Creating an AWS Bedrock Knowledge Base with SST

I recently needed to setup a ‘Knowledge Base’ for an AI agent application. I wanted the ability to vectorize and store markdown, text, and even PDFs. This knowledge base would then be used by the AI agent to answer questions from our users.

My high level requirements were:

Vectorize and store various document types: markdown, text, PDFs, etc.
Update, add and/or remove the documents in the knowledge base without much effort.
Not have to use third party packages to handle the ingestion of documents into the knowledge base; as this was not the focus of the project. It was an added tool to our AI agent to give it access to targeted data.

AWS Bedrock Knowledge Bases provide exactly this functionality. It gives you the ability to setup Data Sources that will then be used by the Knowledge Base to create embeddings which are then stored in a vector database.

Therefore, I needed to find a way to setup this infrastructure as code. This is where the SST comes in, which uses Pulumi under the hood (in Version 3).

In this guide, we’ll create a complete Retrieval-Augmented Generation (RAG) system using AWS Bedrock Knowledge Base, Aurora Postgres as the vector storage, and S3 as the document source - all orchestrated with SST.

Why This Matters

Besides the fact that I never want to use the AWS Console to setup infrastructure, Bedrock Knowledge Bases allow your AI applications to search through your data and retrieve relevant information to answer user queries. Instead of using only what the foundation model was trained on, your AI can reference your specific documents, knowledge base, or data - yielding more accurate, relevant, and up-to-date responses.

Using SST to deploy this infrastructure gives us the benefits of Infrastructure as Code, TypeScript type safety, and simplified management of complex AWS resources.

Prerequisites

Before we begin, make sure you have:

An AWS account with appropriate permissions
Node.js and some package manager installed. I’ll be using Bun in this example.
AWS credentials configured locally
SST Tunnel installed (sudo sst install tunnel) - we’ll need this to connect to our database for setup
Access to AWS Bedrock and the Titan Embedding Model (Titan v2). You must request access to the any model in Bedrock you want to use.

Some familiarity with AWS services (VPC, RDS, S3, IAM), Postgres, and terminal commands will be helpful.

Overview

This example will use the following for the AWS Bedrock Knowledge Base:

Aurora Postgres for the Vector Database link
S3 bucket as the Data Source link

Project Setup

Let’s start by creating a new SST project:

1
mkdir aws-bedrock-knowledge-base-sst
2
cd aws-bedrock-knowledge-base-sst
3
bun init -y
4
bunx sst init

Defining the Infrastructure

Open sst.config.ts and replace its contents with our infrastructure definition. We’ll go through each component to understand its purpose.

The SST Config Structure

Our infrastructure definition begins with the basic SST config structure:

1
/// <reference path="./.sst/platform/config.d.ts" />
2

3
export default $config({
4
  app(input) {
5
    return {
6
      name: "aws-bedrock-knowledge-base-sst",
7
      removal: input?.stage === "production" ? "retain" : "remove",
8
      protect: ["production"].includes(input?.stage),
9
      home: "aws",
10
      providers: {
11
        aws: {
12
          region: "us-east-1", // You can change this to your preferred region
13
          profile: "your-aws-profile", // Replace with your AWS profile name
14
        },
15
      },
16
    };
17
  },
18
  async run() {
19
    // Our infrastructure components will go here
20
  },
21
});

This sets up our application name and our AWS provider configuration.

Networking with VPC

First, let’s create a VPC with a bastion host. We enable a bastion host (bastion: true) so we can connect to our RDS instance and set up the required database schema and tables.

1
const vpc = new sst.aws.Vpc("Vpc", {
2
  nat: "ec2",
3
  bastion: true, // so you can connect to RDS and setup the table
4
});

Vector Database with Aurora RDS

Now let’s create our vector database using Aurora PostgreSQL. We will use a minimum scaling capacity of 0.5 ACU. This will ensure we can connect to the database and the sync will not throw an error. Just be sure remove all resources after you are done with the example.

1
const rds = new sst.aws.Aurora("Rds", {
2
  dataApi: true, // required for Bedrock KnowledgeBase to access RDS
3
  engine: "postgres",
4
  vpc: vpc,
5
  scaling: {
6
    min: "0.5 ACU",
7
  },
8
});

Key points about this configuration:

We use dataApi: true because Bedrock Knowledge Base requires RDS Data API to interact with the database
We need to use postgres engine since it supports the pgvector extension for vector storage
We specify a minimum scaling capacity to ensure the database is available for Bedrock’s sync operations

At this point, we have a VPC, a RDS instance, and a bastion host. We can now connect to the RDS instance and setup the database as a vector store.

Our sst.config.ts file should look like this:

1
/// <reference path="./.sst/platform/config.d.ts" />
2

3
export default $config({
4
  app(input) {
5
    return {
6
      name: "aws-bedrock-knowledge-base-sst",
7
      removal: input?.stage === "production" ? "retain" : "remove",
8
      protect: ["production"].includes(input?.stage),
9
      home: "aws",
10
      providers: {
11
        aws: {
12
          region: "us-east-1", // You can change this to your preferred region
13
          profile: "your-aws-profile", // Replace with your AWS profile name
14
        },
15
      },
16
    };
17
  },
18
  async run() {
19
    const vpc = new sst.aws.Vpc("Vpc", {
20
      nat: "ec2",
21
      bastion: true, // so you can connect to RDS and setup the table
22
    });
23

24
    const rds = new sst.aws.Aurora("Rds", {
25
      dataApi: true, // required for Bedrock KnowledgeBase to access RDS
26
      engine: "postgres",
27
      vpc: vpc,
28
      scaling: {
29
        min: "0.5 ACU",
30
      },
31
    });
32

33
    // return the RDS credentials so we can use them in the next step
34
    return {
35
      rdsHost: rds.host,
36
      rdsPort: rds.port,
37
      rdsUsername: rds.username,
38
      rdsDatabase: rds.database,
39
    };
40
  },
41
});

You can now deploy the VPC and RDS. We will use the dev stage for this example. It will take a few minutes for the RDS instance to deploy and be ready to use.

1
bun sst deploy --stage dev

Note: Make sure you’ve replaced your-aws-profile in the app configuration with your actual AWS profile name before deploying.

The Crucial Manual Step: Setting up the RDS Database

Before the Knowledge Base can function, we need to prepare the RDS database. This is a critical step that must be done in the correct order.

Preparing the Database as a Vector Store

First, we need to connect to our Aurora RDS instance. We will use the SST tunnel to connect to the database.

1
bun sst tunnel --stage dev

This will start a tunnel. Then in another terminal, use your credentials to connect with psql:

1
psql --host <RDS_ENDPOINT> --port 5432 --username postgres -d aws_knowledge_base_sst

You can find the password for the database in AWS Secrets Manager. Navigate to the AWS Console, search for “Secrets Manager”, and select the secret for your database. You will see a ‘Retrieve secret value’ button. Click it and you will see the password for the database.

By default, the database username is postgres, and the database name is the name of the app, and replaces the hyphens with underscores.

Now we need to run the following SQL commands to prepare the database as a vector store.

Enable the pgvector extension for vector operations

1
CREATE EXTENSION IF NOT EXISTS vector;

Create a schema for our Bedrock integration

1
CREATE SCHEMA bedrock_integration;

Create a table for vector embeddings

For Titan v2 use vector(1024) or vector(512) or vector(256) For Titan v1.2 use vector(1536)

custom_metadata is optional but highly recommended. It is used to write data from your metadata files.

1
CREATE TABLE bedrock_integration.bedrock_kb (id uuid PRIMARY KEY, embedding vector(1024), chunks text, metadata json, custom_metadata jsonb);

Create an index for vector similarity search

1
CREATE INDEX ON bedrock_integration.bedrock_kb USING hnsw (embedding vector_cosine_ops) WITH (ef_construction=256);

Create an index for Bedrock to query text data.

1
CREATE INDEX ON bedrock_integration.bedrock_kb USING gin (to_tsvector('simple', chunks));

If you are using the custom_metadata field, you need an index for it.

1
CREATE INDEX ON bedrock_integration.bedrock_kb USING gin (custom_metadata);

These commands:

Enable the pgvector extension for vector operations
Create a dedicated schema for Bedrock
Create a table with the right structure to store document chunks, embeddings, metadata and custom metadata
Create an index for efficient vector similarity search
Create an index for Bedrock to query text data
Add a custom metadata column and index for advanced filtering capabilities (more on this in the Document Metadata section below)

Important: The table name and column names must match what you specified in the fieldMapping section of your Knowledge Base resource. The vector dimension (1024) must match the embedding model you’re using (Titan v2 uses 1024 dimensions).

Now we are ready to deploy the Knowledge Base.

Setup the Knowledge Base Infrastructure

We will now deploy the remaining resources needed for the Knowledge Base.

1
const knowledgeBaseBucket = new sst.aws.Bucket("KnowledgeBaseBucket");

This creates a bucket to store the source documents (PDFs, text files, etc.) that Bedrock will process and index into our vector database.

IAM Role for Bedrock Access

See Knowledge Base Service Role for the IAM role needed for the Knowledge Base.

1
const accountId = aws.getCallerIdentityOutput({}).apply((identity) => {
2
  return identity.accountId;
3
});
4

5
const knowledgeBaseRole = new aws.iam.Role("KnowledgeBaseRole", {
6
  assumeRolePolicy: {
7
    Version: "2012-10-17",
8
    Statement: [
9
      {
10
        Effect: "Allow",
11
        Principal: {
12
          Service: "bedrock.amazonaws.com",
13
        },
14
        Action: "sts:AssumeRole",
15
        Condition: {
16
          StringEquals: {
17
            "aws:SourceAccount": accountId,
18
          },
19
        },
20
      },
21
    ],
22
  },
23
  inlinePolicies: [
24
    {
25
      name: "KnowledgeBasePolicy",
26
      policy: aws.getRegionOutput().name.apply((region) =>
27
        JSON.stringify({
28
          Version: "2012-10-17",
29
          Statement: [
30
            {
31
              Sid: "ListFoundationModels",
32
              Effect: "Allow",
33
              Action: [
34
                "bedrock:ListFoundationModels",
35
                "bedrock:ListCustomModels",
36
              ],
37
              Resource: "*",
38
            },
39
            {
40
              Sid: "InvokeModels",
41
              Effect: "Allow",
42
              Action: ["bedrock:InvokeModel"],
43
              Resource: [
44
                `arn:aws:bedrock:${region}::foundation-model/amazon.titan-embed-text-v2:0`,
45
              ],
46
            },
47
          ],
48
        })
49
      ),
50
    },
51
    {
52
      name: "KnowledgeBaseBucketAccessPolicy",
53
      policy: $resolve(knowledgeBaseBucket.arn).apply((arn) =>
54
        JSON.stringify({
55
          Version: "2012-10-17",
56
          Statement: [
57
            {
58
              Effect: "Allow",
59
              Action: ["s3:GetObject", "s3:ListBucket"],
60
              Resource: [arn, `${arn}/*`],
61
            },
62
          ],
63
        })
64
      ),
65
    },
66
    {
67
      name: "KnowledgeBaseRDSAccessPolicy",
68
      policy: $resolve([rds.clusterArn, rds.secretArn]).apply(
69
        ([clusterArn, secretArn]) =>
70
          JSON.stringify({
71
            Version: "2012-10-17",
72
            Statement: [
73
              {
74
                Sid: "RDSDescribe",
75
                Effect: "Allow",
76
                Action: ["rds:DescribeDBClusters"],
77
                Resource: [clusterArn],
78
              },
79
              {
80
                Sid: "RDSDataApiAccess",
81
                Effect: "Allow",
82
                Action: [
83
                  "rds-data:BatchExecuteStatement",
84
                  "rds-data:ExecuteStatement",
85
                ],
86
                Resource: [clusterArn],
87
              },
88
              {
89
                Sid: "SecretsManagerAccess",
90
                Effect: "Allow",
91
                Action: ["secretsmanager:GetSecretValue"],
92
                Resource: [secretArn],
93
              },
94
            ],
95
          })
96
      ),
97
    },
98
  ],
99
});

This role grants Bedrock the necessary permissions to:

Access the S3 bucket to read your documents
Connect to the RDS instance via the Data API
Access the RDS credentials stored in Secrets Manager
Invoke the Titan text embedding model to generate vector embeddings

The Knowledge Base Resource and S3 Data Source

1
const knowledgeBase = new aws.bedrock.AgentKnowledgeBase(
2
  "KnowledgeBase",
3
  {
4
    name: `${$app.name}-${$app.stage}-knowledge-base`,
5
    description: `Knowledge base for ${$app.name} ${$app.stage}`,
6
    storageConfiguration: {
7
      type: "RDS",
8
      rdsConfiguration: {
9
        databaseName: rds.database,
10
        credentialsSecretArn: rds.secretArn,
11
        resourceArn: rds.clusterArn,
12
        tableName: "bedrock_integration.bedrock_kb", // make sure this table exists in the RDS
13
        fieldMapping: {
14
          primaryKeyField: "id",
15
          textField: "chunks",
16
          vectorField: "embedding",
17
          metadataField: "metadata",
18
        },
19
      },
20
    },
21
    roleArn: knowledgeBaseRole.arn,
22
    knowledgeBaseConfiguration: {
23
      type: "VECTOR",
24
      vectorKnowledgeBaseConfiguration: {
25
        embeddingModelArn: aws
26
          .getRegionOutput()
27
          .name.apply(
28
            (region) =>
29
              `arn:aws:bedrock:${region}::foundation-model/amazon.titan-embed-text-v2:0`
30
          ),
31
      },
32
    },
33
  },
34
  {
35
    dependsOn: [knowledgeBaseRole],
36
  }
37
);
38

39
const s3DataSource = new aws.bedrock.AgentDataSource(
40
  "KnowledgeBaseS3DataSource",
41
  {
42
    knowledgeBaseId: knowledgeBase.id,
43
    name: `${$app.name}-${$app.stage}-knowledge-base-s3`,
44
    dataSourceConfiguration: {
45
      type: "S3",
46
      s3Configuration: {
47
        bucketArn: $resolve(knowledgeBaseBucket.arn).apply((arn) => arn),
48
      },
49
    },
50
  }
51
);

Making Knowledge Base Linkable to other SST Resources

To make the Knowledge Base linkable to other SST resources, we need to wrap it in a linkable object.

We will define the properties and permissions that we will need in order for our other SST resources, like a Lambda function, to access the Knowledge Base.

1
// make sure the knowledge base is linkable
2
sst.Linkable.wrap(aws.bedrock.AgentKnowledgeBase, (knowledgeBase) => {
3
  return {
4
    properties: {
5
      id: knowledgeBase.id,
6
      arn: knowledgeBase.arn,
7
      name: knowledgeBase.name,
8
    },
9
    include: [
10
      sst.aws.permission({
11
        actions: ["bedrock:RetrieveAndGenerate", "bedrock:Retrieve"],
12
        resources: [knowledgeBase.arn],
13
      }),
14
    ],
15
  };
16
});

Final `sst.config.ts`

1
/// <reference path="./.sst/platform/config.d.ts" />
2

3
export default $config({
4
  app(input) {
5
    return {
6
      name: "aws-bedrock-knowledge-base-sst",
7
      removal: input?.stage === "production" ? "retain" : "remove",
8
      protect: ["production"].includes(input?.stage),
9
      home: "aws",
10
      providers: {
11
        aws: {
12
          region: "us-east-1", // You can change this to your preferred region
13
          profile: "your-aws-profile", // Replace with your AWS profile name
14
        },
15
      },
16
    };
17
  },
18
  async run() {
19
    sst.Linkable.wrap(aws.bedrock.AgentKnowledgeBase, (knowledgeBase) => {
20
      return {
21
        properties: {
22
          id: knowledgeBase.id,
23
          arn: knowledgeBase.arn,
24
          name: knowledgeBase.name,
25
        },
26
        include: [
27
          sst.aws.permission({
28
            actions: ['bedrock:RetrieveAndGenerate', 'bedrock:Retrieve'],
29
            resources: [knowledgeBase.arn],
30
          }),
31
        ],
32
      }
33
    })
34

35
    const vpc = new sst.aws.Vpc('Vpc', {
36
      nat: 'ec2',
37
      bastion: true, // so you can connect to RDS and setup the table
38
    })
39

40
    const rds = new sst.aws.Aurora('Rds', {
41
      dataApi: true, // required for Bedrock KnowledgeBase to access RDS
42
      engine: 'postgres',
43
      vpc: vpc,
44
      scaling: {
45
        min: '0.5 ACU',
46
      },
47
    })
48

49
    const knowledgeBaseBucket = new sst.aws.Bucket('KnowledgeBaseBucket')
50

51
    const accountId = aws.getCallerIdentityOutput({}).apply((identity) => {
52
      return identity.accountId
53
    })
54

55
    // See (Knowledge Base Service Role)[https://docs.aws.amazon.com/bedrock/latest/userguide/kb-permissions.html]
56
    const knowledgeBaseRole = new aws.iam.Role('KnowledgeBaseRole', {
57
      assumeRolePolicy: {
58
        Version: '2012-10-17',
59
        Statement: [
60
          {
61
            Effect: 'Allow',
62
            Principal: {
63
              Service: 'bedrock.amazonaws.com',
64
            },
65
            Action: 'sts:AssumeRole',
66
            Condition: {
67
              StringEquals: {
68
                'aws:SourceAccount': accountId,
69
              },
70
            },
71
          },
72
        ],
73
      },
74
      inlinePolicies: [
75
        {
76
          name: 'KnowledgeBasePolicy',
77
          policy: aws.getRegionOutput().name.apply((region) =>
78
            JSON.stringify({
79
              Version: '2012-10-17',
80
              Statement: [
81
                {
82
                  Sid: 'ListFoundationModels',
83
                  Effect: 'Allow',
84
                  Action: ['bedrock:ListFoundationModels', 'bedrock:ListCustomModels'],
85
                  Resource: '*',
86
                },
87
                {
88
                  Sid: 'InvokeModels',
89
                  Effect: 'Allow',
90
                  Action: ['bedrock:InvokeModel'],
91
                  Resource: [
92
                    `arn:aws:bedrock:${region}::foundation-model/amazon.titan-embed-text-v2:0`,
93
                  ],
94
                },
95
              ],
96
            }),
97
          ),
98
        },
99
        {
100
          name: 'KnowledgeBaseBucketAccessPolicy',
101
          policy: $resolve(knowledgeBaseBucket.arn).apply((arn) =>
102
            JSON.stringify({
103
              Version: '2012-10-17',
104
              Statement: [
105
                {
106
                  Effect: 'Allow',
107
                  Action: ['s3:GetObject', 's3:ListBucket'],
108
                  Resource: [arn, `${arn}/*`],
109
                },
110
              ],
111
            }),
112
          ),
113
        },
114
        {
115
          name: 'KnowledgeBaseRDSAccessPolicy',
116
          policy: $resolve([rds.clusterArn, rds.secretArn]).apply(([clusterArn, secretArn]) =>
117
            JSON.stringify({
118
              Version: '2012-10-17',
119
              Statement: [
120
                {
121
                  Sid: 'RDSDescribe',
122
                  Effect: 'Allow',
123
                  Action: ['rds:DescribeDBClusters'],
124
                  Resource: [clusterArn],
125
                },
126
                {
127
                  Sid: 'RDSDataApiAccess',
128
                  Effect: 'Allow',
129
                  Action: ['rds-data:BatchExecuteStatement', 'rds-data:ExecuteStatement'],
130
                  Resource: [clusterArn],
131
                },
132
                {
133
                  Sid: 'SecretsManagerAccess',
134
                  Effect: 'Allow',
135
                  Action: ['secretsmanager:GetSecretValue'],
136
                  Resource: [secretArn],
137
                },
138
              ],
139
            }),
140
          ),
141
        },
142
      ],
143
    })
144

145
    // // create the knowledge base
146
    const knowledgeBase = new aws.bedrock.AgentKnowledgeBase(
147
      'KnowledgeBase',
148
      {
149
        name: `${$app.name}-${$app.stage}-knowledge-base`,
150
        description: `Knowledge base for ${$app.name} ${$app.stage}`,
151
        storageConfiguration: {
152
          type: 'RDS',
153
          rdsConfiguration: {
154
            databaseName: rds.database,
155
            credentialsSecretArn: rds.secretArn,
156
            resourceArn: rds.clusterArn,
157
            tableName: 'bedrock_integration.bedrock_kb', // make sure this table exists in the RDS
158
            fieldMapping: {
159
              primaryKeyField: 'id',
160
              textField: 'chunks',
161
              vectorField: 'embedding',
162
              metadataField: 'metadata',
163
            },
164
          },
165
        },
166
        roleArn: knowledgeBaseRole.arn,
167
        knowledgeBaseConfiguration: {
168
          type: 'VECTOR',
169
          vectorKnowledgeBaseConfiguration: {
170
            embeddingModelArn: aws
171
              .getRegionOutput()
172
              .name.apply(
173
                (region) =>
174
                  `arn:aws:bedrock:${region}::foundation-model/amazon.titan-embed-text-v2:0`,
175
              ),
176
          },
177
        },
178
      },
179
      {
180
        dependsOn: [knowledgeBaseRole],
181
      },
182
    )
183

184
    // // create the s3 data source for the knowledge base
185
    const s3DataSource = new aws.bedrock.AgentDataSource('KnowledgeBaseS3DataSource', {
186
      knowledgeBaseId: knowledgeBase.id,
187
      name: `${$app.name}-${$app.stage}-knowledge-base-s3`,
188
      dataSourceConfiguration: {
189
        type: 'S3',
190
        s3Configuration: {
191
          bucketArn: $resolve(knowledgeBaseBucket.arn).apply((arn) => arn),
192
        },
193
      },
194
    })
195

196
    return {
197
      rdsHost: rds.host,
198
      rdsPort: rds.port,
199
      rdsUsername: rds.username,
200
      rdsDatabase: rds.database,
201
      knowledgeBaseId: knowledgeBase.id,
202
      s3DataSourceId: s3DataSource.id,
203
      bucketName: knowledgeBaseBucket.name,
204
    }
205
  },

Adding Data to the Knowledge Base

Now that the Knowledge Base is deployed, let’s add some data to it.

Understanding Document Metadata

Before uploading documents, it’s important to understand how Bedrock handles document metadata. For each document in your S3 bucket, you can include a companion metadata file that enriches your documents with additional context and enables advanced filtering capabilities.

For a document named example.pdf, you would create a metadata file named example.pdf.metadata.json in the same location in your S3 bucket. The metadata file follows this structure:

1
{
2
  "metadataAttributes": {
3
    "company": {
4
      "value": {
5
        "type": "STRING",
6
        "stringValue": "BioPharm Innovations"
7
      },
8
      "includeForEmbedding": true
9
    },
10
    "created_date": {
11
      "value": {
12
        "type": "NUMBER",
13
        "numberValue": 20221205
14
      },
15
      "includeForEmbedding": true
16
    },
17
    "author": {
18
      "value": {
19
        "type": "STRING",
20
        "stringValue": "Lisa Thompson"
21
      },
22
      "includeForEmbedding": true
23
    },
24
    "origin": {
25
      "value": {
26
        "type": "STRING",
27
        "stringValue": "Overview"
28
      },
29
      "includeForEmbedding": true
30
    }
31
  }
32
}

Key points about metadata:

The metadata file must share the same name as its document with .metadata.json appended
It must be stored in the same folder as the source file
The file must not exceed 10 KB
When includeForEmbedding is set to true, the metadata attribute is incorporated into the embedding, potentially improving retrieval relevance
These metadata fields will be stored in the custom_metadata column we created in our RDS table, allowing for filtering during retrieval

Uploading Documents

Upload documents to your S3 bucket:

1
aws s3 cp ./sample-docs/ s3://YOUR-BUCKET-NAME/ --recursive --profile your-aws-profile

You can find your bucket name in the SST deploy output or the AWS Console.

Initiate a sync job by going to the AWS Bedrock Console:

Navigate to Knowledge Bases
Select your Knowledge Base
In the Data sources section, select your S3 data source
Click “Sync” button

The sync process will:

Process all documents in your S3 bucket
Generate text embeddings using the Titan model
Store the chunks and embeddings in your RDS database

Note: Syncing may take several minutes depending on the amount of data.

Testing the Knowledge Base

Once the sync is complete, you can test your Knowledge Base directly in the AWS Console:

On the Knowledge Base page, click the “Test” button.

click the ‘Generate response’ toggle to switch to only retrieve
enter a query and click ‘Run’

The Knowledge Base will:

Convert your query to an embedding using the same model
Perform a vector similarity search in the RDS database
Return the most relevant chunks of text from your documents

For programmatic access, you can use the AWS SDK to call the RetrieveAndGenerate API:

1
import {
2
  BedrockAgentRuntimeClient,
3
  RetrieveAndGenerateCommand,
4
} from "@aws-sdk/client-bedrock-agent-runtime";
5
import { Resource } from "sst";
6

7
const client = new BedrockAgentRuntimeClient({ region: "us-east-1" });
8

9
const response = await client.send(
10
  new RetrieveAndGenerateCommand({
11
    input: {
12
      text: "Your question about your documents here?",
13
    },
14
    retrieveAndGenerateConfiguration: {
15
      type: "KNOWLEDGE_BASE",
16
      knowledgeBaseConfiguration: {
17
        knowledgeBaseId: Resource.KnowledgeBase.id,
18
      },
19
    },
20
  })
21
);
22

23
// or just a retreive command
24

25
const command = new RetrieveCommand({
26
  knowledgeBaseId: Resource.KnowledgeBase.id,
27
  retrievalQuery: { text: query },
28
  retrievalConfiguration: {
29
    vectorSearchConfiguration: {
30
      numberOfResults: 5,
31
    },
32
  },
33
});
34

35
const result = await client.send(command);

Cleaning Up

When you’re done experimenting, you can remove all deployed resources with:

1
bun sst remove --stage dev

Conclusion

You’ve successfully built and deployed an AWS Bedrock Knowledge Base using SST, Aurora Postgres with vector storage, and S3. This powerful combination enables you to create AI applications that can leverage your organization’s specific data.

Using SST for this deployment gives you the benefits of Infrastructure as Code, making your setup repeatable, maintainable, and version-controllable. The vector database in RDS provides efficient similarity search, while the S3 bucket offers flexible document storage.

Hope this helps you get started with building your own Knowledge Base!

Full code for this example can be found here.

Creating an AWS Bedrock Knowledge Base with SST

Share this post