· via dev.to (home feed)
Pinecone's pg_pinecone adds in-database vector search with native, pgvector and remote engines
Pinecone's Apache-2.0 Postgres extension pg_pinecone runs vector search inside the database with three interchangeable engines; its benchmarks report a 136 MB native index against a 4.1 GB HNSW equivalent.
Pinecone has released pg_pinecone, an Apache-2.0 licensed extension that runs vector search inside PostgreSQL rather than in a separate service. According to the announcement post, published 27 October 2026, each table picks one of three execution engines while applications keep sending the SQL they already use. A v0.13.0 release followed on 15 November 2026 with packaging and security additions, per its GitHub release page. Pinecone's overview notes the extension targets self-managed PostgreSQL 17 and 18 servers, requires superuser access to install, and that the remote engine and full-text search need a server-level setting — worth catching before a production rollout.
Three engines behind familiar SQL
The interface is deliberately ordinary: an application sends the pgvector-style distance ordering with a limit that it already sends, and pg_pinecone answers it. Rows, full vectors included, stay in Postgres, and nothing in the calling code reveals which engine replied.
Each table chooses one of three. The native engine builds an index inside Postgres with no account, no API key and no outbound network traffic. The pgvector engine searches an HNSW index the team already operates, which makes the extension a way to trial the alternative without a migration. The remote engine forwards searches to Pinecone's managed service while the rows remain in the database.
How the native engine stores vectors
The native engine pairs IVF clustering with RaBitQ compression: vectors are grouped into clusters and each is stored as a compact binary code. A query probes the nearest clusters, estimates distances from the codes, then rechecks the shortlist against the full vectors held in the table. Because the index holds codes rather than whole vectors, it stays small and builds fast. The v0.10.0 release notes describe builds that calibrate probe counts and rescoring pool sizes against a chosen recall target, optionally using a table of real queries for calibration.
What the vendor's benchmark shows
Every figure comes from Pinecone's own post, run on a single machine: an AWS r6id.4xlarge with 16 vCPUs and 128 GB of RAM, holding one million wiki_dpr vectors of 768 dimensions.
On that setup the native engine produced a 136 MB index against 2.0 GB for HNSW on halfvec and 4.1 GB for full-size HNSW, with build times of 45 seconds versus 62 and 79. Unfiltered search at 0.95 and 0.99 recall took 1.27 and 2.28 ms for the native engine, 1.71 and 4.65 ms for HNSW on halfvec, and 2.67 and 6.72 ms full-size.
A memory note reframes those numbers: with RAM capped at 4 GB, the native engine and HNSW on halfvec hold their latency, while full-size HNSW slows roughly threefold at 0.95 recall and fourfold at 0.99 because the graph stops fitting. The dev.to write-up cautions that all measurements come from the vendor on one instance size, so teams should benchmark their own tables through both engines before choosing.
Where filtering matters most
Applications usually scope queries to a tenant or a user, and graph indexes handle that poorly: HNSW applies the filter to its candidate set, so a narrow filter can starve the results of qualifying rows. The native engine applies filters during the search itself. At a 1% filter, Pinecone measured 0.981 recall at 8.3 ms for the native engine against 0.924 recall at 56 ms for HNSW on halfvec, against a 0.95 recall target. At a 10% filter HNSW answers faster, at 5.9 ms, but lands at 0.920 recall — below target — while the native engine reaches 1.000 recall at 12.3 ms.
Scaling out and the 0.13.0 release
When a table outgrows its server, the remote engine takes over: the search moves to a Pinecone index, the rows stay in Postgres, and the switch is one SQL call in either direction, since the data needed to rebuild locally never leaves the table. Pinecone's overview adds that each tenant can map to its own namespace, so a query touches only that tenant's data. The v0.10.0 release notes report end-to-end backfill at 847 rows per second at 768 dimensions, up from 55, with a limit of 100 served as a single request.
Version 0.13.0, from 15 November 2026, supplies the operational layer: a one-call health check, PGXN packaging, a mandatory HTTPS control-plane URL, and signed, attested release artifacts.
Why it matters
The usual pattern for embeddings is a second system: copy vectors out of Postgres and keep the two in sync. pg_pinecone collapses that into the database the application already queries, and the per-table engine switch makes the choice reversible and testable against real data, including beside an existing pgvector index. The compressed-code design offers a genuinely different trade-off — much smaller and faster-building indexes, stable latency under memory pressure, and recall that survives narrow filters — properties that matter on a server also handling transactional traffic. The caveats are real: vendor-run benchmarks, one instance size, superuser installation and server settings for some features. But the health check, packaging and signed artifacts in 0.13.0 point toward a project preparing for production use.
- #postgresql
- #vector-search
- #open-source
- #pinecone
- #extensions