Give your team accurate answers, grounded in your own data.
We build permission-aware retrieval systems for internal knowledge, support, and research — with citations back to source and access control built in from day one.
Most internal search is poor for a simple reason: the answers live in many places, in many formats, behind different permissions. Enterprise RAG puts one retrieval layer over those sources and has a model answer only from what it finds, with citations to the source. Whether it works depends less on the model you pick than on retrieval quality, permissions, freshness and how you measure it.
That is where we spend our effort. A system that returns the wrong passage, shows a document to someone who should not see it, or cites a source that does not say what the answer claims will lose trust quickly. The sections below set out how we build against each of those failures. For a deeper technical walk-through, read our enterprise RAG architecture guide.
Where we focus
Tailored to your systems and data, but these are the core building blocks.
Permission-aware retrieval
Answers respect the same access controls as your source systems — no accidental leaks.
Internal knowledge & enterprise search
One retrieval layer across docs, wikis, and databases instead of five separate search boxes.
Document Q&A with citations
Every answer traces back to its source, so it can actually be verified.
Access control & evaluation
Built-in evaluation loops to catch hallucinations before they reach a user.
Why enterprise RAG disappoints, and what we do about each cause
Most failed RAG projects fail in retrieval or permissions, not in the model. These are the usual causes.
| What users see | Usual cause | What we do |
|---|---|---|
| The answer ignores the right document | Chunks lost their context, or search missed an exact term such as an ID or error code | Add context to chunks, combine semantic and keyword search, and rerank the results |
| Someone sees content they should not | Permissions were applied after retrieval, or not synced from the source | Enforce access at query time using permissions carried with every chunk |
| The answer is out of date | The index is not refreshed when sources change | Continuous sync with deletes and updates, and a visible last-updated date |
| A confident answer with a wrong or missing citation | The model answered beyond the evidence | Answer only from retrieved passages, check citations, and say so when evidence is missing |
| Answers are slow or expensive | Too much text sent to the model on every query | Retrieve fewer, better passages, and cache what repeats |
Security teams should note that OWASP's 2025 list of risks for LLM applications includes sensitive information disclosure and, new that year, vector and embedding weaknesses. Weak access control at the retrieval layer is a common route to both.
How we build retrieval that finds the right passage
Each stage has one job, and each is tested on your own documents rather than assumed to work.
| Stage | What we do | Why it matters |
|---|---|---|
| Ingest and parse | Read documents, tables, PDFs and pages, keeping structure and source details | Poor parsing, such as broken tables, cannot be fixed later |
| Chunk with context | Split text sensibly and prepend a short explanation of where each chunk comes from | A chunk that says the company grew 3% is useless without knowing which company and quarter |
| Hybrid search | Combine semantic search with keyword search, and merge the results | Semantic search can miss exact identifiers that keyword search finds |
| Rerank | Score a wider set of candidates and pass only the best to the model | Better answers with less text, so lower cost and latency |
| Generate with citations | Answer only from the passages, and link each claim to its source | Lets people verify, and builds trust |
| Decline when unsure | Say the sources do not contain the answer instead of guessing | A refusal costs less than a confident wrong answer |
Anthropic's published tests of this approach found that adding context to chunks cut failed top-20 retrievals by 49 percent, and by 67 percent with reranking added, in their test set. Results vary by data, which is why we measure on yours. They also point out that a knowledge base under roughly 200,000 tokens, about 500 pages, can simply go in the prompt with caching and may not need RAG at all, a point we will raise with you if it applies.
Making sure answers respect who is asking
An internal assistant must not become a way around your access controls. The right approach depends on how your sources manage permissions.
| Approach | How it works | Trade-off |
|---|---|---|
| Permission metadata filtered at query time | Each chunk carries the users or groups allowed to see it, and the search only considers allowed chunks | Needs permissions synced from the source and kept current |
| Separate indexes per team or tenant | Each group has its own index | Strong isolation, but more to run and duplicate content |
| Check access against the source at answer time | Confirm the user can open each cited document before showing it | Most accurate, at the cost of extra calls and latency |
| Filtering results after generation | Remove disallowed content from the answer afterwards | We avoid this on its own, because restricted text has already reached the model |
We usually combine a query-time filter with a source check on the final citations, and test it with accounts that should and should not see specific documents.
How we know the answers are good before users do
We build a test set of real questions with known good sources and answers, and score every change against it.
| Measure | What it tells you | How we check it |
|---|---|---|
| Retrieval failure rate | How often the right passage is missing from the top results | Compare retrieved passages with the known source for each test question |
| Groundedness | Whether every claim in the answer is supported by the cited text | Review samples, with automated checks to flag unsupported claims |
| Answer correctness | Whether the final answer is right | Score against reference answers written by your experts |
| Citation accuracy | Whether each citation points to the right place | Check that the cited passage supports the claim |
| Correct refusals | Whether it declines when the answer is not in the sources | Include unanswerable questions in the test set |
| Latency and cost | Response time and spend per query | Track p50 and p95 latency and tokens per answer |
The same test set runs after every change to chunking, models or prompts, so quality does not drift unseen. Our guide to evaluating AI agents for production covers the approach in more detail.
Choosing where the vectors live
We pick the storage layer to fit your scale and your existing stack, not the other way round.
| Option | Fits when | Watch for |
|---|---|---|
| PostgreSQL with pgvector | You already run Postgres, the corpus is moderate, and you want permissions and metadata in plain SQL | Very large corpora and heavy query loads need careful tuning |
| A managed vector database such as Pinecone | You want managed scale and low operational load | Another system to secure, and permissions must be synced into it |
| Weaviate | You want an open-source vector database with built-in hybrid search | You take on hosting unless you use a managed offering |
| A search engine with vector support | You already run a search platform and want one system for keyword and semantic search | Tuning relevance across both takes effort |
For the trade-offs in depth, read Production RAG with PostgreSQL and pgvector and RAG knowledge base tools: build vs buy. For the delivery side, see our RAG knowledge systems service.
Real numbers from named engagements.
Every figure links to the case study or source behind it.
Common questions about this work.
Straight answers, grounded in what we've actually shipped.
What is enterprise RAG?
Retrieval-augmented generation connects a language model to your own documents and data. The system finds the relevant passages for each question and has the model answer from them, with citations, instead of relying on what it learned in training.
Do we need RAG, or can we put our documents in the prompt?
If your knowledge base is small, roughly under 200,000 tokens or about 500 pages, putting it in the prompt with caching can work well and is simpler. RAG earns its place when the content is larger, changes often or needs permissions applied per user.
Should we use RAG or fine-tune a model?
For knowledge that changes and needs citations, RAG is usually the better fit. Fine-tuning suits changing a model's style or behaviour more than teaching it facts. We explain the trade-offs in our guide to RAG versus fine-tuning.
How do you stop the system showing people documents they should not see?
We carry each document's permissions with its chunks and enforce them at query time, then check the final citations against the source. We test with accounts that should and should not have access.
How do you reduce hallucinations?
By answering only from retrieved passages, requiring a citation for each claim, checking those citations, and declining to answer when the sources do not contain the information. We measure groundedness on a test set.
How do you keep the knowledge up to date?
We sync from your source systems on a schedule or on change events, handle updates and deletions, and show when content was last refreshed.
Can it run in our own cloud environment?
In most cases yes. We can deploy inside your AWS or other cloud account so data stays within your boundary. Data handling and compliance requirements are confirmed during discovery.
Have a workflow worth automating?
Tell me what's slow, manual, or fragile today, and I'll help you figure out the smartest first build.