S3 Vectors: Object Storage Economics for Vector Search

Vector search used to mean running a database. You stood up a cluster, kept it warm, paid for the RAM that held your index, and scaled nodes as your corpus grew.

Amazon S3 Vectors proposes a different deal. It stores embeddings inside S3 and searches them there, so the cost model looks like object storage - cheap capacity, pay-per-request - rather than an always-on database. This page explains why that shift matters, what it costs you in return, and when the trade is worth taking.

Summary

• What it is: S3 Vectors is a native S3 capability for storing embedding vectors and running similarity search over them, exposed through a dedicated s3vectors client rather than the normal s3 client.
• Insight: it moves vector search from a machine you rent by the hour to storage you pay for by the gigabyte and the query, trading latency for a dramatically lower and more elastic cost floor.
• Key Concepts: vector bucket, vector index, embedding, dimension, distance metric, top-k query, metadata filter.
• When to Use: large or cost-sensitive embedding corpora that tolerate query latency in the tens to hundreds of milliseconds - RAG knowledge bases, archives, semantic search over documents you query occasionally.
• Limitations/Trade-offs: higher per-query latency than an in-memory index, and it is a young API, so operation and parameter names may still move.
• Related Topics: Bedrock Knowledge Bases, self-hosted vector databases (pgvector, OpenSearch, Pinecone), and embedding generation with Bedrock Titan or Cohere.

Verify at build time: S3 Vectors is a 2026 API surface. Treat operation names and parameter shapes here as the most likely form and confirm them against the current boto3 / @aws-sdk/client-s3vectors docs.

Foundations

An embedding is a list of floating-point numbers that represents the meaning of a piece of text, an image, or audio. Similar items produce vectors that sit close together in that numeric space. Vector search is the act of finding the stored vectors nearest to a query vector - the basis of semantic search and Retrieval-Augmented Generation (RAG).

To make that search fast, traditional vector databases build an in-memory index - typically an approximate-nearest-neighbor (ANN) graph like HNSW - and keep it resident in RAM. That is what makes them quick, and also what makes them expensive: you pay for enough memory to hold every vector, all the time, whether or not anyone is querying.

S3 Vectors inverts that. Instead of a cluster, you create a vector bucket - a new bucket type distinct from a normal object bucket. Inside it you create one or more vector indexes. Each index is created with a fixed dimension (the length of every vector, which must match your embedding model - for example 1024 for Amazon Titan Text Embeddings v2) and a distance metric (cosine or euclidean). You then write vectors into the index and query it for the top-k nearest neighbors.

The whole surface is small on purpose: create a bucket, create an index, put vectors, query vectors, get and delete vectors. The mental model is "S3 for embeddings," and the pricing follows that framing.

Mechanics & Interactions

Here is the shape of the two operations that define the workflow - writing vectors and querying them. Keep them in mind as the concrete anchor for the economics discussion.

# --- Python (boto3) ---
import boto3
 
# A dedicated client - note this is "s3vectors", not the normal "s3" client.
sv = boto3.client("s3vectors")
 
# Write one embedding (1024 floats here) with filterable metadata.
sv.put_vectors(
    vectorBucketName="my-vectors",
    indexName="docs",
    vectors=[{
        "key": "doc-42",
        "data": {"float32": embedding},   # embedding: list[float], len == index dimension
        "metadata": {"source": "handbook", "year": 2026},
    }],
)
 
# Query for the 5 nearest neighbors of a query embedding.
res = sv.query_vectors(
    vectorBucketName="my-vectors",
    indexName="docs",
    topK=5,
    queryVector={"float32": query_embedding},
    returnMetadata=True,
    returnDistance=True,
)
for hit in res["vectors"]:
    print(hit["key"], hit.get("distance"))
# Verify exact operation and parameter names against current boto3 docs (2026 API surface).

// --- TypeScript (AWS SDK v3) ---
import {
  S3VectorsClient, PutVectorsCommand, QueryVectorsCommand,
} from "@aws-sdk/client-s3vectors";
 
const sv = new S3VectorsClient({});
 
// Write one embedding with filterable metadata.
await sv.send(new PutVectorsCommand({
  vectorBucketName: "my-vectors",
  indexName: "docs",
  vectors: [{
    key: "doc-42",
    data: { float32: embedding },      // embedding: number[], length === index dimension
    metadata: { source: "handbook", year: 2026 },
  }],
}));
 
// Query for the 5 nearest neighbors.
const res = await sv.send(new QueryVectorsCommand({
  vectorBucketName: "my-vectors",
  indexName: "docs",
  topK: 5,
  queryVector: { float32: queryEmbedding },
  returnMetadata: true,
  returnDistance: true,
}));
for (const hit of res.vectors ?? []) console.log(hit.key, hit.distance);
// Verify exact operation and parameter names against current @aws-sdk/client-s3vectors docs (2026 API surface).

Now the economics. Because vectors live in S3, you pay three familiar kinds of charge: storage for the bytes at rest, a request charge for writing and querying, and no charge at all for capacity you are not using. There is no cluster humming when traffic is zero. A corpus that is queried twice an hour costs almost nothing between queries, which is exactly the case a rented database punishes you for.

The price of that elasticity is latency. S3 Vectors serves queries from storage, not from a warm in-RAM graph, so a single similarity search typically completes in the tens to low hundreds of milliseconds rather than the single-digit milliseconds a dedicated ANN index can hit. That is fine for a RAG pipeline where the vector search is one step before a multi-second LLM call. It is not fine for an autocomplete box that needs an answer in 5 ms.

Metadata filtering interacts with both cost and quality. Each vector can carry a metadata document, and a query can filter on it (for example, only vectors where year >= 2026). Declaring which metadata keys are filterable at index-creation time lets the service prune candidates during search, so filters are a first-class part of the query, not a post-processing step you pay to run yourself.

Advanced Considerations & Applications

The clearest way to place S3 Vectors is on a cost-versus-latency axis against the alternatives.

The pattern that fits S3 Vectors best is a large, latency-tolerant knowledge base. Think a RAG assistant over a company's documents, a legal or research archive, product manuals, or any corpus where the embeddings are numerous, the query rate is modest, and a hundred milliseconds is invisible next to the generation step that follows.

It also shines as a tiering target. You can keep a small hot set in a fast index and let the long tail of rarely queried vectors live in S3 Vectors at a fraction of the cost, the same instinct that sends cold objects to Glacier.

Where it fits poorly: high-QPS, low-latency serving; workloads that need rich hybrid queries beyond top-k plus metadata filters; or anything already bottlenecked on vector-search latency rather than cost. Those still want a purpose-built database.

A first-class use is as the vector store behind an Amazon Bedrock Knowledge Base, an alternative to OpenSearch Serverless that lets a managed RAG pipeline inherit S3 Vectors' economics. That integration gets its own page in this section.

Common Misconceptions

• "S3 Vectors is just storing embeddings as JSON in a normal bucket." - No. A vector bucket is a distinct bucket type with a dedicated s3vectors API and a real similarity-search engine; you do not GetObject your way through it.
• "It replaces OpenSearch or Pinecone for everything." - No. It targets cost-sensitive, latency-tolerant corpora. Low-latency, high-throughput serving still belongs on a warm index.
• "Because it is S3, queries are as fast as a GetObject." - No. Similarity search does real work; expect tens to hundreds of milliseconds, not the low-ms of an in-memory graph.
• "I can put any-length vector in an index." - No. Each index has a fixed dimension set at creation, and every vector must match it exactly. Changing dimension means a new index.
• "Metadata filtering is free-form and automatic." - Partly. You get the most from it by declaring filterable metadata keys when you create the index, so the service can prune during search.

FAQs

Related

• S3 Vectors Basics - create a bucket and index and write your first embeddings.
• Vector Indexes & Similarity Search Queries - top-k queries, distance metrics, and metadata filtering.
• S3 Vectors vs Self-Hosted Vector Databases - the cost, latency, and ops decision in depth.
• Integrating S3 Vectors with Bedrock Knowledge Bases - use it as a managed RAG vector store.

Stack versions: This page was written for boto3 1.43.x (Python 3.10+) and the AWS SDK for JavaScript v3 (Node.js 18+). Amazon S3 Vectors is a fast-moving 2026 API - verify exact operation and parameter names against current docs. 636f64656775696465732e696f7c6367696f313039367c323032363037