pg_pinecone Runs Vector Search Inside the Postgres Database

pg_pinecone is an Apache 2.0 Postgres extension with a native IVF and RaBitQ index, three engines behind one SQL query, and a 136 MB index for a million vectors.

"Netics card on pg_pinecone and its index inside Postgres, over a photo of server storage."
"Netics editorial visual on where a vector index lives when it sits inside the database."

TL;DR

  • pg_pinecone is a PostgreSQL extension, Apache 2.0 licensed, that adds vector search to an existing database so applications keep sending the same SQL and the rows stay where they are.
  • Each table picks one of three engines: native builds the index inside Postgres with no account and no network call, pgvector searches the HNSW index a team already runs, and remote sends the search to an index in Pinecone's managed service.
  • The native engine stores vectors as short RaBitQ codes inside IVF clusters, which produces a small index that builds fast and gets filtered during the search itself.
  • Pinecone's own benchmark on 1M vectors of 768 dimensions measured a 136 MB index for the native engine against 4.1 GB for a full-size HNSW index, with build times of 45 s against 79 s.
  • Filtering is where the design shows: at a 1% filter the native engine held 0.981 recall at 8.3 ms while HNSW on halfvec reached 0.924 recall at 56 ms, with a 0.95 recall target on the chart.
  • The remote engine is the scale path, and the switch is one SQL call in either direction because Postgres keeps every row on every engine.
  • According to the v0.13.0 GitHub release page, the project's release on 15 November 2026 adds a one-call health check, PGXN packaging, a mandatory HTTPS control-plane URL and signed, attested artifacts, which is the operational story catching up with the search story.
  • The measurements all come from the vendor, on one instance size, so a team still has to run its own table through both engines before choosing.
Page capture of Pinecone's introduction post for pg_pinecone, pinecone.io/blog/introducing-pg-pinecone
Page capture of "Introducing pg_pinecone: Open-Source Search for Your Postgres Data", published 27 October 2026 by Harshita Daddala and Anthony Mahanna. Source: pinecone.io/blog/introducing-pg-pinecone, captured 17 November 2026.

A vector index used to be a separate system by default: an application held the rows in Postgres, copied the embeddings into a second service, and kept the two in step through a pipeline somebody owned. pg_pinecone is Pinecone's answer to that arrangement, and it moves the index back into the database server the application already talks to.

What pg_pinecone installs into a database

Pinecone's pg_pinecone overview states that it is an Apache 2.0 extension for PostgreSQL 17 and 18 servers managed by the installing team, and that installation requires superuser access. The remote engine and full-text search, according to the same overview, also need a server setting, a requirement to plan for in a production deployment.

Netics comparison of a graph index and the native engine, pinecone.io/blog/introducing-pg-pinecone
Netics visual, 17 November 2026: what a graph index keeps in memory beside what the native engine keeps, and the three steps a native query runs.

The interface it exposes is deliberately unremarkable. An application sends the pgvector SQL it already sends, ORDER BY embedding <=> $1 LIMIT 10, and pg_pinecone answers it. Tables, including the full vectors, stay in Postgres, and Postgres stays the system of record. Nothing in the calling code learns which engine answered.

How the native engine stores a vector

A graph index keeps every full vector and a set of neighbour links in memory, and a search walks those links toward the query. The native engine uses IVF and RaBitQ: IVF groups vectors into clusters, RaBitQ stores each vector as a short binary code, and a query probes the nearest clusters, estimates distance from the codes, then rechecks the shortlist against the full vectors.

Two consequences follow from that storage choice, and Pinecone states both. The index is small enough to scan quickly because the codes compress each vector while the row retains the full vector. The build is faster for the same reason: it constructs the clustered code index, and the v0.10.0 GitHub release page reports that every build calibrates its probe count and rescore pool against a target recall, either on rows or on a table of real queries supplied for calibration.

Pinecone's index size chart, 136 MB against 2.0 GB and 4.1 GB, pinecone.io/blog/introducing-pg-pinecone
Pinecone's own chart: index size for 1M vectors of 768 dimensions, 136 MB for pg_pinecone against 2.0 GB for HNSW on halfvec and 4.1 GB for HNSW full-size. Source: pinecone.io/blog/introducing-pg-pinecone, retrieved 17 November 2026.

What the benchmark measured on one machine

Every chart in the post runs on the same box: 1M vectors of 768 dimensions from wiki_dpr, one AWS r6id.4xlarge with 16 vCPUs and 128 GB of RAM. Unfiltered search at 0.95 and 0.99 recall came out at 1.27 and 2.28 ms for pg_pinecone, against 1.71 and 4.65 ms for pgvector's HNSW on halfvec and 2.67 and 6.72 ms for HNSW full-size.

The post also prints a memory note that changes how those numbers should be read. With memory capped at 4 GB, pg_pinecone and HNSW on halfvec keep their latency, while HNSW full-size runs about three times slower at 0.95 recall and four times slower at 0.99. The full-size graph simply stops fitting, which is the failure mode teams hit on a database server that also serves transactional traffic.

Pinecone's index build time chart, 45 s against 62 s and 79 s, pinecone.io/blog/introducing-pg-pinecone
Pinecone's chart for index build time on the same table: 45 s for pg_pinecone against 62 s for HNSW halfvec and 79 s for HNSW full-size. Source: pinecone.io/blog/introducing-pg-pinecone, retrieved 17 November 2026.

Why filtering breaks a graph index

A query scoped to one tenant is the normal case in a business application, and a graph index handles it badly. A graph index applies the filter to its nearest-neighbour candidates, so a narrow filter can leave fewer rows than the query asked for. Pinecone describes the effect directly: when a query is scoped to one user or one tenant, a graph index can return fewer results of a quality the application needs.

With a filter column such as a tenant ID, the native engine applies the filter during the search. The measured result on a 1% filter is the clearest number in the post: 0.981 recall at 8.3 ms for pg_pinecone, against 0.924 recall at 56 ms for pgvector's HNSW on halfvec, with a 0.95 recall target drawn on the chart. At a 10% filter the native engine reached 1.000 recall at 12.3 ms while HNSW reached 0.920 recall in 5.9 ms, which is the trade named honestly: the graph answers faster and misses the target.

Pinecone's unfiltered latency chart at 0.95 and 0.99 recall, pinecone.io/blog/introducing-pg-pinecone
Pinecone's unfiltered latency chart: 1.27 and 2.28 ms for pg_pinecone, 1.71 and 4.65 ms for HNSW on halfvec, 2.67 and 6.72 ms for HNSW full-size. Source: pinecone.io/blog/introducing-pg-pinecone, retrieved 17 November 2026.

When the remote engine takes over

One Postgres server has a ceiling, and the extension acknowledges it with a second engine inside the same architecture. A table that outgrows its server switches to remote, and the vector search moves to a Pinecone index while Postgres keeps the rows. The queries do not change, and each switch can be reversed, because the data needed to rebuild a local index is still in the table.

Two operational details define the remote engine. Pinecone's pg_pinecone overview states that each tenant can have its own Pinecone namespace, so a query searches only that tenant's data. The v0.10.0 GitHub release page reports a backfill rate of 847 rows per second end to end at 768 dimensions, up from 55, with LIMIT 100 served as a single request.

Pinecone's filtered search chart, recall against latency, pinecone.io/blog/introducing-pg-pinecone
Pinecone's filtered search chart: recall against latency at 1% and 10% filters, with a 0.95 recall target line, HNSW on halfvec with iterative scans enabled. Source: pinecone.io/blog/introducing-pg-pinecone, retrieved 17 November 2026.

Which engine belongs on which table

The decision comes down to three questions, and the extension is built so that the answer can change later. A table that fits comfortably on its server and serves filtered queries from an application goes to native, which needs no account, no key and no egress. A table already indexed with pgvector can stay on pgvector while the same SQL keeps working, which makes the extension a way to test the alternative without a migration. A table whose embeddings have outgrown its server goes to remote, and keeps its rows in Postgres.

What the 0.13.0 release adds to the operation

Search quality is the part of the story a benchmark can settle, and operations is the part that decides whether a team adopts an extension at all. The v0.13.0 GitHub release page says that version 0.13.0, released on 15 November 2026, adds pinecone.doctor() as a one-call setup and health check, publishes the project on PGXN, requires HTTPS on the control-plane URL, runs cargo-deny against licenses, sources, bans and advisories, and signs and attests the release artifacts.

Netics fact card on the index size measured for pg_pinecone, pinecone.io/blog/introducing-pg-pinecone
Netics visual, 17 November 2026: the index size for a million 768-dimension vectors, and the machine the measurement ran on.

The packaging detail matters as much as the health check. The same GitHub release page lists tarballs for PostgreSQL 17 and 18 on darwin-arm64, linux-arm64 and linux-x86_64, each with a checksum, which is what a package pipeline needs before an extension reaches a production database. The extension is open source and the project is a vendor's project, so a team adopting it inherits both the license and the vendor's release cadence.

What the numbers still leave open

Every figure quoted above comes from Pinecone, measured on one instance size with one dataset and a recall target the vendor chose. These figures establish the measured results on this dataset and instance size; performance on a table of 50 million vectors, on a server that also runs the application's transaction load, or behind a write-heavy ingestion path requires a separate test.

Netics ranking of the three pg_pinecone engines, docs.pinecone.io/guides/pg-pinecone/overview
Netics visual, 17 November 2026: the three engines a table can use, and what each one does with the query.

A team evaluating it can close that gap cheaply, because the extension installs next to pgvector and the switches are reversible. Load one production-shaped table, run the queries the application actually sends, and compare recall against latency with the filter that real tenants produce. Teams building a private AI assistant for their documents run exactly that test, since the retrieval layer decides whether an answer is grounded or invented.

Sources

Source: "Introducing pg_pinecone: Open-Source Search for Your Postgres Data" — pinecone.io, 2026-10-27, https://www.pinecone.io/blog/introducing-pg-pinecone/, retrieved 2026-11-17.