For Technical architect · Platform engineer · Service owner · SIRO
Key points
- Some of the most consequential failures in a public-service assistant, such as citing superseded rules or disclosing restricted documents, can arise from the content and retrieval arrangements even when the model performs well against its own tests. The collection behind it should be treated as a data product, with named owners, a metadata contract and a defined lifecycle.
- Metadata carries authority, timeliness and permission into retrieval. For policy and guidance collections, a workable minimum is owner, status, effective dates, audience, security classification and handling caveats, jurisdiction where guidance differs across the UK, and a stable identifier, and only documents from an approved publishing route should enter the collection.
- For guidance with serious consequences, index synchronisation should not decide when a withdrawal takes effect. One proposed application-level design checks each retrieved document against an authoritative publication register before the model sees it, and fails closed when the register cannot be read or a document's identity or version cannot be established. This is not a guarantee supplied by Bedrock.
- The application remains responsible for authenticating users and should fail closed when an authorisation check errors. In a customer-managed knowledge base, metadata filters protect nothing unless they come from a verified identity and an independent authorisation decision, and AWS states that ACL-aware retrieval in a Bedrock Managed Knowledge Base is filtering, not a security boundary.
- Retrieved text must be handled as data that never gains the authority of system instructions or the ability to call tools, because, as the NCSC has argued, prompt injection may never be fully mitigated in the same way as SQL injection. A grounding check cannot show that passages were authoritative, current or safe.
- Evaluate retrieval and generation separately, and keep ingestion manifests and per-answer retrieval records, so that when an answer is wrong the organisation can find out why, correct the source and show that it has done so. Most of this work concerns the collection rather than the model.
A convincing demonstration can conceal problems in the information on which an AI assistant depends. A model may retrieve a plausible passage and construct a fluent answer, while the underlying document has lost its authority, its access restrictions or the context needed to interpret it correctly. In a public service, those defects become operational questions about the provenance of guidance, the rights of the person asking and the ability of the organisation to reconstruct and correct what happened.
Consider a more current, and hypothetical, version of the same problem. A council builds an assistant to help staff answer residents' questions from its policies and correspondence. One day it answers confidently from a housing allocation policy that was superseded three months earlier, because the old document was never removed from the index. A week later it retrieves a passage from a legitimate-looking uploaded PDF that contains hidden instructions, and its answer starts recommending a course of action nobody in the council approved. Neither failure involves a faulty model. The first is a problem of authority and freshness, and the second is a problem of hostile content entering the collection, and this article returns to both.
That pattern is not unusual, and it applies with particular force to retrieval-augmented generation, the pattern now behind many document assistants, policy chatbots and casework search tools in government. This article sets out why RAG should be treated as a data product with its own owners, quality measures and lifecycle, what that product has to achieve, and how to engineer it, using GOV.UK Chat as the best documented public example, and then sets out how the same product can be built on AWS from Amazon S3, Amazon Bedrock Knowledge Bases, Amazon Bedrock Guardrails and the surrounding services.
What RAG does, and where quality enters
A RAG system first retrieves passages that appear relevant to a question from a collection of documents, and then gives them to a language model with instructions to answer from them, so that answers can reflect current material and cite their sources without retraining a model. Between a document being published and a passage reaching the model, the content passes through a chain of transformations. Source documents are admitted to the collection, parsed from formats such as HTML, PDF and scanned images into text, split into chunks, converted into numerical embeddings, stored in a vector index with metadata, retrieved by similarity and filters, often re-ranked, and finally assembled into the prompt. Each of those steps can lose, distort or misattribute information, and the model at the end generally cannot tell that it happened. A passage from guidance withdrawn last year looks exactly as authoritative to the model as the guidance that replaced it, and a table that lost its column headings during parsing becomes a list of numbers with no meaning.
Some of the most consequential failures in a public-service assistant, including citations to superseded eligibility rules, missing exceptions and inappropriate disclosure of restricted documents, can arise from the data and retrieval arrangements even when the generating model performs well against its own tests. Other failures may come from the model, the instructions given to it or the surrounding application, and the evaluation needs to distinguish them rather than attributing every wrong answer to the same cause.
What GOV.UK Chat shows
The Government Digital Service has published an unusually detailed account of how GOV.UK Chat was built, and much of it is about the content rather than the model. GDS describes the system as drawing exclusively on guidance published on GOV.UK. Content is filtered by metadata before retrieval to favour authoritative and current sources, and pages containing personally identifiable information are excluded. Pages are split using hierarchical semantic chunking that preserves the HTML heading structure, and each chunk reaches the model as a structured object carrying its page description and parent headings, so a passage keeps the context that tells the model what it is part of.
Retrieval combines semantic search with a metadata-based re-ranking layer, using a weighting schema built after reviewing every GOV.UK document type, so that current and contextually relevant content is favoured alongside similarity. GDS tested several embedding models and chose Amazon's Titan model for its balance of quality and infrastructure efficiency. Hybrid search and cross-encoder re-ranking were explored in earlier experiments, but the account does not say they were adopted. Evaluation covers six criteria, groundedness, relevance and answer rate, factual accuracy, factual completeness, reliability and reputational safety, using ground-truth datasets, LLM-as-a-judge methods, expert review of conversation logs and red teaming with the AI Security Institute.
GDS also observes that a model can only generate accurate answers if it is given the right information to work with, and that fixes have to generalise across hundreds of thousands of pages, so the team avoids ad hoc corrections for individual queries. Durable improvements come from the collection and the way it is described.
GDS's later account of designing Chat for the GOV.UK app makes a related point from the user's side. Source links are the main way people can verify an answer, onboarding reminds users that AI can make mistakes and encourages them to check answers through the sources provided, and the team deliberately avoids overstating what the service can do. Working, accurate source links are therefore a product requirement as well as a retrieval metric.
The account is also notable for what it leaves out. It does not describe how duplicated, conflicting or withdrawn content is handled, and those are precisely the problems that most departmental collections have in greater measure than GOV.UK, which benefits from a central publishing platform, consistent document types and professional content design. Because Chat draws only on published guidance, it also tells us nothing about controlling access to private or restricted records, which is the harder problem for most internal assistants and which the rest of this article treats as an engineering question.
For a broader examination of what published government AI projects can demonstrate, including how productivity claims differ from sustained service outcomes, see What Published Public-Sector AI Projects Actually Show.
Why this matters more in government
Public bodies have long struggled with the quality of their data. The National Audit Office's 2019 report on using data across government found that data was not seen as a priority, that the importance of investing in quality data was not well understood, and that there was a culture of tolerating and working around poor data. It pointed to Windrush as an example of the consequences of acting without fully assessing the quality of the underlying data.
Those conditions do not disappear when the data is guidance, correspondence or case records. A departmental knowledge base will typically hold several versions of the same policy, guidance of unclear status, scanned material never meant to be machine-readable, and files whose access restrictions exist only in the folder they sit in, and a RAG service built on it will reproduce each problem with the confidence of a language model. The consequences are also heavier than in a commercial setting, because an answer that cites superseded eligibility rules or omits a statutory exception can affect someone's entitlement or legal position, and the organisation may have to explain where it came from.
What the data product has to achieve
Treating RAG as a data product means deciding, before the assistant is built, what the collection behind it must achieve and how that will be measured. The Government Data Quality Hub recommends six dimensions of data quality, and notes that different uses need different combinations of them. Each has a specific meaning for a retrieval collection, and in a public service the meaning is often temporal, because guidance that was correct for a case decided last year may still be the right answer to a question about that case.
| Dimension (Data Quality Hub) | What it means for a RAG collection | How it is usually tested |
|---|---|---|
| Accuracy | Each document correctly states the rule or guidance for the period, place and audience it applies to | Owner review; sampled checks against policy and legislative sources |
| Completeness | The collection covers the questions the service is meant to answer, including exceptions and edge cases | Coverage analysis against a question set; unanswered-question logs |
| Uniqueness | Applicability and version precedence are unambiguous, so near-duplicates are removed or marked and concurrent versions for different schemes, jurisdictions or periods are distinguishable | Near-duplicate detection; precedence rules per topic |
| Consistency | Documents on the same topic and period do not contradict each other, or the conflict is resolved and recorded | Contradiction review by topic owners |
| Timeliness | Documents carry when they apply, and material that no longer applies to current questions is withdrawn from them promptly | Effective-from and effective-to metadata; withdrawal audits |
| Validity | Documents parse correctly, with headings, tables and lists preserved | Parsing quality checks on difficult formats |
Two further requirements are not part of the Data Quality Hub's framework but are, in our view, essential for a retrieval collection in government.
| Additional requirement | What it means | How it is usually tested |
|---|---|---|
| Authority | Each document has an identifiable owner and publication status, and the service can prefer authoritative sources | Required ownership and status metadata; admission checks |
| Permission | Each document carries the access rules of its source, and retrieval honours them for a verified caller | Permission leakage tests per user group before release |
Ownership, contracts and lifecycle
A data product has an owner accountable for its quality and a defined set of consumers. For a RAG collection, policy and content owners answer for what each document says and whether it is current, while a platform or data team answers for the pipeline that turns documents into a reliable index. The arrangement fails when each assumes the other is handling quality, which is common when an AI project runs as a technology initiative separate from the teams that own the content.
The contract should also distinguish when a document was published from when its rules applied, since retrospective questions may legitimately require an older version. The two sides need a contract defining the metadata every document must carry, the formats accepted, the time within which a change at source must appear in retrieval, and what happens when a document is superseded, withdrawn or reclassified. Publishing processes then have to change to meet it, since capturing an effective-to date or an audience restriction when a document is approved is far easier than reconstructing it later.
On AWS, organisations that already run a data catalogue can record the collection in the same place as their other data assets. Amazon SageMaker Catalog, built on Amazon DataZone, supports data products that group assets for a specific business use, with publish and subscribe workflows in which an owner approves who may consume them. Registering the RAG collection that way gives it a named owner and a visible list of the services that depend on it, which matters when a policy change has to be traced to every assistant that might cite the old version.
Engineering the collection on AWS
The remainder of this article turns to the technical work on AWS, where the first decision is which kind of knowledge base to build on. Since 17 June 2026, Amazon Bedrock has offered two paths that are easy to confuse because they share a name and some APIs, and they differ in what the organisation controls.
| Customer-managed Knowledge Base | Bedrock Managed Knowledge Base | |
|---|---|---|
| Who runs the pipeline | The organisation chooses and operates the vector store (for example Amazon OpenSearch Serverless, Amazon Aurora PostgreSQL or Amazon S3 Vectors) and configures parsing and chunking | AWS manages ingestion, storage, indexing and retrieval infrastructure |
| Retrieval APIs | Retrieve and RetrieveAndGenerate | Retrieve and AgenticRetrieveStream; RetrieveAndGenerate is not supported |
| Access control | Metadata filters constructed by the application at query time | ACL-aware retrieval for supported connectors, with real-time verification for some; filtering rather than a security boundary |
| Synchronisation safeguards | Incremental sync and direct ingestion; data deletion policy on the data source | Scheduled syncs and a deletion protection threshold, alongside ACL crawling |
| Suits | Collections where the organisation needs to control the index, its metadata model and its location in detail | Connecting existing document platforms such as SharePoint or Confluence quickly, where their permissions are the model to follow |
Either path still leaves the most important quality controls outside the knowledge base, in the publishing pipeline that feeds it and the application that calls it. The table below shows one way to assemble those controls around a customer-managed knowledge base with an Amazon S3 source, which gives a public body the most direct control over metadata and evidence. The combination illustrates one possible implementation. It does not describe a deployed customer system.
| Stage | AWS building blocks | What it protects |
|---|---|---|
| Source of record | Amazon S3 bucket per collection, with versioning and KMS encryption; each document paired with a .metadata.json sidecar file | Authority, timeliness, a recoverable history of source objects |
| Admission | S3 event notifications through Amazon EventBridge to AWS Step Functions or AWS Lambda, validating metadata and format and quarantining failures | Validity, completeness of metadata, protection against unapproved content |
| Publication state | An authoritative register (for example in Amazon DynamoDB) recording each document's status and withdrawals; status is checked for retrieved documents before model use | An application-controlled withdrawal gate independent of index sync, subject to fail-closed checks |
| Parsing and chunking | Default or foundation-model parsing; fixed-size, hierarchical or semantic chunking | Validity of tables and structure; passages that carry their context |
| Embedding and index | A Bedrock embedding model (Amazon Titan Text Embeddings, as GOV.UK Chat chose, or another supported model) and the chosen vector store | Retrieval quality, cost and operational fit |
| Synchronisation | Ingestion jobs triggered from the admission workflow, or direct ingestion for individual documents; job outcomes monitored in Amazon CloudWatch | Timeliness; a measured lag between publication and retrieval |
| Retrieval | Retrieve with filters derived from a verified identity and the publication register; optional re-ranking | Authority, timeliness, permission |
| Generation | The model call, with Amazon Bedrock Guardrails configured for the flow, including a contextual grounding check against the retrieved passages | Faithfulness to retrieved passages; refusal when the collection does not support an answer |
| Evidence | An ingestion manifest per sync, a retrieval event per answer, AWS CloudTrail for API activity | The ability to reconstruct where an answer came from |
Engineering note. The pipeline in Table 4 is an Inference Public suggested design assembled from documented AWS services. It is not an AWS reference architecture or a deployed customer implementation.
Admission and metadata
The metadata schema is the most important design decision in a government RAG service, because it carries authority, timeliness and permission into retrieval. A workable minimum for policy and guidance collections is the document's owner, status (draft, current, superseded, withdrawn), effective-from and effective-to dates, audience (public, staff, specific roles), security classification and handling caveats, jurisdiction where guidance differs across the UK, and a stable identifier that survives renaming and relocation. For an Amazon S3 data source, Bedrock Knowledge Bases reads metadata from a sidecar file with the same name as the document and .metadata.json appended, and supports filtering on those attributes at query time, which can support source status and audience filtering when the application independently determines and enforces the relevant authorisation rules. Because the metadata sits in a separate object, the publishing workflow can write and validate it as part of approval, and S3 versioning preserves the history of both objects.
Admission control matters as much as description. Only documents that have passed through an approved publishing route should enter the collection, and the pipeline should reject or quarantine documents that arrive without the required metadata, which converts a quality expectation into an enforced rule.
Parsing and chunking
Government collections contain much material that does not parse cleanly. A customer-managed knowledge base offers default text parsing and, at additional cost, a foundation-model parser for complex documents such as nested tables and text within images, and the choice should be made by testing the collection's most difficult documents, because a parsing failure is invisible later in the pipeline.
Chunking determines what a single retrieved passage contains. Bedrock supports fixed-size, hierarchical, semantic and no chunking. Hierarchical chunking retrieves small, precise child chunks while returning the larger parent chunk for context, which suits long guidance documents with nested sections; AWS notes it is not recommended when an S3 vector bucket is the vector store. Semantic chunking groups text by meaning using a foundation model, again at additional cost. GDS's approach of preserving headings and passing the parent structure with each chunk illustrates the underlying principle, which is that a passage must carry enough context for the model, and for a human checking the citation, to know what it belongs to.
Keeping the index current, and withdrawing quickly
An index is a copy of the collection, and copies drift. In a customer-managed knowledge base, each addition, change or removal in a data source has to be synchronised before it is reflected in retrieval, although synchronisation is incremental and processes only what has changed since the last run, and some sources support direct ingestion of individual documents. AWS notes that after a sync completes it can take a few minutes for new embeddings to become queryable when the vector store is something other than Amazon Aurora. Synchronisation should be triggered by the publishing process, monitored for failures and treated as part of the release of new guidance; AWS has published a solution that automates it in response to changes in S3, which is a reasonable starting point.
For some content that lag may be acceptable, but for guidance with serious consequences it should not determine when a withdrawal takes effect. One design is to record withdrawal as a change of state in an authoritative publication register outside the vector index, then check the status of every retrieved document against that register before any passage is given to the model. The response path must fail closed when the register cannot be read, when a passage lacks a stable document identifier, or when the identity and applicable version cannot be established. Documents that have been withdrawn must be removed from the candidate passages even if the index has not yet converged; because removing results after retrieval can leave too little usable evidence, the application may need to retrieve additional candidates or abstain. This is a proposed application-level control, not a guarantee supplied by Bedrock Knowledge Bases, and it depends on reliable register reads, versioned identifiers, and a tested process for invalidating cached answers and conversation context. Urgent withdrawal needs an operational route outside working hours and a way to identify responses previously generated from the affected source.
Effective dates need the same care. A question about a decision made last year may legitimately need last year's guidance, and a question from Scotland may need different guidance from one in England, so the filter should apply the date and jurisdiction the question concerns, which is usually but not always the present.
Two configuration settings also affect withdrawal. A data source can be set to retain its vectors when the data source itself is deleted, so content can continue to contribute to results after its source has gone. In a managed knowledge base, an optional deletion protection threshold stops a sync from deleting more than a set percentage of indexed documents, defaulting to 15 per cent, and if the threshold is exceeded the sync skips its delete phase and leaves those documents indexed. That protects against accidental mass deletion at the cost of currentness, which is another reason the application should be able to exclude withdrawn content independently of the index.
Permissions and identity
Retrieval must never return a passage the user is not entitled to see, because the model will summarise whatever it is given. The strongest separation comes from keeping collections for different audiences in separate knowledge bases, and where separate public bodies or security domains share a service, separate accounts may be justified. Where a single index serves several groups, the two knowledge base types offer different mechanisms. In a customer-managed knowledge base the application constructs metadata filters at query time, and those filters protect nothing unless they are derived from a verified identity and an authorisation decision made independently of the request, for example by a policy engine such as Amazon Verified Permissions, as AWS has shown in a published multi-tenant pattern. In a managed knowledge base, ACL-aware retrieval applies permissions crawled from supported connectors such as SharePoint, Confluence and Google Drive.
AWS is explicit about the limits of the managed capability: ACL awareness provides filtering rather than a security boundary, the service does not authenticate end users, and it must not be the sole access control without upstream authentication. Crawled permissions are only as fresh as the last sync, real-time verification is unavailable for Amazon S3 and custom sources, and identity matching depends on email addresses agreeing exactly across systems. In either model the application remains responsible for authenticating the user, should fail closed when an authorisation check errors, and must keep caches and conversation history separate between users, because a cached answer built from restricted passages is itself restricted. Permissions should be tested for each user group before release, including someone whose access was recently removed.
Treating retrieved content as untrusted
Every document in the collection is, in effect, an input to the model, which creates a security exposure that ordinary search systems do not have. A document containing instructions, whether planted deliberately or present innocently, can influence the model's behaviour when it is retrieved. OWASP's 2025 list of risks for LLM applications places prompt injection first, including indirect injection through external content, and adds vector and embedding weaknesses as a separate risk for RAG systems. The NCSC has argued that prompt injection should not be treated as a variant of SQL injection, because language models do not separate instructions from data, and that it may never be fully mitigated in the same way; the practical response is to limit what a compromised output can do.
The UK government's voluntary Code of Practice for the Cyber Security of AI, published in January 2025, names indirect prompt injection and data poisoning among the risks that justify AI-specific security measures, and expects checks and sanitisation to be applied to data and inputs.
For a RAG service, that means retrieved text must be handled as data and must never acquire the authority of system instructions, or the ability to call tools, simply because retrieval judged it relevant. In practice it also means admission control on what enters the collection, extra scrutiny for any source that accepts content from outside the organisation, such as correspondence or uploaded documents, and output handling that assumes the model may have been misled. A read-only assistant that answers questions carries far less risk than one whose output triggers actions, and that boundary should be designed deliberately.
Amazon Bedrock Guardrails can add a check on the other side of the model, but it has to be configured for the application's actual flow. A contextual grounding check needs three things, the grounding source, the user's query and the response to check, and it scores the response for grounding and relevance against thresholds the service owner sets between 0 and 0.99. Where an application calls Retrieve and then invokes the model separately, it has to pass the retrieved passages to the guardrail explicitly as the grounding source, together with the user's question and the answer to evaluate. AWS is also explicit that when guardrails are used with RetrieveAndGenerate, they apply to the input and the generated response and not to the references retrieved at runtime. Detection and blocking are distinct policy choices, so a configured check must be tested to establish whether it actually blocks or only reports a finding. The newer Standard tier of contextual grounding requires cross-Region inference, which a public body must assess against its location and processing requirements; the Classic tier has different evaluation behaviour. In streaming flows, AWS also warns that an irrelevant response may be returned before the completed stream is classified. The grounding check compares the answer with the passages it was given, so it can detect an answer that diverges from them, but it cannot establish that those passages were authoritative, current or safe. It complements the controls on the collection without replacing them.
Evaluating the product as well as the answers
A RAG service needs two kinds of evaluation, because retrieval and generation fail in different ways. Retrieval evaluation asks whether the right passages were found for a question, and generation evaluation asks whether the answer faithfully reflects those passages and answers the question. Bedrock's RAG evaluation supports both, with retrieval metrics such as context relevance and coverage, and generation metrics such as correctness, completeness and faithfulness, using a language model as the judge.
Alongside the judged metrics, a public service needs measures it can compute directly: retrieval recall at a fixed number of results for questions with known source documents, permission leakage tests that query as each user group and check nothing restricted is returned, citation integrity checks that each cited link resolves to the passage actually retrieved, and an abstention rate for questions the collection should not be able to answer. All of these should be rerun whenever the collection, the embedding model, the chunking settings, the generating model or the prompt changes.
Automated judges need calibrating against human judgement, and the question set they use is itself a data product. It should be built with the content owners, include the exceptions and edge cases that matter most to users, and record for each question which documents ought to be retrieved. The most valuable regression tests in government are often the ones that check a superseded document is no longer cited after a policy change, and that a restricted document is not retrieved for a user without access.
Collection-level measures belong alongside these, such as the proportion of documents with complete metadata, the number of near-duplicates, the age of the oldest document still marked current and the lag between a change at source and its appearance in retrieval, because they predict whether the service will stay reliable better than an accuracy score taken at launch.
Following the two failures through
Returning to the council's assistant shows where each control earns its place. The superseded housing policy should have been stopped at several points: the withdrawal recorded in the publication register should have excluded it at query time from the moment the new policy was approved, its status and effective-to date in the metadata should have excluded it through a filter once the index caught up, the publishing workflow should have triggered a sync, the regression set should have included a question that would cite the old policy, and the answer's citation should have shown its date to anyone checking. When it does slip through, the council needs to reconstruct what happened, and S3 versioning alone cannot do that, because it records changes to stored objects but not which versions were indexed at the time, which passages were retrieved, which filters applied or whether a cached answer was served. That requires an evidential record designed explicitly for the task: a versioned ingestion manifest recording the source objects and their version identifiers, metadata and parsing, chunking and embedding configuration, alongside a retrieval event recording the actual passage text or a durably resolvable immutable reference, passage identifiers, policy-filter decisions, request identity or pseudonymous reference, prompt and model configuration versions, citation targets and the response that was delivered. A provider's ingestion job identifier alone does not prove which internal chunk representation was indexed, so the organisation must test whether it can reconstruct a representative historical response from the evidence it retains. Those records can themselves contain personal or confidential information and require proportionate retention, encryption, access restrictions and deletion arrangements. Without an explicit evidence contract the council may be able to establish that an old document existed while remaining unable to explain why a particular resident saw a particular answer.
The planted instruction is a different kind of failure. An approved-source rule would have kept uploaded correspondence out of a policy collection altogether, or held it in a separate collection with stricter handling. Treating retrieved text as data, with no route from an answer to any action, limits what a successful injection can achieve. A grounding check may well pass, because the answer is faithful to a passage that was itself hostile, which is why it cannot be the control that catches this case. Those controls reduce the chance and the impact of this failure without guaranteeing to detect it. Human escalation for answers that recommend a decision, and monitoring for unusual answer patterns, are what remain, and the retrieval events make it possible to find every answer that drew on the hostile passage once it is identified.
What the programme needed
A programme of this kind would be better served by spending its first months on the collection rather than the model: establishing who owned each part of it and which documents were authoritative, agreeing the metadata that would carry status, dates, audience and permissions, deciding how withdrawn material would leave retrieval and how quickly, writing a question set with the people who understood the edge cases, and limiting what the system's output could do. None of that work needs a model, and all of it determines whether the model's answers can be relied on once real users and real records are involved.
For a public body building on AWS today, the services to do this are available and well documented. What remains is to treat the collection as a product with owners, a contract and evidence, so that when an assistant gives a wrong answer the organisation can find out why, correct the source and show that it has done so.
Sources
- Government Digital Service, Developing GOV.UK Chat: our data science and AI engineering journey (15 May 2026)
- National Audit Office, Challenges in using data across government (June 2019)
- Government Data Quality Hub, Meet the data quality dimensions
- Government Data Quality Hub, What is data quality?
- Amazon Bedrock User Guide, How content chunking works for knowledge bases
- AWS Machine Learning Blog, Amazon Bedrock Knowledge Bases now supports advanced parsing, chunking, and query reformulation
- AWS Machine Learning Blog, Access control for vector stores using metadata filtering with Amazon Bedrock Knowledge Bases
- Amazon Bedrock User Guide, Connect to Amazon S3 for your knowledge base (document metadata files)
- Amazon Bedrock User Guide, Include metadata in a data source to improve knowledge base query
- AWS Machine Learning Blog, Selecting a vector store for Amazon Bedrock Knowledge Bases
- AWS Machine Learning Blog, Build and deploy an automatic sync solution for Amazon Bedrock Knowledge Bases
- Amazon Bedrock User Guide, Use contextual grounding check to filter hallucinations in responses
- Amazon DataZone User Guide, What is new in Amazon DataZone (data products)
- AWS, Amazon SageMaker Catalog
- AWS News Blog, Introducing Amazon Bedrock Managed Knowledge Base
- Amazon Bedrock User Guide, Build a managed knowledge base (Bedrock Managed vs Customer-managed)
- AWS What's New, Amazon Bedrock Managed Knowledge Base is now generally available (17 June 2026)
- Amazon Bedrock API Reference, RetrieveAndGenerate (not supported with managed knowledge bases)
- Amazon Bedrock User Guide, Connect a data source to a managed knowledge base (deletion protection)
- AWS Architecture Blog, Secure multi-tenant RAG with Amazon Bedrock and Verified Permissions
- Amazon Bedrock User Guide, Access Control Lists awareness enablement
- Amazon Bedrock User Guide, Sync your data with your Amazon Bedrock knowledge base
- Amazon Bedrock User Guide, Ingest changes directly into a knowledge base
- Amazon Bedrock User Guide, Modify a data source for your Amazon Bedrock knowledge base
- Amazon Bedrock User Guide, Use metrics to understand RAG system performance
- Government Digital Service, Designing GOV.UK Chat for the GOV.UK app (19 August 2026)
- Amazon Bedrock User Guide, Query a knowledge base and generate responses (guardrails and retrieved references)
- DSIT, Code of Practice for the Cyber Security of AI (31 January 2025)
- OWASP, LLM01:2025 Prompt Injection
- OWASP, Top 10 for LLM Applications 2025
- NCSC, Prompt injection is not SQL injection (it may be worse) (8 December 2025)
Editorial note: This article is general engineering guidance. The GOV.UK Chat material is drawn from GDS's own published account and does not describe work by Inference Public or Inference Clinical. The proposed AWS design, publication register and evidence contract are engineering recommendations, not a claim that GDS implemented them. AWS features were checked against AWS documentation on 20 November 2026.
All insights