Naive RAG: Basic Retrieve-Then-Generate

Naive RAG is the baseline architecture every other one in this taxonomy is a variation on or improvement over. It retrieves documents purely based on vector similarity between the query's embedding and the stored document embeddings — embed the query, run a nearest-neighbor search against the vector store, take the top-k matches, drop them into the prompt alongside the original query, and generate a response in a single pass.

There's no validation step, no iteration, no decision-making about whether retrieval was even necessary or whether the results were actually good — the pipeline runs the same fixed sequence every time, regardless of query. This works best for simple, fact-based queries where the query and the answer are semantically close enough that direct similarity matching reliably surfaces the right context ('What is the return policy?' against a document that literally discusses return policy).

Naive RAG's weaknesses are exactly what motivate every other architecture in this taxonomy: it retrieves once and generates once, so if the retrieved context isn't actually sufficient, there's no mechanism to notice or go get more. It doesn't validate whether retrieved chunks are actually relevant before using them — irrelevant context gets passed straight to the LLM. And it has no adaptability: the same fixed retrieve-then-generate flow runs whether the query is a trivial fact lookup or a complex multi-hop question that genuinely needs several retrieval rounds.

Despite these limitations, Naive RAG is still the right starting point for most systems. It's the cheapest and fastest architecture to build and run, and the standard, pragmatic approach is exactly what this topic's own comparison table recommends: start at Naive RAG as your baseline, and move to a more sophisticated architecture only once you hit a documented failure mode that a specific, more complex architecture is designed to solve — not before.

from openai import OpenAI

client = OpenAI()

def embed(text: str) -> list[float]:
    return client.embeddings.create(model="text-embedding-3-small", input=text).data[0].embedding

def naive_rag(query: str, vector_store, top_k: int = 3) -> str:
    # 1) Embed the query
    query_embedding = embed(query)

    # 2) Retrieve by similarity — single pass, no validation, no iteration
    results = vector_store.similarity_search(query_embedding, k=top_k)
    context = "\n\n".join(r.text for r in results)

    # 3) Generate once, using whatever was retrieved
    resp = client.chat.completions.create(
        model="gpt-4.1",
        messages=[{"role": "user", "content": f"Context:\n{context}\n\nQuestion: {query}"}],
    )
    return resp.choices[0].message.content