Been building AI applications lately? You’ve probably felt the pain of vector embedding storage. Vector databases are powerful, yeah but expensive and a hassle to work with. Surprise. AWS just launched something that can save you up to 90% on vector storage.

Let me introduce you to Amazon S3 Vectors.

What Are We Discussing Here?

Let’s get our feet wet in the fundamentals before jumping into S3 Vectors. In case you already store vectors in Pinecone, Weaviate, or have your own vector database, you’re already aware that vectors are numeric encodings of your data text, images, audio, etc. They encode semantic meaning so you can retrieve similar things, drive RAG applications, or grant your AI agents some memory.

The problem? Traditional vector databases are:

• 💸 Expensive at scale (especially when you’re storing millions or billions of vectors)
• 🔧 Complex to maintain and provision
• 📊 Often overkill if you’re not querying constantly

Say hello to S3 Vectors the first cloud object store with native vector support. It’s similar to Amazon S3, but optimized for vectors. You get the legendary reliability and scalability of S3, with the capability to actually query your vectors in sub-second performance.

Why Should You Care? 🤔

Let’s be realistic: we don’t all need millisecond query times for all vectors in our system. Sure, your recommendation engine has to be super fast, but what about:

• 📚 Long-term conversation history for your AI agents
• 🗂️ Archive data that you query occasionally
• 📈 Training datasets that grow over time
• 🔍 Semantic search across millions of documents that don’t need real time response

This is where S3 Vectors shines. Pay only for what you use, no infrastructure to provision whatsoever, and scale from thousands to billions of vectors without breaking a sweat (or your bank).

The Architecture: How It Actually Works

S3 Vectors introduces three core concepts:

1. Vector Buckets 🪣

A new type of S3 bucket specifically designed for vector data. Not your regular S3 bucket this one is designed for vectors from ground up.

2. Vector Indexes 📑

Inside each vector bucket, you create indexes to hold and organize your vectors. Each bucket supports up to 10,000 indexes and each index can hold tens of millions of vectors. Indexes are groups that bunch related vectors together.

3. Vectors (Clearly) ⚡

Your actual vector embeddings live here. And the best news? You can attach metadata as key-value pairs to each vector. Need to filter on date, category, user preference, or genre? No problem. S3 Vectors will automatically optimize your data as it evolves no manual fiddling required.

Strong Consistency FTW

Here’s the key bit: writes are strongly consistent. When you add or update a vector, it’s immediately available for queries. No eventual consistency angst.

Let’s Get Practical: Code That Actually Works 💻

I know you’re itching to see some code, so let’s walk through a real example. Say you’re building a movie recommendation system (because every tutorial needs movies, right? 🎬).

Step 1: Generate Embeddings with Amazon Bedrock

import boto3
import json

# Set up Bedrock client
bedrock = boto3.client("bedrock-runtime", region_name="us-west-2")

# Your movie descriptions
texts = [
"Star Wars: A farm boy joins rebels to fight an evil empire in space",
"Jurassic Park: Scientists create dinosaurs in a theme park that goes wrong",
"Finding Nemo: A father fish searches the ocean to find his lost son"
]

embeddings = []

# Getting embeddings for each movie
for text in texts:
body = json.dumps({"inputText": text})

response = bedrock.invoke_model(
modelId='amazon.titan-embed-text-v2:0',
body=body
)

response_body = json.loads(response['body'].read())
embedding = response_body['embedding']
embeddings.append(embedding)

Step 2: Store Vectors in S3 Vectors

# Create S3 Vectors client
s3vectors = boto3.client('s3vectors', region_name='us-west-2')

# Insert your vectors with metadata
s3vectors.put_vectors(
vectorBucketName="my-movie-vectors",
indexName="movie-embeddings",
vectors=[
{
"key": "v1",
"data": {"float32": embeddings[0]},
"metadata": {
"id": "key1",
"source_text": texts[0],
"genre": "scifi"
}
},
{
"key": "v2",
"data": {"float32": embeddings[1]},
"metadata": {
"id": "key2",
"source_text": texts[1],
"genre": "scifi"
}
},
{
"key": "v3",
"data": {"float32": embeddings[2]},
"metadata": {
"id": "key3",
"source_text": texts[2],
"genre": "family"
}
}
]
)

Step 3: Query Your Vectors

# User asks: "List movies about adventures in space"
input_text = "List the movies about adventures in space"

# Create embedding for the query
request = json.dumps({"inputText": input_text})
response = bedrock.invoke_model(
modelId="amazon.titan-embed-text-v2:0",
body=request
)

model_response = json.loads(response["body"].read())
query_embedding = model_response["embedding"]

# Do similarity search with metadata filtering
query = s3vectors.query_vectors(
vectorBucketName="my-movie-vectors",
indexName="movie-embeddings",
queryVector={"float32": query_embedding},
topK=3,
filter={"genre": "scifi"},  # Only search sci-fi movies
returnDistance=True,
returnMetadata=True
)

results = query["vectors"]
print(results)  # Star Wars will be your top match!

The Integration Story: Playing Nice with Others 🔗

S3 Vectors is not an isolated island. AWS made sure it plays nice with other tools you may already have on board:

Amazon Bedrock Knowledge Bases 🧠

Create knowledge bases for RAG applications natively with S3 Vectors as your storage layer. Cut costs without sacrificing functionality.

Amazon OpenSearch Service 🔍

And now things get interesting: use a tiered storage approach. Store your low-frequency, long-term vectors in S3 Vectors (cheap), and scale up to OpenSearch for high-priority vectors when you need that high-QPS, low-latency performance.

Picture it like this:

• S3 Vectors: Your budget-savior data warehouse for vectors
• OpenSearch: Your high-performance query engine

You can even export S3 vector index snapshots directly to OpenSearch Serverless collections from the console. Best of both worlds.

Amazon SageMaker Unified Studio 🎨

Build and prototype your generative AI workloads with native access to Bedrock and S3 Vectors in one integrated studio.

When Should You Actually Use This? 🎯

Use S3 Vectors if:

• ✅ You need to persist large vector datasets (millions to billions)
• ✅ Query rate is not thousands of QPS
• ✅ Cost is a primary concern
• ✅ You need sub-second query latency (not microsecond)
• ✅ You don’t want to worry about infrastructure
• ✅ You need strong consistency guarantees

Stick with traditional vector databases if:

• ❌ You need ultra-low latency (single-digit milliseconds)
• ❌ You’re servicing high-QPS real-time applications
• ❌ You need advanced features like hybrid search or complex aggregations
• ❌ Your vectors are frequently updated and queried simultaneously

The Nitty-Gritty Details 🔧

Some important specs to keep in mind:

• Supported distance metrics: Cosine and Euclidean
• Metadata types: String, number, boolean, and lists
• Metadata filtering: All metadata is filterable out of the box
• Encryption: SSE-S3 by default, or bring your own KMS keys
• Access control: Default IAM policies (with a separate s3vectors namespace)
• Block Public Access: Always enabled (can’t be disabled)
• Currently available in: US East (N. Virginia), US East (Ohio), US West (Oregon), Europe (Frankfurt), and Asia Pacific (Sydney)

Getting Started (It’s Easier Than You Think) ⚡

Via Console:

1. Navigate to S3 → Vector Buckets
2. Click "Create vector bucket"
3. Create a vector index (specify dimensionality and distance metric)
4. Start inserting vectors via SDK, CLI, or API

Via Code: Just use the boto3 S3 Vectors client as shown in the examples above—it’s that straightforward.

Pro tip: Check out the S3 Vectors Embed CLI on GitHub. It lets you create embeddings and store them in S3 Vectors with single commands. Super handy for testing and quick prototypes.

---

Resources & Further Reading 📚

• AWS S3 Vectors Official Docs
• S3 Vectors Features Page
• AWS Blog: Introducing S3 Vectors
• Getting Started Guide
• S3 Vectors Embed CLI on GitHub