A production RAG pipeline on Amazon Bedrock has five discrete cost centers that most teams only discover after their first AWS bill arrives: embedding ingestion, vector storage, query-time embedding, retrieved-context token overhead on the LLM call, and the infrastructure floor charge from whichever vector store backs the index. The single largest surprise is the OpenSearch Serverless minimum: $345–$350/month regardless of query volume, charged the moment you create a collection. Teams running low-traffic Knowledge Bases often pay more for vector storage than for all LLM inference combined. This note maps every cost component, compares vector store alternatives now that Amazon S3 Vectors is generally available (GA December 2025), and provides sizing calculations for a realistic 1M-document production deployment.
1. Bedrock Knowledge Bases Pricing Components
Ingestion Pipeline
Ingestion is a one-time cost per document load — paid again only on re-ingestion. It has two sub-components:
Document parsing (Bedrock Data Automation):
- Standard output: $0.010/page — covers PDF, DOCX, HTML extraction
- Custom output (with blueprint fields): $0.040/page or $0.005/image, plus an incremental charge for blueprints defining more than 30 fields
- Simple text/Markdown files do not incur parsing charges; parsing applies only when Bedrock Data Automation processes structured documents
Embedding on ingestion:
- Titan Embeddings V2: $0.020/1M tokens ($0.00002/1K tokens)
- Cohere Embed: $0.100/1M tokens ($0.00010/1K tokens)
- Every chunk produced by the chunking stage gets embedded; total cost scales linearly with chunk count, not document count
Ingestion cost example — 10,000-page PDF corpus:
| Step | Volume | Unit Cost | Total |
|---|---|---|---|
| Parsing (standard) | 10,000 pages | $0.010/page | $100 |
| Chunking produces ~30,000 chunks @ 400 tokens avg | 12M tokens | $0.020/1M | $0.24 |
| Ingestion total | ~$100.24 |
The parsing cost dominates for dense document corpora. For plain-text or pre-parsed content, ingestion is nearly free — the embedding cost on 12M tokens is $0.24.
Storage (Vector Index)
Covered in depth in Section 2 (OpenSearch Serverless) and Section 3 (vector store comparison). Storage is the steady-state recurring charge — it runs every hour regardless of query traffic.
Retrieval
Every query triggers two billable events:
- Query embedding: the user’s question is embedded using the same model configured at ingestion time — billed at the same per-token rate ($0.020/1M for Titan V2)
- LLM generation: the RetrieveAndGenerate API constructs a prompt from the query + retrieved chunks + system instructions, then calls the configured foundation model — billed at standard on-demand inference rates
Reranking (optional):
- Amazon Rerank 1.0: $1.00/1,000 reranking queries — adds 10¢ per hundred queries; significant at high volume
Query embedding cost is negligible in isolation (a 50-token query costs $0.000001 with Titan V2), but retrieved-context token overhead on the LLM call is the real variable — see Section 7.
2. OpenSearch Serverless OCU Economics
OCU Pricing
OpenSearch Serverless bills on OpenSearch Compute Units (OCUs), not on instance hours. Each OCU covers compute + memory for either indexing or search workloads.
- Price: $0.24/OCU-hour (us-east-1, us-west-2)
- Indexing OCUs: handle write throughput during ingestion sync jobs
- Search OCUs: handle query-time vector similarity search
- OCUs auto-scale independently; you pay only for what’s consumed, subject to the minimum below
The $345/Month Floor
The most important number in Bedrock Knowledge Bases FinOps:
Every collection requires a minimum of 2 OCUs (1 indexing + 1 search). At $0.24/OCU-hour, that floor is $0.48/hour = $345.60/month, charged continuously even when zero queries are running.
This floor applies per-collection, not per-account. Teams that create separate collections per environment (dev/staging/prod) pay $345.60 × 3 = $1,036.80/month before writing a single document.
Indexing OCU scaling during ingestion: A sync job on a large corpus can temporarily scale to 4–8 indexing OCUs. A job that runs for 2 hours at 4 OCUs costs 8 OCU-hours × $0.24 = $1.92 — small relative to the monthly floor but worth including in ingestion-cost calculations.
Storage within OpenSearch Serverless: $0.024/GB-month. A typical 1M-chunk index with 1536-dimensional float32 vectors (Titan V2 default) occupies roughly 6 GB of raw vector data; with metadata and inverted indexes, expect 15–20 GB total, costing $0.36–$0.48/month — trivial relative to the OCU floor.
When the OCU Floor Becomes Untenable
The $345/month floor is economically rational above approximately 5,000–10,000 queries/month at typical LLM spend. Below that threshold, OpenSearch Serverless often exceeds total LLM inference cost. Decision thresholds:
| Monthly Query Volume | OpenSearch Floor as % of Typical Total RAG Spend | Recommendation |
|---|---|---|
| < 1,000 | > 80% | Switch to S3 Vectors or pgvector |
| 1,000–10,000 | 30–60% | Evaluate S3 Vectors or Aurora pgvector |
| 10,000–100,000 | 5–20% | OpenSearch Serverless is reasonable |
| > 100,000 | < 5% | OpenSearch Serverless optimizes for latency |
3. Vector Store Cost Comparison for RAG
The 2026 Landscape
Amazon S3 Vectors (GA December 2025) fundamentally changed the make-or-buy calculus for Bedrock Knowledge Bases. It is now a first-party AWS managed vector store with native Knowledge Bases integration that eliminates the OCU floor.
| Store | Monthly Floor | Storage Cost | Query Cost | Integration with Bedrock KB | Best For |
|---|---|---|---|---|---|
| OpenSearch Serverless | $346 (2 OCU) | $0.024/GB | Included in OCU | Native | High-volume, low-latency (<50ms p50) |
| Amazon S3 Vectors | $0 | $0.06/GB | $0.004/TB processed (Tier 1) | Native (GA 2025) | Low-to-medium volume, cost-first |
| Aurora PostgreSQL pgvector | ~$43 (0.5 ACU serverless v2) | $0.10/GB (io2) | Included in ACU | Supported | Existing Postgres users, <10M vectors |
| Pinecone Serverless | $0 (free tier to 100K vecs) | ~$0.033/GB | $0.08/1M queries | Via LangChain/custom | Managed, predictable per-query billing |
| Qdrant Cloud | ~$25 (1 node) | ~$0.014/GB | Included | Via custom | Self-hosted hybrid, price-sensitive |
S3 Vectors Cost Detail
S3 Vectors uses tiered query processing pricing based on index size:
- Storage: $0.06/GB-month
- PUT (upload): $0.20/GB
- Query processing Tier 1 (small indexes): $0.004/TB of vector data scanned
- Query processing Tier 2 (indexes >10M vectors): reduced rate — up to 80% lower than Tier 1, announced June 2026
- Latency: sub-second for infrequent queries; as low as 100ms for frequent/warm indexes
For a 1M-vector index (float32 1536-dim ≈ 6 GB): monthly storage = $0.36. Query cost at 10,000 queries/month scanning 6 GB each = 60 TB scanned × $0.004/TB = $0.24/month. Total: $0.60/month vs. $345.60 for OpenSearch Serverless — a 99.8% reduction for low-volume workloads.
pgvector on Aurora Serverless v2
Aurora Serverless v2 gained auto-pause capability (min_capacity=0) as of May 2026. With auto-pause enabled, a pgvector instance costs $0 when idle and $0.12/ACU-hour when active ($0.06/ACU-hour × 2 ACUs minimum when running). This makes it viable for dev/staging environments and low-traffic production use cases.
Limit: pgvector performance degrades significantly beyond 5–10M vectors without HNSW index tuning. IVFFlat indexes require periodic rebuilding as vectors are added. For Knowledge Bases exceeding 10M chunks, OpenSearch Serverless or a dedicated vector database is architecturally sounder.
4. Embedding Model Selection
Cost Per Token (us-east-1, 2026)
| Model | Dimensions | Cost/1M tokens | Max Input | Notes |
|---|---|---|---|---|
| Amazon Titan Embeddings V2 | 256 / 512 / 1536 | $0.020 | 8,192 tokens | Default for Bedrock KB; variable dimensionality |
| Cohere Embed English v3 | 1024 | $0.100 | 512 tokens | 5× Titan cost; better MTEB on English |
| Cohere Embed Multilingual v3 | 1024 | $0.100 | 512 tokens | Required for non-English corpora |
| OpenAI text-embedding-3-small (via third-party) | 1536 | ~$0.020 | 8,191 tokens | Not native to Bedrock KB; requires custom retrieval pipeline |
Dimensionality and Storage Cost Tradeoffs
Titan Embeddings V2 supports three dimensionality settings — 256, 512, or 1536 — at the same per-token price. Choosing 256 dimensions instead of 1536 reduces vector storage by 6× with modest retrieval quality loss:
| Dimensions | Vector Size (float32) | 1M chunks storage | Monthly cost (OpenSearch) |
|---|---|---|---|
| 256 | 1 KB | 1 GB | $0.024 |
| 512 | 2 KB | 2 GB | $0.048 |
| 1536 | 6 KB | 6 GB | $0.144 |
Storage savings are marginal relative to the OCU floor but become meaningful at S3 Vectors scale (billions of vectors).
Practical recommendation: Use Titan V2 at 1536 dimensions for English-only knowledge bases — it matches Cohere’s retrieval quality on most enterprise benchmarks at 1/5th the token cost. Use Cohere Embed Multilingual v3 only when the corpus contains non-English documents.
5. Chunking Strategy and Cost
Available Strategies in Bedrock Knowledge Bases
| Strategy | How It Works | Chunks per 1K tokens of source | Cost Multiplier |
|---|---|---|---|
| Fixed-size | Split every N tokens, optional overlap | 2–4× (with overlap) | 1.0× baseline |
| Semantic | Embed sentences, merge by cosine similarity | 1.5–3× | 1.5–3× (extra embedding passes) |
| Hierarchical | Parent + child chunk pairs | 2–5× | 2–5× |
| Custom (via Lambda) | Any logic | Varies | Varies |
How Chunk Size Affects Cost
Every chunk is embedded exactly once at ingestion. Total embedding cost = (number of chunks) × (average tokens per chunk) × (embedding price/token). Since total tokens ≈ total source tokens regardless of chunk size, embedding cost is approximately constant for fixed-size chunking without overlap.
Overlap is where cost multiplies: A 20% overlap setting means 20% of tokens are embedded twice. On a 10M-token corpus with Titan V2 at $0.020/1M:
- No overlap: $0.20
- 20% overlap: $0.24 (+20%)
- 50% overlap: $0.30 (+50%)
Semantic chunking is more expensive at ingestion because the algorithm makes multiple embedding passes to compute sentence-level similarity before grouping. AWS documentation and third-party benchmarks confirm it is also limited to 1 MB per file, making it unsuitable for technical documents, legal contracts, or any source file exceeding that threshold.
Recommendation for cost-optimized production: Fixed-size chunking at 512 tokens, 10% overlap, using Titan V2 at 1536 dimensions. This covers most retrieval quality requirements while keeping chunk count predictable. Reserve semantic chunking for corpora where chunk boundary quality is critical and source files are small (FAQ databases, knowledge articles).
Re-Ingestion Costs
Bedrock Knowledge Bases does not support delta updates — changing any document in a data source triggers a full sync of that data source. Re-ingestion costs:
- Re-parsing: $0.010/page for any document that changed (and any document in the same sync batch)
- Re-embedding: all chunks for re-synced documents are re-embedded
Nightly refresh pipelines on a 100,000-page corpus where 5% of pages change daily:
- Daily parsing cost: 5,000 pages × $0.010 = $50/day → $1,500/month
- Daily embedding: 5,000 pages × ~3 chunks/page × 400 tokens × $0.020/1M = $0.12/day → $3.60/month
- Parsing dominates re-ingestion cost by 400×
Mitigation: Separate data sources by update frequency. High-change content (news, reports) in one data source; stable reference content (policies, product specs) in another. This prevents stable content from being re-parsed when only volatile content changes.
6. Retrieval Augmentation Token Overhead
How Retrieved Context Inflates LLM Input Token Count
A standard Bedrock Knowledge Bases RetrieveAndGenerate call assembles a prompt with:
- System prompt: ~200–500 tokens (static, can be cached)
- User query: 20–100 tokens
- Retrieved context: 4–20 retrieved chunks × 200–600 tokens/chunk = 800–12,000 tokens
- Citation/formatting instructions: ~100 tokens
For a Knowledge Base configured to return 5 chunks at 512 tokens each, the retrieved context alone adds 2,560 input tokens to every generation call. At Claude Sonnet pricing ($3.00/1M input tokens), that context costs $0.0077 per query — before the query itself or the system prompt.
Token overhead at scale:
| Queries/Month | Chunks Retrieved | Avg Context Tokens | Monthly Context Cost (Claude Sonnet) |
|---|---|---|---|
| 10,000 | 5 × 512 | 2,560 | $76.80 |
| 100,000 | 5 × 512 | 2,560 | $768 |
| 1,000,000 | 5 × 512 | 2,560 | $7,680 |
Prompt caching reduces this substantially: The system prompt portion (static instructions, ~300 tokens) can be cached at $0.30/1M input tokens (90% reduction from $3.00). Retrieved chunks are query-specific and cannot be cached across different queries but may be cacheable within a multi-turn conversation.
Compressing Retrieved Context Before Injection
Context compression — summarizing retrieved chunks to extract only query-relevant sentences before injecting into the LLM prompt — can reduce retrieved context tokens by 50–70%, cutting input token costs by a similar margin. The tradeoff: compression requires an additional LLM call (or a smaller compression model), so the net saving depends on the cost ratio between the compression model and the generation model.
Compression cost example using Haiku as compressor:
- 2,560 tokens retrieved → compress with Claude Haiku ($0.25/1M input): $0.00064
- Compressed context: 768 tokens → save 1,792 tokens at Sonnet pricing: $0.0054 saved
- Net saving per query: $0.0054 − $0.00064 = $0.0048/query
- Break-even volume: positive ROI from the first query; worthwhile at any scale above 10,000 queries/month
7. RetrieveAndGenerate vs. Custom Retrieval Pipeline
What RetrieveAndGenerate Provides
The managed RetrieveAndGenerate API:
- Embeds the query, retrieves top-K chunks, assembles the prompt, calls the LLM, and returns the answer + citations in one API call
- No infrastructure beyond the vector store
- Supports hybrid search, reranking, and metadata filtering as configuration options
- Cost: sum of query embedding + vector store query + LLM call (no API-level surcharge)
Custom Retrieval Pipeline
A custom pipeline separating the Retrieve API from LLM inference allows:
- Query rewriting/expansion before retrieval (improves recall, adds one LLM call per query)
- Custom chunk fusion or re-ranking logic
- Injection of structured data (SQL query results, API responses) alongside retrieved chunks
- Use of any LLM, not just Bedrock-hosted models
- Semantic caching of query embeddings across similar questions
Cost comparison at 100,000 queries/month:
| Approach | Additional Cost | Complexity | Quality Uplift |
|---|---|---|---|
| RetrieveAndGenerate (managed) | None | Low | Baseline |
| + Custom reranker | $100 (Rerank 1.0) | Low | 10–15% precision gain |
| + Query rewriting | ~$30 (Haiku, 300 tok/query) | Medium | 15–25% recall gain |
| + Context compression | Net negative (saves $480/mo) | Medium | Neutral |
| Full custom pipeline | ~$50–200 infra | High | Depends on implementation |
When to build a custom pipeline: When retrieval quality directly affects revenue (e.g., customer-facing support bots where wrong answers churn users), when hybrid data sources (SQL + vector) are required, or when query volume exceeds 1M/month and cost optimization requires surgical caching that the managed API does not expose.
8. Hybrid Search Cost Patterns
What Hybrid Search Adds
Hybrid search combines dense vector similarity (ANN) with sparse keyword retrieval (BM25/TF-IDF). Benchmarks show 10–30% higher recall than vector-only search on diverse enterprise corpora, and a 7.4% NDCG lift on WANDS benchmark at optimized weighting.
OpenSearch (including Serverless) supports hybrid search natively via Reciprocal Rank Fusion (RRF) with no additional per-query infrastructure cost — BM25 and vector search run in the same query plan, fused with RRF on the server side.
Infrastructure cost impact of enabling hybrid search in OpenSearch Serverless:
- Additional indexing OCU-hours during ingestion (BM25 inverted index construction alongside vector indexing): ~10–20% more indexing OCU usage
- Additional search OCU load per query: ~15–25% higher OCU consumption per query due to parallel keyword + vector path
- No separate billing line — OCU auto-scaling absorbs this transparently; net monthly impact is 10–20% higher OCU spend at high query volumes
For S3 Vectors: Hybrid search is not natively supported as of June 2026. Teams needing BM25 alongside S3 Vectors must maintain a separate inverted index (e.g., a small OpenSearch domain or Typesense instance), adding $50–$150/month for the keyword search layer.
Bedrock Knowledge Bases Hybrid Search Support
Bedrock Knowledge Bases (with OpenSearch Serverless backend) has supported hybrid search since March 2024 — configurable without code changes, enabled via Knowledge Base settings. Bedrock Rerank 1.0 at $1.00/1,000 queries provides an additional cross-encoder reranking pass after hybrid fusion, improving precision by another 5–15%.
9. RAG Pipeline Monitoring and Cost Attribution
Tracking Cost Separately in CUR
AWS Cost and Usage Reports (CUR) surface Bedrock Knowledge Bases charges under distinct line items:
AmazonBedrock/EmbeddingModels— ingestion and query embeddingAmazonOpenSearchService/OCU-Hour— vector storage floor and query computeAmazonBedrock/InferenceModels— LLM generation calls (RetrieveAndGenerate)AmazonBedrock/DataAutomation— document parsing at ingestionAmazonCloudWatch/DataProcessing-Bytes— prompt/response logging at $0.50/GB
CUR does not automatically split embedding costs between ingestion-time and query-time embedding — both appear under EmbeddingModels. Use CloudWatch custom metrics to track ingestion sync job timestamps, then attribute embedding costs to the ingestion period.
CloudWatch Metrics for RAG Observability
| Metric | Namespace | What to Alert On |
|---|---|---|
KnowledgeBaseQueryDuration |
AWS/Bedrock |
p95 > 2s indicates OCU pressure |
KnowledgeBaseRetrievalCount |
AWS/Bedrock |
Zero count = retrieval failure |
OCUActiveCount |
AWS/OpenSearchServerless |
Spike → unexpected ingestion job |
EmbeddingTokensProcessed |
Custom (via Lambda instrumentation) | Anomaly → runaway sync job |
InvocationLatency |
AWS/Bedrock |
Foundation model cold start or throttling |
CloudWatch log costs for a high-volume RAG deployment (1M queries/month, logging 3 KB/request) = 3 GB/day × $0.50/GB = $45/month — a non-trivial cost worth filtering to error cases only for production.
10. Cost Optimization Patterns
Query Caching for Repeated Questions
Many enterprise Knowledge Bases receive semantically identical or near-identical queries (FAQ patterns, common support questions). Caching strategies:
- Exact-match cache (DynamoDB or ElastiCache): cache
hash(query) → response; zero retrieval or generation cost on cache hit - Semantic cache (vector similarity on query embeddings): cache queries with embedding similarity > 0.95; requires one embedding call but avoids retrieval + generation
At 30% cache hit rate on 100,000 queries/month, caching saves ~30,000 × ($0.023 retrieval + $0.025 generation) = $1,440/month. DynamoDB cache cost for this volume: ~$5/month. Semantic cache with ElastiCache Serverless: ~$20–50/month. Net positive at any hit rate above 2–3%.
Batching Ingestion for 50% Discount
Bedrock offers batch inference at 50% lower pricing for asynchronous embedding jobs. Batch processing is available for embedding models on Bedrock. For a nightly re-ingestion pipeline that is not latency-sensitive, routing embedding calls through the Batch Inference API halves embedding costs:
- On-demand Titan V2: $0.020/1M tokens
- Batch Titan V2: $0.010/1M tokens
On a corpus that re-embeds 1M tokens nightly: $0.010/night saved = $3/month — negligible on small corpora, but on a 100M-token nightly refresh, batch saves $300/month.
Reducing Retrieved Chunk Count
The default Knowledge Base configuration returns 5 chunks. Reducing to 3 cuts retrieved-context token overhead by 40%, reducing LLM input token costs proportionally. Test recall at 3 vs. 5 chunks on a held-out query set before reducing in production — for most factual enterprise QA tasks, 3 chunks is sufficient when chunking and embedding quality are high.
11. Knowledge Base Sizing: 1M-Document Estimate
Assumptions
- 1,000,000 documents, average 5 pages each = 5,000,000 pages
- Average 3 chunks per page at 400 tokens = 15,000,000 chunks; 6 billion tokens
- Titan V2 embeddings at 1536 dimensions
- OpenSearch Serverless backend (production-grade baseline)
- 50,000 queries/month, 5 chunks retrieved per query, Claude Sonnet as generation model
- 10% monthly document update rate (100,000 pages re-ingested/month)
One-Time Ingestion Cost
| Component | Volume | Unit Cost | Total |
|---|---|---|---|
| Document parsing | 5M pages | $0.010/page | $50,000 |
| Embedding (6B tokens) | 6,000,000,000 tokens | $0.020/1M | $120 |
| Ingestion total | $50,120 |
Parsing cost is the dominant ingestion expense — $50,000 for the initial load. If documents are pre-parsed (plain text, Markdown), this drops to $120.
Monthly Steady-State Cost
| Component | Volume | Unit Cost | Monthly |
|---|---|---|---|
| OpenSearch Serverless floor | 2 OCU continuous | $0.24/OCU-hr | $345.60 |
| OpenSearch storage (30 GB index) | 30 GB | $0.024/GB | $0.72 |
| Query embedding | 50,000 queries × 50 tok | $0.020/1M | $0.05 |
| LLM inference — retrieved context | 50K × 2,560 tok input | $3.00/1M | $384 |
| LLM inference — output | 50K × 400 tok output | $15.00/1M | $300 |
| Reranking (Rerank 1.0) | 50K queries | $1.00/1K | $50 |
| Re-ingestion parsing (10% update rate) | 500K pages/mo | $0.010/page | $5,000 |
| Re-ingestion embedding | 600M tokens/mo | $0.020/1M | $12 |
| CloudWatch logging (filtered) | ~5 GB/mo | $0.50/GB | $2.50 |
| Monthly steady-state total | ~$6,095 |
Cost Breakdown by Category
| Category | Monthly | % of Total |
|---|---|---|
| Re-ingestion (parsing) | $5,000 | 82% |
| LLM generation | $684 | 11% |
| Vector store infrastructure | $346 | 6% |
| Reranking | $50 | <1% |
| Embedding (queries) | $0.05 | <1% |
The dominant cost is re-ingestion parsing — not LLM inference, not vector storage. For document-heavy corpora with high update rates, minimizing unnecessary re-parsing has a larger ROI than any other optimization.
Optimization Scenario: S3 Vectors + No Reranking + 3-Chunk Retrieval
| Change | Monthly Saving |
|---|---|
| Switch to S3 Vectors (eliminate OCU floor) | $345 |
| Remove reranking | $50 |
| Reduce retrieved chunks from 5 to 3 | $230 |
| 30% query cache hit rate | $432 |
| Batch ingestion embedding | $6 |
| Total optimization saving | $1,063/month |
Optimized monthly cost: ~$5,032 — with most remaining spend in re-ingestion parsing. The only way to further reduce that cost is to reduce update frequency or separate data sources by update rate.
Alternative: S3 Vectors Backend
Replacing OpenSearch Serverless with S3 Vectors at this scale (15M vectors, 30 GB):
- Storage: 30 GB × $0.06 = $1.80/month
- Query processing: 50,000 queries × 30 GB scanned = 1,500 TB × $0.004/TB = $6/month (Tier 1; Tier 2 pricing applies beyond 10M vectors, reducing this by up to 80% → ~$1.20/month)
- Vector store cost: $3/month vs. $346/month — 99% reduction
Latency tradeoff: S3 Vectors returns results in <1 second for infrequent queries, 100ms for warm/frequent indexes. For internal tooling and async workflows, this is acceptable. For customer-facing chat with <200ms p95 requirements, OpenSearch Serverless remains the right choice.
Key Findings
-
The $345/month OpenSearch Serverless floor is the most common cost shock — teams running dev/test Knowledge Bases, low-traffic pilots, or multiple environments pay this floor for each collection, often exceeding all LLM inference costs.
-
Amazon S3 Vectors (GA December 2025) changes the calculus for low-to-medium volume — at 50K queries/month, it reduces vector store cost from $346 to $3/month with acceptable latency for non-real-time use cases. Native Bedrock Knowledge Bases integration removes the need for custom retrieval plumbing.
-
Re-ingestion parsing, not embedding, is the cost driver for document-heavy corpora — at $0.010/page for Bedrock Data Automation, a corpus with frequent updates can easily generate $5,000+/month in parsing costs alone. Separating data sources by update frequency is the highest-ROI optimization.
-
Retrieved context token overhead on the LLM call often exceeds all other retrieval costs combined — at 50K queries/month with 5 chunks × 512 tokens, Claude Sonnet input costs $384/month just for the retrieved context. Context compression with Haiku as a compressor yields net-positive economics from the first query.
-
Titan Embeddings V2 is the default Bedrock KB embedding model at $0.020/1M tokens — 5× cheaper than Cohere Embed. Use Cohere only for multilingual corpora. Variable dimensionality (256/512/1536) at the same price allows storage optimization at scale.
-
Hybrid search in OpenSearch Serverless adds 10–20% OCU cost for a 10–30% recall improvement — typically a positive tradeoff. S3 Vectors does not natively support hybrid search and requires a separate keyword index layer.
-
Query caching delivers the best cost-per-dollar optimization at high FAQ-pattern volumes — 30% cache hit rate saves more than switching embedding models or reducing chunk count, with minimal quality impact.
Sources: AWS Bedrock Pricing page (aws.amazon.com/bedrock/pricing), Amazon S3 Vectors GA announcement (December 2025), S3 Vectors June 2026 query pricing reduction announcement, OpenSearch Serverless pricing documentation, MarkTechPost vector database comparison (May 2026), community cost analyses at cloudburn.io, darryl-ruggles.cloud, and medium.com/@dhemanthc.