Neon Postgres

We're expanding our branching experience to the entire backend, starting with files: you can now branch your database AND your buckets in Neon, without duplicating storage https://lnkd.in/gBbchaJs

A 4B open-source model post-trained with castform matched GPT-5.6 Sol on search accuracy, at ~100x lower cost. The corpus backend for the whole pipeline was Neon + Lakebase Search: https://lnkd.in/gdw3gasf

We just shipped granular access control on Neon: four org-level roles (Admin, Editor, Viewer, Collaborator) with matching project-level permissions. Give your agents and developers exactly the access they need: https://lnkd.in/gQTP3_DC

Lakebase Search brings BM25 text search and vector search directly into Postgres. CommSync is using it across their entire product: https://lnkd.in/gBz5WdTf Lakebase Search bundles two Postgres extensions, lakebase_text for BM25 full-text search and lakebase_vector for approximate nearest-neighbor vector search: https://lnkd.in/gWR5UTzv CommSync (https://commsync.ai/) is running it across different features in their product, each with different needs 👇 1/ Inbox search (their highest-traffic path) - pure text: BM25 over messages and attachments, powering both typeahead and full results 2/ AI assistant - pure vector: handles natural-language queries like "find the thread where someone complained about pricing" 3/ Command palette (cmd+k) - hybrid: fuses lexical and semantic results with Reciprocal Rank Fusion 4/ AI agents' knowledge base - vector retrieval for RAG, reusing the same embeddings and database as the rest of the product

We just shipped neon inspect db, a new CLI command for read-only Postgres diagnostics. Your agent can now debug your database with full safety: https://lnkd.in/gzc9D5ND When something in Postgres is slow, the usual fix has an annoying workflow. You leave your CLI, open psql, connect, and try to recall the exact catalog view, columns, and joins for the diagnostic you need… When using an agent, it gets worse - models tend to hallucinate pg_catalog column names and write broken queries, plus it’s risky to give an agent that kind of SQL access. A connection string is a dangerous credential to give to an agent. 𝐖𝐡𝐚𝐭 𝐧𝐞𝐨𝐧 𝐢𝐧𝐬𝐩𝐞𝐜𝐭 𝐝𝐛 𝐝𝐨𝐞𝐬: It brings data-plane diagnostics into the CLI you already use. It comes with 14 subcommands covering table bloat, unused indexes, locks, slow queries, vacuum health, replication lag, and more (e.g. Neon-specific ones like LFC hit rate). Every command is read-only, scoped to just the columns that answer the question, and capped where results can get large, with structured JSON/YAML output your agent can actually reason over. 𝐘𝐨𝐮 𝐜𝐚𝐧 𝐡𝐚𝐧𝐝 𝐚𝐧 𝐚𝐠𝐞𝐧𝐭 𝐫𝐞𝐚𝐥 𝐝𝐢𝐚𝐠𝐧𝐨𝐬𝐭𝐢𝐜 𝐩𝐨𝐰𝐞𝐫 𝐨𝐯𝐞𝐫 𝐲𝐨𝐮𝐫 𝐝𝐚𝐭𝐚𝐛𝐚𝐬𝐞, 𝐰𝐢𝐭𝐡𝐨𝐮𝐭 𝐡𝐚𝐧𝐝𝐢𝐧𝐠 𝐢𝐭 𝐰𝐫𝐢𝐭𝐞 𝐚𝐜𝐜𝐞𝐬𝐬 𝐨𝐫 𝐚 𝐫𝐚𝐰 𝐜𝐨𝐧𝐧𝐞𝐜𝐭𝐢𝐨𝐧 𝐬𝐭𝐫𝐢𝐧𝐠.

We recently made Lakebase Search available on Neon: hybrid vector and full-text search built for agents. One half of that is lakebase_text: here's why we built it, and why Postgres' default BM25 solution isn't enough 👇 When you add full-text search to a Postgres app, the default path is tsvector + GIN indexes + ts_rank. This works, until it doesn't. 𝐓𝐡𝐞 𝐟𝐢𝐫𝐬𝐭 𝐩𝐫𝐨𝐛𝐥𝐞𝐦 𝐰𝐢𝐭𝐡 𝐭𝐬_𝐫𝐚𝐧𝐤 𝐢𝐬 𝐭𝐡𝐚𝐭 𝐢𝐭 𝐝𝐨𝐞𝐬𝐧'𝐭 𝐚𝐜𝐭𝐮𝐚𝐥𝐥𝐲 𝐢𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭 𝐁𝐌𝟐𝟓, the relevance algorithm behind most modern search engines. BM25 accounts for how rare a term is across the entire corpus (IDF) and how long the document is (length normalization). ts_rank does neither correctly. In practice, this means that as your corpus grows, relevance scores drift. A term that was moderately common at 10K documents looks very different at 1M, but ts_rank doesn't know that. The ranking that worked fine at small scale quietly gets worse as you add data. 𝐓𝐡𝐞 𝐬𝐞𝐜𝐨𝐧𝐝 𝐩𝐫𝐨𝐛𝐥𝐞𝐦 𝐢𝐬 𝐩𝐞𝐫𝐟𝐨𝐫𝐦𝐚𝐧𝐜𝐞. GIN indexes have no top-K pushdown: when you run a full-text query with LIMIT 10, Postgres still scores every matching document before applying the limit. At small corpus sizes this is fine. At millions of documents, every query scans everything that matches and throws most of it away. 𝐥𝐚𝐤𝐞𝐛𝐚𝐬𝐞_𝐭𝐞𝐱𝐭 𝐟𝐢𝐱𝐞𝐬 𝐛𝐨𝐭𝐡. We built this Postgres extension to replaces GIN with a BM25-native index built specifically for Neon's separated storage-compute architecture. It stores corpus-wide statistics at index build time (document frequencies, average document length) and uses them to compute real BM25 scores. The <@> operator returns true BM25 scores, ordered by actual relevance. For performance, it uses Block-Max WAND for top-K pushdown: instead of scoring every matching document before applying your LIMIT, the index returns the top K results directly, skipping documents it can prove won't make the cutoff. GIN structurally can't do this. The index also stores durably on Neon's object storage layer, the same as the rest of your data. Scale-to-zero works. And when you branch a Neon database, you get an instant copy of the lakebase_bm25 index alongside the data, so you can test new indexing configurations against real production data without touching prod. 𝐥𝐚𝐤𝐞𝐛𝐚𝐬𝐞_𝐭𝐞𝐱𝐭 𝐬𝐡𝐢𝐩𝐬 𝐚𝐬 𝐩𝐚𝐫𝐭 𝐨𝐟 𝐋𝐚𝐤𝐞𝐛𝐚𝐬𝐞 𝐒𝐞𝐚𝐫𝐜𝐡, 𝐚𝐥𝐨𝐧𝐠𝐬𝐢𝐝𝐞 𝐥𝐚𝐤𝐞𝐛𝐚𝐬𝐞_𝐯𝐞𝐜𝐭𝐨𝐫 𝐟𝐨𝐫 𝐀𝐍𝐍 𝐯𝐞𝐜𝐭𝐨𝐫 𝐬𝐞𝐚𝐫𝐜𝐡. Both live in the same Postgres: hybrid search (BM25 + vector similarity, joined against your operational tables, filtered by tenant) in a single SQL query. Check out the docs: https://lnkd.in/gWR5UTzv And the full writeup: https://lnkd.in/gTQtkeb9

𝐎𝐮𝐫 𝐩𝐥𝐚𝐭𝐟𝐨𝐫𝐦 𝐢𝐬 𝐞𝐱𝐩𝐚𝐧𝐝𝐢𝐧𝐠: 𝐎𝐛𝐣𝐞𝐜𝐭 𝐒𝐭𝐨𝐫𝐚𝐠𝐞, 𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧𝐬, 𝐚𝐧𝐝 𝐀𝐈 𝐆𝐚𝐭𝐞𝐰𝐚𝐲 𝐚𝐫𝐞 𝐧𝐨𝐰 𝐛𝐞𝐭𝐚. 𝐓𝐞𝐥𝐥 𝐲𝐨𝐮𝐫 𝐚𝐠𝐞𝐧𝐭 𝐭𝐨 𝐝𝐞𝐩𝐥𝐨𝐲 𝐚 𝐟𝐮𝐥𝐥 𝐍𝐞𝐨𝐧 𝐛𝐚𝐜𝐤𝐞𝐧𝐝 - https://lnkd.in/g_mv4-Ni We started by building a serverless Postgres database, with separate compute and storage and branches that unlock development speed. But when agents build an app, they don't only deploy databases: they wire up auth, they reach for S3 for file uploads, deploy functions, LLM keys… So now that developers are using agents as the main interface to build, we're building a backend with the same principles. When you build with an agent, we want it to deploy not only a database but all the tools that make your backend functional, with everything running on the same engine and sharing the same workflows. Today we're shipping the beta of our first 3 new products: Object Storage, Functions, and AI Gateway. Together with our database and Managed Better Auth, they form the first version of our backend platform. 𝐏𝐨𝐬𝐭𝐠𝐫𝐞𝐬 𝐝𝐚𝐭𝐚𝐛𝐚𝐬𝐞: Serverless and branchable - provisions instantly by your agent, only bills when running. 𝐌𝐚𝐧𝐚𝐠𝐞𝐝 𝐁𝐞𝐭𝐭𝐞𝐫 𝐀𝐮𝐭𝐡: Auth that runs in your branch alongside your Postgres environment. [𝐍𝐄𝐖] 𝐎𝐛𝐣𝐞𝐜𝐭 𝐒𝐭𝐨𝐫𝐚𝐠𝐞: S3-compatible object storage that branches with your data. Create a database branch and also get an isolated copy of your files. [𝐍𝐄𝐖] 𝐅𝐮𝐧𝐜𝐭𝐢𝐨𝐧𝐬:  long-running Node.js functions that deploy and tear down with the branch automatically, without timing out. [𝐍𝐄𝐖] 𝐀𝐈 𝐆𝐚𝐭𝐞𝐰𝐚𝐲: one bill for a wide catalog of frontier and open-source models, with no markup on model pricing.

Onboarding begins now: Compute, Storage, AI Gateway. Access at https://neon.com/backend - Compute: Long-running functions - Storage: object storage that branches with your database - AI Gateway: One API for all frontier and open-source models

Starting TODAY every Neon paid plan includes 500 GB of monthly data transfer. That's 5× more than before! 📈 With this change, we expect most Neon customers will never have to pay for egress overages. Best of all, it applies automatically to all existing paid plans. Why we're doing this? Few things are more frustrating than an unexpected egress charge landing on your invoice. Raising the included amount to 500 GB removes that surprise for most Neon customers. Read more about it here: https://lnkd.in/dKSHabpy

Important news: Neon is expanding to offer a more complete set of backend primitives for running apps and agents: ✅ Database ✅ Authentication 🔜 Storage 🔜 Compute 🔜 AI Gateway Spoiler alert: They're going to be boring.