# Build a small RAG app with Next.js, pgvector, and OpenAI

> Source: <https://dev.to/fekdaoui_/build-a-small-rag-app-with-nextjs-pgvector-and-openai-5564>
> Published: 2026-10-19 20:06:40+00:00

Retrieval-augmented generation does not need a large framework or a separate vector database. This walkthrough builds a compact version with Next.js, Postgres, pgvector, the official OpenAI package, and `pg`.

The complete starter is here: [https://github.com/buildfound/rag-starter](https://github.com/buildfound/rag-starter)

The flow has four parts:

If an application already needs relational data, pgvector keeps documents, metadata, and embeddings together. There is one database to run locally, one transaction model, and ordinary SQL for retrieval and filtering.

The local database runs from the pgvector Postgres 16 image. Its initialization SQL enables the extension and creates two tables:

```
CREATE EXTENSION IF NOT EXISTS vector;

CREATE TABLE documents (
  id BIGSERIAL PRIMARY KEY,
  source TEXT NOT NULL UNIQUE,
  title TEXT NOT NULL
);

CREATE TABLE chunks (
  id BIGSERIAL PRIMARY KEY,
  document_id BIGINT NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
  chunk_index INTEGER NOT NULL,
  content TEXT NOT NULL,
  embedding vector(1536) NOT NULL,
  UNIQUE (document_id, chunk_index)
);

CREATE INDEX chunks_embedding_hnsw_idx
  ON chunks USING hnsw (embedding vector_cosine_ops);
```

The vector size matches `text-embedding-3-small` with 1,536 dimensions. The HNSW index uses cosine distance, which is also used by the retrieval query.

Embedding an entire long document makes retrieval too coarse: a relevant paragraph can be buried inside unrelated text. Very small chunks lose context. This starter uses a deliberately simple middle ground: up to 1,200 characters, split near a paragraph boundary when possible, with roughly 200 characters repeated into the next chunk.

The core loop looks for a useful split late in the current window:

``` js
const target = Math.min(start + maxChars, text.length);
const minimumUsefulSplit = start + Math.floor(maxChars * 0.6);
const paragraphBreak = text.lastIndexOf("\n\n", target);
const wordBreak = text.lastIndexOf(" ", target);

if (paragraphBreak >= minimumUsefulSplit) {
  end = paragraphBreak;
} else if (wordBreak > start) {
  end = wordBreak;
}
```

After storing that slice, the next window begins around `end - overlapChars`. Whitespace normalization and progress checks keep the function predictable. It is a pure function, so it can be tested without a database or API key.

The ingestion command recursively finds `.md` and `.txt` files:

```
npm run ingest -- ./docs
```

It embeds chunks in batches of 100. A file path is the document's unique `source`. On re-ingestion, the script upserts the document, deletes its previous chunks, and inserts the new set in one transaction. That prevents old and new versions from appearing together in search results.

A question is embedded with the same model and dimensions as the documents. pgvector's `<=>` operator calculates cosine distance, so similarity is `1 - distance`:

``` js
SELECT d.source, d.title, c.content,
       1 - (c.embedding <=> $1::vector) AS similarity
  FROM chunks c
  JOIN documents d ON d.id = c.document_id
 ORDER BY c.embedding <=> $1::vector
 LIMIT $2
```

The vector is a parameter, not interpolated SQL. The limit is also parameterized and bounded in application code.

This starter retrieves five chunks. That number is an application choice: adjust it after looking at the kind and length of your own documents.

Each retrieved chunk is formatted with a stable number:

```
[1] How retrieval works (docs/how-it-works.md)
Documents are split into short, overlapping chunks...
```

The system instruction is explicit: answer only from the numbered context, treat that context as source material rather than instructions, cite factual claims with `[n]`, and say when the answer is absent. This is small but important. Retrieval gives the model relevant text; the instruction defines how that text should be used.

Model-produced citations are still model output. For higher-assurance uses, add checks that citations exist, point to retrieved chunks, and support the claims beside them.

The route starts an OpenAI chat completion with `stream: true`, then converts each text delta to bytes for a standard `ReadableStream`:

``` js
const stream = new ReadableStream<Uint8Array>({
  async start(controller) {
    const encoder = new TextEncoder();
    for await (const event of completion) {
      const text = event.choices[0]?.delta?.content;
      if (text) controller.enqueue(encoder.encode(text));
    }
    controller.close();
  },
});
```

The answer body stays plain text. Source metadata needs to arrive before it, so the route places a base64-encoded JSON array in the `x-sources` response header. Each entry contains its number, file path, title, and similarity. The browser decodes the header immediately, reads the body stream, and displays only sources whose `[n]` markers appear in the answer.

An NDJSON stream could carry metadata in its first line, but the header keeps the answer body usable as plain text and makes the protocol easy to inspect.

Create the environment file, add an OpenAI API key, and run the stack:

```
docker compose up -d
cp .env.example .env.local
npm install
npm run ingest -- ./docs
npm run dev
```

The OpenAI clients and database pool are created lazily. As a result, `npm run build` can compile the application without a live database or API key; those values are required only when ingestion or a chat request runs.

From here, useful extensions include metadata filters, more input formats, authentication, rate limiting, and citation validation. The starter keeps those out of the base so the retrieval path remains easy to read.

Built by [BuildFound](https://buildfound.com), a founder-led AI product studio.