DEV Community: Matthew Evan Eichler

AWS Bedrock Managed Knowledge Bases: Should We Use Them?

Matthew Evan Eichler — Wed, 01 Jul 2026 15:53:28 +0000

AWS released Managed Knowledge Bases for Amazon Bedrock on 17 June 2026. The feature significantly reduces the operational complexity of building Retrieval-Augmented Generation (RAG) solutions by allowing Bedrock to manage the vector storage, indexing, embeddings, and retrieval infrastructure on your behalf.

For teams looking to deliver an Agent Core proof of concept or their first production RAG workload quickly, this can be a compelling option. However, there are some important trade-offs to understand before committing to the managed approach.

Traditionally, a Bedrock Knowledge Base required a customer-managed vector store such as:

OpenSearch Serverless
OpenSearch Managed Clusters
Aurora PostgreSQL with pgvector
Pinecone
DocumentDB
Other supported vector databases With a Managed Knowledge Base, Bedrock handles the underlying vector infrastructure and embedding model selection for you.

Creating one from the AWS CLI is straightforward:

aws bedrock-agent create-knowledge-base \
      --name "my-managed-kb" \
      --role-arn "arn:aws:iam::${AWS_ACCOUNT_ID}:role/service-role/AmazonBedrockExecutionRoleForKnowledgeBase_ihv1p" \
      --knowledge-base-configuration '{
        "type": "MANAGED",
        "managedKnowledgeBaseConfiguration": {
          "embeddingModelType": "MANAGED"
        }
      }'

Advantages

Lower operational overhead

There is no need to provision, secure, monitor, patch, or scale a separate vector database.

Lower costs

S3 storage is cheaper than database storage. Pay only for each ingestion and retrieval operation. Indexing and searching compute are free. No 24/7 server costs.

Faster time-to-value

Managed Knowledge Bases make it possible to stand up a RAG solution in minutes rather than days.

Automatic embedding management

Bedrock manages embedding selection and indexing, reducing the number of architectural decisions required from development teams.

Cost-effective for smaller workloads

The managed model can be attractive for:

Proofs of Concept
Departmental knowledge bases
Agent Core pilots
Workloads with highly variable usage patterns

Good fit for multiple small knowledge bases

Organizations experimenting with several independent knowledge domains can often benefit from the simplified operational model.

Disadvantages

Less control

The primary trade-off is reduced visibility and control over the underlying vector store and retrieval implementation.

Potential performance limitations

Organizations with extremely high query-per-second (QPS) requirements may still prefer dedicated OpenSearch-based solutions where indexing, scaling, and query performance can be tuned explicitly.

Fewer advanced search capabilities

If your use case requires sophisticated filtering, custom ranking strategies, or hybrid lexical/vector search, a self-managed OpenSearch solution may remain the better choice.

Infrastructure-as-Code support is not yet mature

At the time of writing, Managed Knowledge Bases are available through the Bedrock APIs and Console, but CloudFormation and CDK support have not yet fully caught up.

CloudFormation and CDK Considerations

One of the biggest surprises for infrastructure engineers is the current gap between the Bedrock APIs and CloudFormation support.

While a Managed Knowledge Base can be created through the Bedrock API and AWS CLI, there is currently no equivalent CloudFormation resource definition that maps cleanly to the managed configuration. This means CDK users cannot yet create Managed Knowledge Bases using standard CDK constructs.

For teams that require full Infrastructure-as-Code automation, a common workaround is a Lambda-backed Custom Resource that invokes the Bedrock API during deployment.

This situation is not unusual for newly released AWS services. Historically, CloudFormation and CDK support often follow shortly after the underlying service APIs become available.

Recommendation

If your goal is to deliver a RAG-enabled Agent Core solution quickly and with minimal operational overhead, a Managed Knowledge Base is currently the most attractive starting point.

If, however, your organization requires:

Advanced search capabilities
Full infrastructure control
Sophisticated indexing strategies
Complete CloudFormation/CDK automation

... then a traditional OpenSearch-based Knowledge Base remains the more flexible option.

TL;DR

Use Managed Knowledge Bases when speed, simplicity, and lower operational overhead are more important than infrastructure control.

Postscript: Cloud Formation and CDK Engineering Insights

As with most new AWS Products, the Cloud Formation types and CDK support comes at some later date; forget including this in your codebase unless you want to spend the time writing a Lambda backed Custom Resource.

You might find it interesting that the original OpenSearch Serverless Vector Collection also requires a Custom Resource in CDK. The reason is the cluster is created using a Cloud Formation type but there are no default indexes defined. An "on-the-fly"Lambda is created which initialises the cluster with an index that the Knowledge Base can use.

If you want to take a deep dive into this approach try Dirk Michel's pipelineburst example from his Bedrock examples repository in his CDK stacks section (written about 2 years ago).

swiss tables in go

Matthew Evan Eichler — Wed, 26 Feb 2025 10:04:55 +0000

AWS CDK Typescript: Adding Extra Nodes to Study Kubernetes Availability

Matthew Evan Eichler — Wed, 05 Feb 2025 11:06:56 +0000

This installment of the AWS CDK Typescript code for setting up an environment for studying Kubernetes Fundamentals (course LFS258 from the Linux/Cloud Native Foundation) shows how to easily add three extra EC2 instances for playing with higher availability options for your learning Kubenetes cluster.

I used extra1 for the HA Proxy then extra2 and extra3 to join Control Plane Nodes with the cluster. You can, of course, play with these extra instances as you will:

$ kubectl get nodes
NAME     STATUS   ROLES           AGE     VERSION
cp       Ready    control-plane   21d     v1.31.1
extra2   Ready    control-plane   4d20h   v1.30.9
extra3   Ready    control-plane   4d20h   v1.30.9
k8swk1   Ready    control-plane   21d     v1.31.1

Pull Request #4

I'm GitOps Certified

Matthew Evan Eichler — Tue, 04 Feb 2025 19:38:28 +0000

🧠 I'm GitOps with Argo Certified (Fundamentals) from Codefresh, check out the training and certification. 🎉🥳

AWS CDK Typescript: Adding Custom Initialisation to EC2 Instances

Matthew Evan Eichler — Wed, 22 Jan 2025 11:06:39 +0000

In my last post, I introduced an AWS CDK Typescript example repository which can build and destroy two EC2 instances if you are taking the Linux Foundation LFS258 Kubernetes Fundamentals self-paced course. You can work on the course and tear down the Stacks at the end of the day to avoid any extra Cloud Costs.

But doing this over and over again can be tedious setting up the Ubuntu packages everytime you start the next day over. This is where the User Data for AWS EC2 virtuals machines comes in. You can introduce a script that gets executed each time a new EC2 instance is created, sparing you some extra time.

aventinesolutions/lfx-study-aws-cdk-kubernetes Pull Request #3

In this case,

We first want to prepare our Ubuntu boxes with some changes to system configuration and ensure a couple of modules are loaded.
We also use apt to fully update all packages
Then we set up the package signing keys in a GnuPG keyring.
Next, we install the Docker, Kubernetes and Helm packages required before we can start building our cluster according to the course.

After the Cloud Formation Stack has completed, how do I know my initialisation script worked correctly? I found the output in /var/log/cloud-init-output.log ...

...
Preparing to unpack .../helm_3.16.3-1_amd64.deb ...
Unpacking helm (3.16.3-1) ...
Setting up helm (3.16.3-1) ...
Processing triggers for man-db (2.10.2-1) ...
... etc

You can use this as a pattern when you need also need a few set-up customisations for the EC2 image you use. However, if you have many changes from your chosen base image, then it would probably scale-up better to create your own custom Amazon Machine Image [AMI] from an EC2 instance that you have thoroughly tested (refer to this post "Build Your Own Ubuntu AMI" from @matrey Mathieu Rey)

Run Commands When You Launch an EC2 Instance with User Data Input on AWS Docs

AWS CDK Typescript Simple Project for Cloud Formation of Resources Required for Kubernetes Study

Matthew Evan Eichler — Mon, 30 Dec 2024 12:27:34 +0000

This repository demonstrates using the AWS Cloud Development Kit (CDK) to build infrastructure for self-paced Kubernetes courses and Linux Foundation certifications. It showcases cross-stack dependencies, where the VPC and security groups are defined in a separate stack from the compute resources. This approach avoids the potential for unintended destruction often associated with nested stacks, especially in complex CloudFormation deployments. The Kubernetes node scaling is easily configurable to accommodate advanced courses (e.g., three worker and three control plane nodes). Developed using JetBrains IntelliJ Ultimate. Feedback welcome!

aventinesolutions/lfx-study-aws-cdk-kubernetes

Rust is Still Promising as a Replacement for C++

Matthew Evan Eichler — Fri, 20 Dec 2024 16:30:33 +0000

Jet Brains Developers' Survey for 2024 ... Rust is still promising as a memory safe replacement for C++ with the highest popularily, along with Go Lang, among Developers who "plan to adopt a new language." Both languages have robust concurrency in mind.

Multiple Stacks in AWS CDK (Typescript)

Matthew Evan Eichler — Wed, 11 Dec 2024 14:49:50 +0000

It is possible to build multiple, separate Cloud Formation Stacks in a single AWS CDK project. Perhaps that is better when scaling up ... I mean, does this avoid accidental destruction when using Nested Stacks? How to Create Multiple Stacks