RAG System on Corporate Documents: What the Project Includes and What It Costs

A corporate RAG system (Retrieval-Augmented Generation) is not "upload a PDF to ChatGPT" - it is infrastructure that indexes policies, contracts, instructions, and knowledge bases, finds relevant fragments, and generates answers with source citations. In 2026, this is the standard for internal assistants, support, and compliance queries. Below are project scope, stages, timelines, and realistic budget ranges.

• MVP on one source (Confluence, SharePoint, PDF folder) - $8,000 - $25,000, 4-8 weeks
• Corporate RAG platform (multiple sources, RBAC, audit) - $35,000 - $120,000, 3-5 months
• Enterprise: on-prem, DLP, SLA, multilingual - $120,000 - $350,000+, 6-10 months
• Monthly costs - embeddings, LLM API, vector DB, reindexing: from $300 to $12,000+
• Main price driver - not the model (GPT-5.6 Terra, Claude Sonnet 5, Gemini 3.5 Flash), but retrieval quality and depth of document workflow integrations

What RAG on Corporate Documents Means

RAG augments an LLM with search over your data: the model does not "remember" the vacation policy - it receives relevant paragraphs from a vector index and builds an answer from them. For business, this reduces hallucinations and provides verifiable links to the source.

Typical corporate scenarios:

• an employee asks about contract approval procedure - the system finds the section in Confluence and cites the clause;
• a support agent gets a draft answer from an up-to-date Zendesk knowledge base;
• legal searches precedents in a contract archive with filters by counterparty type and date.

Without RAG, a corporate chatbot either answers in generalities or "invents" internal rules. With RAG, the answer is tied to documents that can be opened and verified.

What the Project Includes

An RAG project splits into eight blocks. Each affects timeline and budget.

Turnkey means: the system indexes agreed sources, answers in target channels, logs queries, passes pilot, and is handed over with reindexing documentation.

Development Stages

1. Data Audit and Specifications (1-2 weeks)

You define:

• which sources to connect (Confluence, Notion, SharePoint, local PDFs, wiki, CRM);
• volume: number of documents, update frequency, languages;
• access: SSO, RBAC, separate indexes per department;
• metrics: precision@k, share of answers with correct citation, response time, CSAT.

Output: source map, access rights matrix, list of "golden" eval questions (50-200 from real employee practice).

2. Ingestion Prototype (2-4 weeks)

Connect the first source and verify the full cycle:

• export or webhook on document change;
• parsing (HTML, DOCX, PDF, tables);
• chunking: fragment size, overlap, preserving headings and hierarchy;
• write to vector DB with metadata (department, date, author, tag).

Typical stack: LangChain / LlamaIndex, Unstructured, Apache Tika, connectors to SharePoint Graph API and Confluence REST.

3. Retrieval and Search Quality (3-6 weeks)

Core engineering work:

• embedding model: OpenAI text-embedding-3-large, Cohere, local bge-m3 / e5 for on-prem;
• vector DB: pgvector, Qdrant, Weaviate, Milvus, Pinecone;
• hybrid search: keyword + semantic for exact SKUs, contract numbers, article codes;
• reranker: Cohere Rerank, cross-encoder, bge-reranker - improves accuracy by 15-30%;
• filters: user sees only documents for their department.

Without iterations on the eval set, retrieval "almost works" in demo and breaks on real questions.

4. Generation and Guardrails (2-4 weeks)

• system prompt with "answer only from context" rule;
• citations: link to document, page, anchor;
• "don't know" answer on low retrieval score;
• prompt injection protection via documents;
• model routing: Gemini 3.5 Flash / GPT-5.6 Luna for simple queries, Terra / Claude Sonnet 5 for complex ones.

5. Integrations and Interface (2-6 weeks)

• widget on intranet, bot in Slack/Teams/Telegram;
• SSO (SAML, OIDC), query log for compliance;
• admin panel: indexing status, manual reindex, view of "bad" answers;
• API for embedding in CRM, ticket system, IDE.

6. Pilot and Production (2-4 weeks)

• regression on eval dataset after each release;
• pilot on one department (50-200 users);
• latency, token cost, quality drift monitoring;
• runbook: what to do when a source fails, how to add a new wiki section.

Cost Ranges by Project Type

1. MVP - One Source, Internal Pilot

Suitable for testing the hypothesis that "employees will stop searching wiki manually." Limits: one language, basic citations, manual reindex or daily cron.

2. Corporate RAG Platform

Standard for mid-size and large business: HR, IT, support, sales on one platform but see different document slices.

3. Enterprise

Banks, telecom, pharma, public sector. A significant share goes to security, pentest, legal approval, redundancy, and self-hosted embeddings when data must not leave the perimeter.

Monthly Costs (OPEX)

Example: 5,000 documents, 3,000 queries/month, Terra + pgvector + rerank:

• Embeddings (10% reindex/month): ~$40
• LLM (2,500 input + 600 output tokens per query): ~$60-90
• Infrastructure: ~$150-250
• Total: ~$250-400/month

At 50,000 queries/month and enterprise SLA, OPEX easily reaches $3,000 - $12,000/month. Plan TCO for 18-24 months, not just one-time development.

Timeline and Team

Rates in 2026 (remote, Eastern Europe / CIS): ML/RAG specialist $60-100/h, backend $45-80/h, DevOps $50-90/h. US or Western Europe teams - multiply by 2-3.

Timelines grow not from "connecting OpenAI API" but from dirty data (outdated wiki, scans without OCR, duplicates), access approvals for internal systems, and quality iterations on real employee questions.

What Increases Project Cost

Many formats and legacy. Scanned PDFs without text layer, nested Excel tables, old HTML in Confluence - each format needs a separate parser and tests.

Document-level RBAC. User A must not see a fragment from a closed contract. Index filters, AD/SharePoint rights sync, audit - +20-35% to budget.

Multilingual. Separate indexes or multilingual embeddings, eval per language, local stop words. +25-40% for 3+ languages.

Real-time updates. Webhook on every wiki save vs nightly batch - different queue architecture and ingestion cost.

On-prem and air-gap. Self-hosted LLM (Llama 4, Qwen 3.7), local embeddings, GPU - +$500-3,000/month infrastructure, but mandatory for regulated industries.

How Not to Overpay

1. Start with one department and one source - HR or IT support on Confluence, 30-50 reference questions.
2. Eval from week one - without a dataset you pay for endless "chunk size tweaks."
3. Hybrid search with rerank - cheaper than LLM fine-tuning at start; add fine-tuning when RAG hits a ceiling.
4. Model routing - Flash/Luna for FAQ, Terra/Sonnet for complex multi-hop questions.
5. Cache frequent queries - semantic cache cuts API by 20-40%.
6. Fixed MVP, T&M for new sources - price each new connector (SAP, ERP) separately.

When RAG Doesn't Fit

• Fewer than 20-30 documents that rarely change - a plain FAQ or knowledge base is simpler; RAG infrastructure won't pay for itself.
• No one to maintain the sources - if nobody keeps documents current and monitors answer quality after launch, the system goes stale fast and loses employee trust.
• You need a precise calculation or an action, not a text answer - RAG is strong for search and explanations over documents, but it doesn't replace workflow automation or direct ERP/CRM integration for executing operations.
• Budget and timeline only allow a two-week pilot - even an MVP needs 4-8 weeks and $8,000+; if that's not workable, start with an off-the-shelf FAQ chatbot instead of full RAG.

Summary

A RAG system on corporate documents in 2026 costs from $8,000 (MVP on one wiki) to $350,000+ (enterprise with on-prem and compliance). Timelines - from 4-8 weeks to 10 months. Main drivers: number and quality of sources, access rights requirements, retrieval accuracy, and traffic volume. The LLM is only part of OPEX; ingestion and search quality determine whether the system is useful or "a pretty demo with hallucinations."

Start with an eval set of real employee questions, one source, and measurable metrics - that makes it easier to justify budget and scale without rewriting architecture.

Current guides on service pricing - on the pricing page.

If you need help with development, AI implementation, or website support for your project - contact me.

Frequently Asked Questions

How does RAG differ from fine-tuning a model on documents?

Fine-tuning embeds knowledge in model weights: expensive to update on every policy change, hard to cite sources. RAG stores documents separately, finds current fragments on query, and injects them into context - knowledge updates via reindexing in minutes or hours. For corporate documents with frequent edits, RAG is almost always better at start; fine-tuning makes sense for a narrow answer format or token savings at millions of similar queries.

Can you build RAG on ChatGPT Enterprise or Copilot without development?

For simple cases - partially. Uploading files to Custom GPT or Microsoft Copilot works for a pilot on hundreds of documents. Limits: weak control over chunking and retrieval, complex RBAC, no custom eval, vendor lock-in, volume and internal DMS integration limits. For production with thousands of documents, SSO, audit, and SLA you need a custom RAG platform or boxed solution with customization - from $35,000 and up.

How many documents can a typical project handle?

MVP comfortably handles 500-5,000 documents (or up to 50,000 pages) on managed vector DB. Corporate platform scales to 100,000+ documents with sharding, hybrid search, and batch ingestion. The bottleneck is less vector storage than parsing quality and rerank latency on a large index. OCR archives at millions of pages are a separate ingestion project with +30-50% budget.

How to measure RAG quality before launch?

Build an eval dataset: 50-200 real questions with reference documents/paragraphs. Metrics: recall@k (was the right fragment in top-k), faithfulness (answer matches context), citation accuracy (link points to the right place). Run the set after every chunking, embedding, or rerank change. Production target: recall@5 above 85% on key topics, faithfulness above 90% on pilot.

What does post-launch support include?

Typical retainer $1,000 - $5,000/month (small/mid project) or 15-25% of development cost per year: quality monitoring, eval updates, connector fixes when source API changes, new wiki sections, prompt tuning, latency and API cost alerts. Reindexing on mass document updates (new policy, Confluence migration) is often a separate sprint. Without support, RAG degrades in 3-6 months: sources change, quality drops unnoticed until user complaints.

Terms in this article

RAG — Retrieval-Augmented Generation

MVP — Minimum Viable Product

on-prem — software hosted in your own infrastructure

SLA — Service Level Agreement

embeddings — numeric vectors that capture text meaning

DLP — Data Loss Prevention

vector db — database for similarity search over embeddings

LLM API — HTTP API to call a large language model

retrieval — finding relevant context before generation

Confluence — Atlassian wiki for team documentation

knowledge base — structured repository of answers/docs

Zendesk — customer support and helpdesk platform

chatbot — conversational bot interface

hybrid search — keyword plus vector search together

query expansion — broaden a query to improve recall

chunking — splitting documents into retrieval-friendly pieces

reranking — reordering search results by relevance

CRM — Customer Relationship Management

guardrails — rules and filters that keep AI outputs safe and on-policy

observability — logs, metrics and traces to understand system behavior

ETL — Extract, Transform, Load

ERP — Enterprise Resource Planning

pipeline — sequence of processing stages

fallback — backup path used when the primary option fails

OCR — Optical Character Recognition

headless — backend CMS/API without a built-in public frontend

widget — embedded UI component

LlamaIndex — framework for connecting LLMs to private data

LangChain — framework for building LLM applications

cross-encoder — rerank model that scores query and document together

RBAC — Role-Based Access Control

webhook — HTTP callback when an event happens

prompt injection — attack that manipulates model behavior via input

CSAT — Customer Satisfaction Score

system prompt — hidden instructions that steer the model for a task

SSO — Single Sign-On

overlap — shared tokens between adjacent chunks

pgvector — PostgreSQL extension for vector search

Pinecone — managed vector database for similarity search

reranker — model that reorders search hits by relevance

Qdrant — vector database for similarity search

regression — bug where a previously working feature breaks again

audit trail — verifiable history of actions and changes

latency — delay before a response arrives

self-hosted — software you run on your own servers

SAML — Security Assertion Markup Language

OIDC — OpenID Connect

runbook — step-by-step playbook for incidents and operations

retainer — fixed monthly fee for ongoing support

SIEM — Security Information and Event Management

HIPAA — Health Insurance Portability and Accountability Act

GDPR — General Data Protection Regulation

part-time — partial work capacity

VPC — Virtual Private Cloud

worker — background job processor

frontend — client-side UI of a site or app

fine-tuning — additional training of a model on domain data

backend — server-side logic, APIs and data layer

workflow automation — chaining steps and tools without manual handoffs

real-time — processed with minimal delay

OPEX — operating expenses

DevOps — Development and Operations

TCO — Total Cost of Ownership

multi-hop — multi-step retrieval or reasoning

air-gap — physical or logical isolation from the public internet

ML — Machine Learning

vendor lock-in — hard to leave a vendor without costly rewrite

GPU — Graphics Processing Unit

citation accuracy — citations point to the right place

production — live environment serving real users

faithfulness — how well an answer sticks to the retrieved sources

T&M — time and materials billing

sharding — splitting data across shards

GPT — Generative Pre-trained Transformer