Managed pgvector hosting · PostgreSQL 18 · NVMe · EU + US-East

Managed pgvector hosting
on dedicated NVMe.

Hosted vector search on PostgreSQL with pgvector pre-installed and tuned for production HNSW workloads. Local NVMe keeps 1M-vector searches under 4ms p50 in our benchmark setup — backups, monitoring, and HA failover are part of the platform, not paid afterthoughts.

up to 2,000 QPS<4ms p50from $35/node

Managed pgvector on NVMe — Rivestack hosted vector search architecture
500K+ IOPS
local NVMe per node
< 4 ms
p50 vector search latency
$35/mo
starting, fixed pricing
EU
Hosted in France · GDPR-ready

Why managed pgvector?

Running pgvector yourself is fine until the dataset gets real. Then NVMe, index tuning, and HA stop being optional — and the cheap VPS becomes a second job.

NVMe-grade vector search

HNSW graph traversal is bound by random read latency, not throughput. Local NVMe delivers far lower random-read latency than general-purpose cloud block storage. Same pgvector SQL, better tail behavior when the index no longer fits in memory.

NVMe vs cloud SSD benchmarks →

pgvector pre-installed and tuned

pgvector 0.8.x support, HNSW parameters tuned for common 1536-dim embedding workloads, and ef_search available for workload-specific tuning. No extension hunt, no surprise version drift during upgrades.

pgvector quickstart →

Backups, HA, and metrics — included

Daily snapshots with 14-day PITR, optional Patroni-managed HA cluster with automatic failover, and a per-database metrics dashboard. Same setup a real DBA would build — done by default, not sold as add-ons.

Why managed Postgres for AI →

Rivestack vs Exoscale vs Elestio vs Supabase

Same broad managed PostgreSQL + pgvector category. Different defaults, different storage assumptions, and different levels of help for vector-heavy workloads.

RivestackExoscaleElestioSupabase
Best fitPostgres AI workloadsEuropean cloud buyersMarketplace-style hostingFull app platform
Starting price$0 free · $35/moHourly DBaaS$14/mo+$25 + compute add-ons
Storage defaultDedicated local NVMeManaged DBaaS storageProvider-dependent VM diskCloud block storage
pgvector support0.8.x lineExtension includedExtension serviceExtension included
HNSW tuningWorkload tuned · ef_search guidanceGeneral DB tuningManaged service defaultsExtension defaults
Vector workload reviewIncludedSupport planSupport planCommunity / paid
Pricing modelFixed per nodeHourly usageMonthly servicePlan + usage/add-ons
Migration pathpg_dump, restore, or logical replication helpStandard PostgreSQL toolsDB migration serviceImport/export tooling
Provider pages and prices change; use this as a buying checklist and verify final plan details before committing. Vector benchmarks measured on 1M × 1536-dim, ef_search=40. Full pgvector NVMe vs cloud SSD numbers →

Benchmarks

Measured on the $35/month Starter plan. No synthetic loads, no cherry-picked configs.

Throughput
2,000 QPS
Best in class for this price range
p99 Latency
< 4 ms
Sub-millisecond at low concurrency
Recall
99.5%
HNSW index, cosine distance
Test config:
2 vCPU
4 GB RAM
NVMe
PostgreSQL 18
pgvector 0.8.x
1536 dims
HNSW cosine
ef_search=40

OpenAI text-embedding-3-small (1536 dimensions). Side-by-side numbers vs gp3-backed managed Postgres in the NVMe vs cloud SSD benchmarks.

How it works

From "we should try pgvector" to a working HNSW query — three steps, no extension wrangling.

01

Create a database in 30 seconds

Sign in, pick a region (EU or US-East), pick a node size, click create. The cluster is provisioned, hardened, and ready before your coffee.

02

pgvector is already enabled

No extension hunt. CREATE EXTENSION vector is a no-op — the supported pgvector 0.8.x line ships pre-installed and pre-tuned for HNSW workloads.

03

Build HNSW indexes and query

Standard pgvector — your existing client library, your existing SQL.

step 03 · build an index and querypostgres ≥ 14 · pgvector 0.8.x
CREATE TABLE docs (
  id   BIGSERIAL PRIMARY KEY,
  text TEXT,
  emb  vector(1536)
);

CREATE INDEX ON docs
  USING hnsw (emb vector_cosine_ops);

SELECT id, text, emb <=> $1 AS dist
FROM   docs
ORDER BY emb <=> $1
LIMIT  10;

Need a deeper walkthrough? See the full pgvector getting-started guide and the pgvector vs Pinecone comparison.

Migrate to managed pgvector without rewriting your app

Rivestack is standard PostgreSQL. For pgvector workloads already on Postgres, migration usually means moving data and connection strings, not changing your query model.

01

Supabase, Neon, RDS, Aiven, or Exoscale

Use standard PostgreSQL exports for small databases, or logical replication for always-on systems. Tables, indexes, extensions, roles, and connection strings are reviewed before cutover.

02

Pinecone or another vector database

Export IDs, metadata, and embeddings, then load them into a PostgreSQL table with a vector column. We help map filters back to SQL columns so the migration is not just a bulk insert.

03

Self-hosted pgvector

Move with pg_dump/restore, streaming replication, or a replica promotion plan depending on downtime tolerance. The goal is to retire backup, failover, upgrade, and tuning chores cleanly.

Fixed monthly pricing

One price per node. No per-query billing, no egress surcharges, no vector-count overage. The bill on day 30 matches the quote on day 1.

Shared
$0/month

For testing and prototyping. Shared PostgreSQL with pgvector enabled.

  • Shared CPU · 256 MB RAM
  • pgvector enabled
  • 2 GB storage
  • ~100K vectors (1536d)
  • Community support
  • SSL encrypted
Popular
Starter
$35/node/month

Production-ready dedicated PostgreSQL with NVMe storage, automated backups, and monitoring.

  • 2 vCPU · 4 GB RAM per node
  • 55 GB NVMe storage
  • ~1M vectors (1536d)
  • pgvector tuned (HNSW)
  • HA ready (add nodes)
  • Daily backups + 14d PITR
  • Monitoring dashboard
  • Terraform provider
Growth
$59/node/month

More compute, more storage. Same HA support — add nodes for automatic failover.

  • 4 vCPU · 8 GB RAM per node
  • 135 GB NVMe storage
  • ~5M vectors (1536d)
  • pgvector tuned (HNSW)
  • HA ready (add nodes)
  • Daily backups + 14d PITR
  • Priority support
  • Custom PostgreSQL config
Scale
$99/node/month

High-performance dedicated PostgreSQL for demanding vector workloads.

  • 8 vCPU · 16 GB RAM per node
  • 295 GB NVMe storage
  • ~20M vectors (1536d)
  • pgvector tuned (HNSW)
  • HA ready (add nodes)
  • Daily backups + 14d PITR
  • Priority support
  • Custom PostgreSQL config

Managed pgvector FAQ

What teams ask before moving a real pgvector workload.

Managed pgvector means PostgreSQL with the pgvector extension pre-installed, pre-tuned, and operated for you on dedicated infrastructure. You get the standard pgvector SQL surface — the vector type, HNSW and IVFFlat indexes, distance operators — on top of a database where someone else handles backups, monitoring, replication, failover, and version upgrades. On Rivestack specifically, that infrastructure is local NVMe rather than cloud SSD, which is what HNSW random-read workloads care about most.

Yes. pgvector is used in production for RAG, semantic search, recommendation engines, and embedding search APIs with millions of vectors. The constraints to plan for are memory headroom for the HNSW index, storage latency on cache misses, sensible ef_search and m values, and proper filtering — usually B-tree indexes on the columns used in WHERE alongside the HNSW index. PostgreSQL handles the rest with the same backup, replication, monitoring, and tuning patterns it has used for years.

A well-sized PostgreSQL node handles tens of millions of vectors comfortably; hundreds of millions are reachable with sharding or partitioning. The practical limits are memory available for the HNSW index, storage IOPS under random reads, and how strict your latency targets are. As a rough guide on Rivestack: a 4 GB node serves around 1M 1536-dimension vectors with sub-10ms p95 latency at moderate concurrency, and a 16 GB node serves around 20M.

HNSW (Hierarchical Navigable Small World) is the graph-based approximate nearest neighbor index pgvector uses for fast vector search. Build-time parameters m and ef_construction control graph density; the query-time parameter hnsw.ef_search controls how aggressively the graph is traversed. Higher values mean better recall and slightly higher latency. HNSW search is dominated by random reads, which is why storage latency matters more than CPU once the index no longer fits in memory.

For most teams, yes. pgvector keeps vectors next to the relational data, so filters, joins, and tenant scoping happen in standard SQL — without a second system to keep in sync. Dedicated vector databases still make sense at very large scale (hundreds of millions to billions of vectors) or when the workload is purely vector search with no relational context. For typical RAG and semantic search systems, pgvector on managed PostgreSQL is simpler and cheaper.

Start with the workload, not the provider list. The questions that actually decide it: what storage latency the plan delivers under random reads, how much memory is available for the HNSW index plus PostgreSQL cache, which pgvector version is supported and how upgrades happen, what backup and PITR coverage is included, what the HA topology looks like, how pricing changes when query volume grows, and how the provider helps you migrate from where you are today. A provider that can answer those in workload language is a real candidate.

On a $35/month Rivestack node we measure up to about 2,000 QPS on cached vector workloads, and sub-4ms p50 on the 1M × 1536-dim HNSW benchmark path. Tail latency depends on concurrency, cache residency, filters, and ef_search; the benchmark section shows p99 separately instead of compressing every latency percentile into one marketing number. Full methodology is in the pgvector NVMe vs cloud SSD writeup.

Yes. Supabase and Neon are standard PostgreSQL with pgvector, so migration is pg_dump / pg_restore for smaller databases or logical replication for always-on workloads — typically 30–60 minutes of effort, no application changes. Pinecone is not Postgres, so you re-insert your embeddings into a vector column once; we have a migration helper and we will look at your workload shape before you start.

Rivestack tracks the pgvector 0.8.x release line and rolls extension updates through standard maintenance windows after compatibility testing. New clusters are provisioned with the supported 0.8.x build; existing clusters are upgraded deliberately rather than silently.

Yes. pgvector 0.8.x supports PostgreSQL 13 through 18. Rivestack provisions every cluster on PostgreSQL 18 with pgvector pre-installed, so you can use the latest planner, partitioning, and observability improvements alongside vector search without managing extension compatibility yourself.

Both. HNSW is the default and what we tune for, because it is the right choice for almost every production workload at the scale our customers run. IVFFlat is fully supported when you have a static dataset and want lower index build time and lower memory. You can mix both index types within the same database.

Rivestack

Stop overpaying for
pgvector you don't control.

Free tier with pgvector ready in 60 seconds. Or send us your current setup and we'll tell you in 48 hours whether Rivestack is cheaper, faster, and less painful than what you have today.

Free tier · No credit card · pgvector ready in 60 seconds.