Best Parts for a Local RAG Document-QA Workstation in 2026

See our methodology.

Who this guide is for

You have a pile of documents that you cannot, or would rather not, paste into a hosted chatbot: contracts, internal wikis, research PDFs, support tickets, a decade of email exports. You want to ask questions of them in plain English and get answers that quote the source passage. That is retrieval-augmented generation, and in 2026 the software side of it is solved well enough — Ollama exposes an embeddings endpoint built for exactly this pipeline (Ollama — Embeddings), and llama.cpp's server ships embedding and reranking endpoints alongside chat (llama.cpp server README).

The hardware side is where builds go wrong, because RAG splits your budget across three different jobs with three different bottlenecks:

1. Embedding the corpus. A one-time (or occasional) batch pass that turns every chunk of every document into a vector. It is throughput-bound and it loves a GPU.
2. Storing and serving the index. Vectors plus an HNSW or IVF graph, queried on every question. This is a RAM and storage-latency job, and it runs 24/7.
3. Generating answers. An interactive job where the retrieved chunks are stuffed into the prompt. Prefill speed decides how long you wait for the first word; VRAM decides which model you can run at all.

A build tuned for only one of those jobs — a big GPU on a starved host, or a fast CPU with no VRAM — leaves you waiting on the other two. The five picks below are chosen so each job has a part that covers it, and the Best Overall pick is the 12 GB card that makes the generation job cheap: the ZOTAC RTX 3060 Twin Edge OC.

Step 0: size your corpus before you size your build

Do this arithmetic before you open a single product page. It tells you whether you need a GPU for the embedding pass, how much disk the index takes, and which tier of build you are in.

Documents → chunks. Most embedding models cap their input. BGE-large-en-v1.5 takes at most 512 tokens per input (BAAI — bge-large-en-v1.5), and E5-large-v2's model card is explicit that "long texts will be truncated to at most 512 tokens" (intfloat — e5-large-v2). So your chunk size is set by the embedder, not by taste. As a worked example, 2,000 PDFs averaging 30 pages at roughly two 512-token chunks per page is about 120,000 chunks.

Chunks → index footprint. pgvector documents the cost exactly: each vector takes 4 × dimensions + 8 bytes, and a half-precision halfvec takes 2 × dimensions + 8 (pgvector README). A 1,024-dimension embedding is therefore 4,104 bytes, so 120,000 chunks is about 492 MB of raw vectors, or about 247 MB as halfvec. The graph index adds more on top; FAISS's index table puts HNSW at 4·d + M·2·4 bytes per vector (FAISS wiki — Faiss indexes), so an M of 32 adds 256 bytes per vector.

Chunks → embedding-pass hours. The ratio is what matters. Sentence-Transformers' published encoding speeds for msmarco-distilbert-base-v4 are 1,100 documents per second on a V100 versus 70 per second on an 8-core Xeon Platinum 8168 (SBERT — MS MARCO models) — roughly a 16× gap. Whatever your absolute speed, a pass that finishes in one hour on a GPU takes most of a day on CPU cores alone.

If you land in the first row, you can skip the GPU until you want a bigger generator. Everyone else should read on.

Comparison table

Top picks

🏆 Best Overall: ZOTAC Gaming GeForce RTX 3060 Twin Edge OC 12GB

12 GB GDDR6 · 192-bit bus · 3,584 CUDA cores · 170 W

The ZOTAC Gaming GeForce RTX 3060 Twin Edge OC 12GB is the part the whole build hangs on. NVIDIA's specification lists 12 GB of GDDR6 on a 192-bit bus, 3,584 CUDA cores and 170 W of graphics-card power, with a 550 W system power recommendation (NVIDIA — RTX 3060 family specs); TechPowerUp's database confirms the GA106 configuration (TechPowerUp — RTX 3060 12 GB). It launched at $329 (NVIDIA — RTX 3060 announcement).

For RAG, the number that matters most is prompt processing, not generation, because every question arrives with several retrieved chunks attached. LocalScore records 1,488 tok/s of prompt processing and 51.6 tok/s of generation on Llama 3.1 8B Q4_K_M, and 753 tok/s prompt / 26.4 tok/s generation on Qwen2.5 14B Q4_K_M (LocalScore — RTX 3060). Put five 512-token chunks in a prompt — 2,560 tokens — and the 8B model spends about 1.7 seconds on prefill before the first word; the 14B model spends about 3.4 seconds. Both are usable. The llama.cpp community scoreboard shows the same card's raw ceiling at 2,137.5 tok/s prompt and 75.6 tok/s generation on the smaller Llama 2 7B Q4_0 (llama.cpp CUDA scoreboard).

✅ Pros

• 12 GB holds a 14B generator at Q4_K_M (8.99 GB file, per bartowski — Qwen2.5 14B GGUF) with an embedding model resident beside it.
• The GPU embedding pass is where the ~16× GPU-over-CPU gap pays out on a real corpus.
• 170 W board power keeps the PSU and cooling requirements ordinary.
• Mature CUDA support across Ollama, llama.cpp, Sentence-Transformers and text-embeddings-inference.

❌ Cons

• A 14B model leaves little headroom: TYO Lab's 12 GB benchmark set notes that 14B models required --ctx-size 4096 to fit (TYO Lab — 64 GB RAM, 12 GB VRAM), which limits how many chunks you can retrieve per question.
• Ampere-era throughput; newer cards finish the embedding pass faster.
• The RTX 3060 is also sold as an 8 GB variant — confirm the listing says 12 GB.

Buy on Amazon → · See full details →

Price may vary — check the retailer page for current pricing.

💰 Best Value: MSI GeForce RTX 3060 Ventus 2X 12G

12 GB GDDR6 · 192-bit · 170 W · 235 × 124 × 42 mm · 1× 8-pin

The MSI GeForce RTX 3060 Ventus 2X 12G is the same GA106 chip with the same 12 GB, so every number in the pick above applies unchanged. MSI's datasheet for the OC edition lists a 1,807 MHz boost, 15 Gbps memory, 170 W power draw, a single 8-pin connector, a 550 W recommended PSU and a card size of 235 × 124 × 42 mm (MSI — Ventus 2X 12G OC datasheet).

The value argument is about the rest of the build, not the sticker. At 235 mm it fits compact mATX and small-form-factor cases that a triple-fan 3060 does not, and a single 8-pin connector means a basic 550 W unit covers it. For a document-QA box that lives in a closet or under a desk, that can remove a case upgrade from the bill entirely. Street prices between this card and the ZOTAC swap back and forth week to week, so compare both links and buy the cheaper one on the day — the silicon is identical.

✅ Pros

• Same 12 GB, same 170 W envelope, same software support as the Best Overall pick.
• 235 mm length and a 42 mm thickness fit small cases.
• One 8-pin connector and a 550 W PSU recommendation keep the power budget simple.

❌ Cons

• A two-fan cooler on a compact card runs louder under a long embedding pass than larger coolers.
• No performance advantage whatsoever over the ZOTAC — this pick exists only on price and fit.

Buy on Amazon → · See full details →

Price may vary — check the retailer page for current pricing.

🎯 Best for Always-On Retrieval: AMD Ryzen 5 5600G

6 cores / 12 threads · 3.9–4.4 GHz · Radeon Vega 7 · 65 W

The AMD Ryzen 5 5600G is the host CPU for a machine that answers questions around the clock. Tom's Hardware's review lists it at 6 cores and 12 threads, 3.9/4.4 GHz, Radeon Vega 7 graphics and a 65 W TDP, with a $259 launch price (Tom's Hardware — Ryzen 5 5600G review).

Two things make it the right always-on part. First, the integrated GPU drives the monitor, so the RTX 3060's full 12 GB stays available for models — on a CPU without graphics, the desktop takes a slice of VRAM before you load anything. Second, the 65 W envelope suits a box that is idle most of the day and busy for seconds at a time. It also works as a GPU-less starter build for the first corpus tier: CPU embedding is practical at small scale, and Hugging Face's Intel work shows int8-quantized BGE models running up to 4.5× faster than full precision on CPU (Hugging Face — CPU-optimized embeddings).

✅ Pros

• Integrated graphics keep every megabyte of the discrete card free for models.
• 65 W TDP suits 24/7 duty and ordinary air cooling.
• Runs small corpora with no discrete GPU at all.

❌ Cons

• PCIe 3.0 connectivity, flagged as a con in Tom's review, lengthens model loads slightly; it does not affect generation once weights are resident.
• Six cores parse PDFs more slowly than the 5800X on a big re-index.

Buy on Amazon → · See full details →

Price may vary — check the retailer page for current pricing.

⚡ Best Performance: AMD Ryzen 7 5800X

8 cores / 16 threads · 32 MB L3 · 105 W · PCIe 4.0

The AMD Ryzen 7 5800X is the pick when the corpus is large and changes often. AMD lists it at 8 cores and 16 threads, 32 MB of L3, a 105 W default TDP and PCIe 4.0 support, and notes that a discrete graphics card is required (AMD — Ryzen 7 5800X).

The GPU does the embedding math, but everything before it is CPU work: extracting text from PDFs, cleaning it, splitting it into chunks, tokenizing and batching. On a large re-index those stages are what keep the GPU waiting, and two extra cores plus a large L3 help. PCIe 4.0 also leaves a sensible path to a second card later — see the upgrade note below.

✅ Pros

• Most parsing and chunking throughput of the AM4 picks here.
• PCIe 4.0 for faster model loads and a second GPU later.
• 32 MB L3 helps the branchy, cache-sensitive work of document parsing.

❌ Cons

• No integrated graphics: the display runs on the RTX 3060 and takes some VRAM.
• 105 W TDP needs a real tower cooler on an always-on machine.

Buy on Amazon → · See full details →

Price may vary — check the retailer page for current pricing.

🧪 Budget Pick: Kingston A400 960GB SATA SSD

960 GB · up to 500 MB/s read / 450 MB/s write · 300 TBW

The Kingston A400 960GB is the drive that keeps model weights and the vector index off your boot NVMe. Kingston's datasheet lists up to 500 MB/s read and 450 MB/s write for the 960 GB model, a 300 TBW endurance rating, a 3-year warranty and 0.195 W idle power (Kingston — A400 datasheet).

At 500 MB/s, loading the 8.99 GB Qwen2.5 14B file takes about 18 seconds and the 4.92 GB Llama 3.1 8B file about 10 seconds — noticeable if you swap models constantly, irrelevant if the server stays up. A home-scale index of a few hundred thousand chunks is a gigabyte or two, which SATA serves without drama. The Crucial BX500 1TB is a same-class alternative if it is cheaper on the day.

✅ Pros

• Nearly 1 TB for a model library plus indexes.
• 300 TBW is plenty for an index that is rebuilt occasionally.
• Near-zero idle draw for an always-on box.

❌ Cons

• SATA speeds make repeated model swapping slow compared with NVMe.
• DRAM-less budget drive; not the place for a write-heavy database.

Buy on Amazon → · See full details →

Price may vary — check the retailer page for current pricing.

What to look for in a local RAG workstation

VRAM tier versus model size

Puget Systems' rule of thumb is to multiply a model's parameter count in billions by two to get gigabytes at 16-bit precision, and to plan an extra 15% on top of the model itself (Puget Systems — what hardware do you need to run a local LLM). At Q4_K_M the files shrink to the sizes above, but RAG adds residents the chat-only math forgets: the embedder, and often a reranker. BGE-reranker-v2-m3 is a 0.6B-parameter model (BAAI — bge-reranker-v2-m3), about 1.1 GB at 16-bit.

Embedding-model throughput

Smaller embedders are dramatically cheaper to run. BGE-small-en-v1.5 is 384 dimensions and about 33M parameters; BGE-large is 1,024 dimensions and about 335M (BAAI — bge-large-en-v1.5). Nomic-embed-text-v1.5 sits between them at 768 dimensions and about 137M parameters with an 8,192-token context (Nomic — nomic-embed-text-v1.5), and BGE-M3 offers 1,024 dimensions with an 8,192-token context (BAAI — bge-m3). On the GPU, Sentence-Transformers reports fp16 with Flash Attention and unpadding as its fastest configuration, 3.87× over fp32 (SBERT — speeding up inference).

Vector-index storage and IOPS

Use the pgvector formula from Step 0. Halving storage with halfvec is usually free in retrieval quality terms, and it keeps the HNSW graph in RAM on smaller machines — pgvector notes that indexes build significantly faster when the graph fits in maintenance_work_mem.

System RAM for chunking and re-ranking

Puget recommends 1.5–2× as much system RAM as VRAM; for a 12 GB card that is 18–24 GB, which rounds to a 32 GB kit. PDF extraction and index builds are the memory spikes, not inference.

Thermals and noise for an always-on box

A RAG server idles most of the day and bursts for seconds per question. Size cooling for the embedding pass — hours of sustained GPU and CPU load — not for the query traffic.

Upgrade path to 24 GB

When the 14B tier stops being enough, a second 12 GB card is the cheapest route to 24 GB; see the dual RTX 3060 24 GB build guide. A 27B-class model at Q4 does not fit on one 12 GB card, and offloading it to system RAM costs far more speed than it does in chat because RAG prompts are long.

What fits in 12 GB: embedding and generator pairings

Resident weights are file sizes for the generator (bartowski — Llama 3.1 8B GGUF, bartowski — Qwen2.5 14B GGUF) plus 16-bit parameter counts for the embedder and reranker from their model cards; BGE-M3 is Ollama's listed 1.2 GB (Ollama — bge-m3). Index size uses pgvector's 4 × d + 8 bytes per vector. Throughput is LocalScore's RTX 3060 measurement for the generator alone, before KV cache and any co-resident model.

The 8B rows leave generous room for KV cache and long retrieval contexts. The 14B rows trade that room for answer quality; TYO Lab measured Qwen2.5-Coder-14B at 35.8 tok/s with a 4,096-token context on a 12 GB card (TYO Lab), which is roughly the ceiling you should plan around.

Embedding and reranking throughput: what each part does to your index and your queries

Retrieval is two jobs with different bottlenecks. Indexing is a throughput problem: you embed every chunk once (and again whenever you change embedders), in big batches, and nobody is waiting on any single chunk. Reranking is a latency problem: on every question, a cross-encoder rescores the top 20–100 candidates before the generator sees them, and that time lands directly in front of the user. The parts above handle the two very differently.

The GPU advantage grows with the embedder

Hugging Face's static-embeddings benchmark ran each model on the same CPU and the same GPU. The post lists its hardware as an RTX 3090 and an i7-13700K. Throughput is in short sentences per second (Hugging Face — static embeddings):

The pattern decides the build. A small embedder runs acceptably on cores alone, because the gap is "only" 10×. Anything base-sized or larger opens a 16–33× gap, and that's where the RTX 3060 stops being optional. On the CPU side, Sentence-Transformers measured OpenVINO int8 as the fastest backend on that same i7-13700K (SBERT — speeding up inference). Its chart shows a median of about 2.8× over fp32 PyTorch, which is the cheapest speed-up available to a GPU-less box.

Time to index 100,000 chunks on these picks

Real chunks are far longer than benchmark sentences. RunPod measured bge-m3 on 512-token chunks at about 190 per second on an RTX A5000, a workstation card with roughly twice the RTX 3060's memory bandwidth (RunPod — GPU embedding benchmark). That's about a seventh of the sentence rate above. The table below is our estimate, scaled from those two sources:

• RTX 3060 at about 0.4× an RTX 3090 on encoder workloads;
• Ryzen 7 5800X at about half the i7-13700K's multi-threaded throughput, and the 5600G at about three-quarters of the 5800X;
• sentences-to-512-token-chunks at about 8× the cost.

Treat these as ±30%. The spread between rows matters more than any single cell. With bge-small, a CPU-only index of 100,000 chunks is a lunch break. With bge-m3, it's an overnight job on the 5800X and roughly two work-days' worth of hours on the 5600G. On the 3060 it's a coffee break either way. If you re-embed weekly, or plan to try several embedders, that difference is the case for the card.

Rerank latency per query

Cross-encoders cost more per candidate than embedders, because each one reads the query and the passage together. Sentence-Transformers' published speeds show the size tax: ms-marco-MiniLM-L6-v2 scores 1,800 docs/s against 960 for the twelve-layer L12 variant, for an NDCG@10 gain of 0.01 (74.30 vs 74.31) (SBERT — cross-encoder models). Our estimates for rescoring a top-50 candidate list of 256–512-token passages, scaled the same way as the table above:

The practical rule: on a GPU-less build, use a MiniLM-class cross-encoder, or skip reranking and retrieve fewer, better chunks. A 568M reranker on cores adds five to ten seconds to every question, longer than the generator's own time to first token on the 3060.

Don't assume the bigger reranker is better, either. In Qwen's own evaluation table, BGE-reranker-v2-m3 scored 57.03 on MTEB-R, below the 61.82 of plain Qwen3-Embedding-0.6B retrieval with no reranker. Qwen3-Reranker-0.6B, the same size, lifted it to 65.80 (Qwen — Qwen3-Reranker-0.6B). Rerank gains depend on the pairing and the domain. Measure recall on a hundred of your own questions before you pay latency for a reranker.

The Raspberry Pi tier

A Raspberry Pi 4 Model B 8GB can run a small embedder for a personal notes or email index at a few watts. We found no public embedding measurement for it. Four Cortex-A72 cores sit far below the desktop CPUs above, so treat it as an ingest appliance that embeds new documents as they arrive. It's not an interactive search box, and a full re-index of a large corpus is measured in days. For anything past a personal archive, the 5600G is the cheapest real retrieval host in this guide.

Common pitfalls

• Chunks longer than the embedder's window. Anything past 512 tokens on BGE-large or E5-large-v2 is silently truncated, so the tail of every oversized chunk never makes it into the index.
• Changing the embedding model without re-indexing. Query vectors and document vectors must come from the same model. Swapping embedders means a full re-embed.
• One server for everything. llama.cpp's --embedding flag restricts a server instance to the embedding use case, so plan on separate instances for the embedder and the chat model.
• Retrieving too many chunks. Twenty 512-token chunks is 10,240 prompt tokens — about 13.6 seconds of prefill on a 14B model at 753 tok/s before the first word appears.
• Index on the boot drive. Put weights and indexes on a dedicated SSD so a reinstall or a full boot disk never takes the knowledge base with it.

Related guides

• Best GPU for local LLMs in 2026
• Best SSD for local LLM model storage in 2026
• Best budget local LLM workstation components in 2026
• Best always-on local LLM server parts in 2026
• Local RAG on private data: RTX 3060 vs frontier models
• RTX 3060 benchmark data · ZOTAC vs MSI RTX 3060 12 GB, live prices · Ryzen 5 5600G vs Ryzen 7 5800X, live prices
• Iris-mini vs Iris-pro on an RTX 3060 12GB: which open-weight search agent fits 12 GB

Citations and sources

1. LocalScore — RTX 3060 accelerator page — Llama 3.1 8B Q4_K_M 1,488 tok/s prompt / 51.6 tok/s generation; Qwen2.5 14B Q4_K_M 753 / 26.4 tok/s. (accessed 2026-09-10)
2. llama.cpp CUDA performance scoreboard — RTX 3060 Llama 2 7B Q4_0 pp512 2,137.5 tok/s, tg128 75.6 tok/s. (accessed 2026-09-10)
3. TYO Lab — 64 GB RAM, 12 GB VRAM: the honest local LLM benchmark — 14B models at --ctx-size 4096; Qwen2.5-Coder-14B 35.8 tok/s. (accessed 2026-09-10)
4. bartowski — Meta-Llama-3.1-8B-Instruct-GGUF — Q4_K_M 4.92 GB. (accessed 2026-09-10)
5. bartowski — Qwen2.5-14B-Instruct-GGUF — Q4_K_M 8.99 GB. (accessed 2026-09-10)
6. NVIDIA — GeForce RTX 3060 family specifications — 12 GB GDDR6, 192-bit, 3,584 CUDA cores, 170 W, 550 W system power. (accessed 2026-09-10)
7. NVIDIA — GeForce RTX 3060 announcement — $329 launch price. (accessed 2026-09-10)
8. TechPowerUp — GeForce RTX 3060 12 GB — GA106 configuration. (accessed 2026-09-10)
9. MSI — GeForce RTX 3060 Ventus 2X 12G OC datasheet — 235 × 124 × 42 mm, 1× 8-pin, 550 W PSU. (accessed 2026-09-10)
10. Tom's Hardware — AMD Ryzen 5 5600G review — 6C/12T, 65 W, Vega 7, $259, PCIe 3.0. (accessed 2026-09-10)
11. AMD — Ryzen 7 5800X — 8C/16T, 32 MB L3, 105 W, PCIe 4.0. (accessed 2026-09-10)
12. Kingston — A400 datasheet — 500/450 MB/s, 300 TBW, 0.195 W idle. (accessed 2026-09-10)
13. Puget Systems — what hardware do you need to run a local LLM — 2× parameters rule, +15% overhead, 1.5–2× RAM vs VRAM. (accessed 2026-09-10)
14. BAAI — bge-large-en-v1.5 — 1,024 dim, 512 tokens; bge-small 384 dim. (accessed 2026-09-10)
15. intfloat — e5-large-v2 — 512-token truncation. (accessed 2026-09-10)
16. Nomic — nomic-embed-text-v1.5 — 768 dim, 8,192 context. (accessed 2026-09-10)
17. BAAI — bge-m3 — 1,024 dim, 8,192 tokens. (accessed 2026-09-10)
18. Ollama — bge-m3 — 1.2 GB. (accessed 2026-09-10)
19. BAAI — bge-reranker-v2-m3 — 0.6B parameters. (accessed 2026-09-10)
20. SBERT — MS MARCO models — 1,100 vs 70 docs/s, V100 vs 8-core Xeon. (accessed 2026-09-10)
21. SBERT — speeding up inference — fp16 + Flash Attention 3.87× over fp32. (accessed 2026-09-10)
22. Hugging Face — CPU-optimized embeddings — int8 up to 4.5× faster. (accessed 2026-09-10)
23. pgvector README — 4 × d + 8 bytes per vector, 2 × d + 8 for halfvec. (accessed 2026-09-10)
24. FAISS wiki — Faiss indexes — HNSW memory per vector. (accessed 2026-09-10)
25. Ollama — Embeddings — embeddings endpoint for RAG pipelines. (accessed 2026-09-10)
26. llama.cpp server README — --embedding and /rerank. (accessed 2026-09-10)
27. Hugging Face — static embeddings — CPU vs GPU sentences/s per embedder; RTX 3090 / i7-13700K test box. (accessed 2026-09-18)
28. RunPod — GPU embedding workloads benchmark — bge-m3 on 512-token chunks, ~190/s on RTX A5000. (accessed 2026-09-18)
29. SBERT — cross-encoder pretrained models — MiniLM-L6 1,800 vs L12 960 docs/s, NDCG@10 74.30 vs 74.31. (accessed 2026-09-18)
30. Qwen — Qwen3-Reranker-0.6B — MTEB-R 61.82 baseline, 57.03 bge-reranker-v2-m3, 65.80 Qwen3-Reranker-0.6B. (accessed 2026-09-18)

Prices and availability change frequently — the price shown on the retailer page at the time of your visit is authoritative. As an Amazon Associate, SpecPicks earns from qualifying purchases.

This piece is editorial synthesis based on publicly available information. No independent first-party benchmarking is reported.

— Mike Perry