Lifestyle
Amazon Bedrock Managed Knowledge Base Agentic Retrieve Adds AgentCore Memory: Restore Conversations in One Call and Filter Documents by User ACL
AWS explains that adding memoryConfiguration to AgenticRetrieveStream lets a Bedrock Managed Knowledge Base use AgentCore memory, with userContext applying document ACLs. The integration is opt-in, and the memory resource must be in the same account as the knowledge base.
News date: About 8 min read
Contents
AWS has published a tutorial on its machine learning blog showing how to combine the Agentic Retrieve feature of Amazon Bedrock Managed Knowledge Base (AWS's managed enterprise document knowledge base) with AgentCore memory. Agentic Retrieve automatically plans multiple sub-queries to answer a question; AgentCore memory is a memory service that can store users' conversations and personal facts. Each document can also carry an ACL (access control list), a list of who may read it. According to AWS, the integration is opt-in and backward compatible. The article does not label it as preview or beta, and it gives no availability information beyond the example region. For teams building knowledge Q&A applications, the conversation tables, history replay and fact extraction pipelines they previously had to maintain themselves can now be handled by the service.
What changed, and what did you have to do yourself before?
AWS notes that users expect knowledge applications to remember them. Follow-up questions depend on the previous turn's context, and answers should reflect a location, role or plan mentioned weeks earlier, while still relying only on documents the user is allowed to read and including citations. AWS says Managed Knowledge Base and AgentCore memory now take over three tasks: storing conversations, extracting facts from them, and bringing relevant facts into search.
The approach is to add memoryConfiguration to the AgenticRetrieveStream request. AWS says that, within a single call, the service restores the conversation; the planner (the component that decides what to search for) decides on its own when it needs user facts, retrieves them from long-term memory, and uses them to build the sub-queries sent to the knowledge base; after the answer is generated, the service saves that question-and-answer turn back to memory. AWS explains that with this approach the application no longer needs conversation tables, history replay or extraction pipelines, but is still responsible for authenticating the user and passing the user's identity.
| Item | Approach described by AWS |
|---|---|
| Conversation history | sessionBinding lets the service restore and write it; messages carries only the current question |
| Document permissions | userContext.userId carries the verified email, and the knowledge base filters by ACL |
| Memory identity | actorId uses the Cognito sub, and the namespace is rooted at actorId |
| Write mode | persistenceMode defaults to DEFAULT (requires generateResponse to be true); NONE restores without writing |
| When memory fails | The request does not fail, a FAILED event appears in the trace, and the answer is generated from the knowledge base alone |
What are the supported scope and prerequisites?
AWS says the memory resource used with this integration must be in the same AWS account as the knowledge base and in ACTIVE status. The example in the article uses the US West (Oregon) us-west-2 region and requires Python 3.10 or later and Boto3 1.43.72 or later. You also need permissions to create the following resources: an S3 bucket, a Cognito user pool, IAM roles, a knowledge base and a memory resource. The article does not describe availability in other regions.
AWS also notes that aclEnabled cannot be changed after the data source is created. Documents not covered by any ACL entry are not ingested; a user whose email matches no entry gets no results from that data source. A single request can include up to five knowledge bases.
How should identity and isolation be designed for multiple users?
In AWS's example, employees sign in through Amazon Cognito (AWS's sign-in service). In the ID token obtained after sign-in, the sub (a fixed user identifier) is used as the memory actorId (the memory owner identifier) and namespace, while the verified email is used as userContext.userId. The application obtains all of these values from the verified token, not from the request body. AWS explains that an email can be changed or reassigned to someone else after an employee leaves, so the new user would inherit the old memories; therefore actorId should use an ID that never changes and is never reused.
On memory strategies, AWS says the summary strategy captures facts users mention in passing, while the user preference strategy extracts preferences users state explicitly; it recommends using both. retrievalConfigs accepts only one entry, so a single namespacePath must cover all of that user's records; the example places {actorId} directly under the root.
As defense in depth (an additional layer of protection), AWS recommends creating an IAM role session tagged with userId for each user, combined with the bedrock-agentcore:actorId and namespacePath condition keys. In its demonstration, if a request binds another person's actorId, the memory operation returns AccessDeniedException, and the answer is still generated from the knowledge base.
What about real-world behavior, cost and latency?
In AWS's example run, engineer Maya asked about the weekly on-call stipend and got an answer; salesperson Sofia asked the same question, but because she has no access to engineering documents, the answer said no on-call stipend is documented in the sources she can access. This filtering is done by the knowledge base. In another example, Maya first mentioned in a VPN conversation that she works in the Frankfurt office, then asked about PTO (paid time off) in a new conversation. Long-term memory returned one record, and the answer reflected Frankfurt's rules. When Liam asked the same question, 0 memory records were returned, he got a generic table listing three offices, and he was asked which office he works in.
AWS says long-term memory extraction is asynchronous. In its run, the first record appeared 81 seconds after turn 2, but this timing is not a commitment, and designs should assume records take some time to become available. On latency, session restoration adds about 200 milliseconds; a full turn with one knowledge base, ACLs and memory took 4–10 seconds, mainly driven by planning iterations. These are observed values, not service commitments. On billing, agentic retrieval is priced per call plus underlying retrievals, and memory operations made during the call are billed as AgentCore memory usage.
Frequently asked questions
Do I have to switch to this feature?
No. AWS says the integration is opt-in and backward compatible. If you need precise control over the history included in each request (for example, editing the history yourself), AWS recommends continuing to send messages; however, messages cannot be used together with sessionBinding in the same request.
Will answers fail if the memory service fails?
No. According to AWS, memory operations are best effort. When a memory call fails or is denied, the request does not fail, a FAILED event appears in the trace, and the answer is generated from the knowledge base alone.
How should sessionId be managed?
For a new conversation, the application generates the sessionId and returns it to the client, which sends it back in later turns to continue the conversation. AWS explains this is safe because short-term memory is keyed by actorId, and actorId comes from the token. AWS recommends a stable sessionId throughout the conversation; a new ID on every request is accepted but breaks continuity and produces one summary record per turn.
Which conversation events are restored?
AWS explains that only USER and ASSISTANT conversation events are restored; events with the TOOL or OTHER role written by other systems are skipped.
Browse the latest news in this topic
Found this guide helpful? Share it with someone who needs it
Lifestyle
NVIDIA Launches DGX Spark HPC Developer Kit: Four-Node Ring Cluster, 512GB Memory, Now on Sale
At SC26, NVIDIA unveiled the DGX Spark HPC Developer Kit, built from four DGX Spark systems with 512GB of combined memory and 20TB of NVMe. The kit can be purchased now; the HPC SDK installation playbook is still to come.
Lifestyle
GitHub Copilot weekly update: Copilot app supports GitHub Enterprise Server (GA), plus Claude Fable 5.2 and Gemini 4 Carbon for Pro+, Max, Business and Enterprise
GitHub's Copilot update for the week of November 9: the Copilot app now supports GHES repositories (generally available), VS Code 1.146 adds an experimental Inbox mode, and two new models are available to Pro+, Max, Business and Enterprise.
Lifestyle
GitHub Copilot Retires Claude Opus 4.8, Opus 5 and GPT-5.6 Terra on Nov. 16: Switch to Opus 5.5 and Other Models
GitHub announced that from November 16, 2026, three models are deprecated in most Copilot experiences, and it lists replacement options. Individual annual-plan subscribers can still use Claude Opus 4.8, while Enterprise and Business admins should check the default enablement rules.
Lifestyle
Nature Sustainability Study: 403 US Hyperscale Data Centers Use About 82 TWh a Year, 1.8% of US Electricity
According to The Verge, a Harvard team published a study in Nature Sustainability estimating that US hyperscale data centers use about 82 TWh a year, with roughly 54% of that power possibly from natural gas and coal. The figures are estimates based on satellite imagery and grid data.
Sources
Compiled from the references and verification dates listed above; fares, schedules, product features, and terms can change, so please confirm the latest details on the relevant official website before travelling, booking, or purchasing.