May 2025 Summaries

Flashboard offers a solution for users of Neon Postgres who need a content management system (CMS) without the hassle of integrating a separate headless CMS, which can be complex and time-consuming. Flashboard instantly transforms a Postgres database into a Notion-style admin panel, enabling users to manage HTML content, images, and file uploads directly within their existing database infrastructure. This approach allows users to maintain all their data in one place, simplifying app growth and maintenance by avoiding the complications of syncing multiple data sources. Flashboard provides a rich text editor and file upload capabilities, streamlining the process of creating and editing content. By circumventing the need to learn new DSLs or SDKs, Flashboard aims to save time and resources, offering an efficient and comprehensive CMS experience tailored for Neon Postgres users.

A change in the Postgres execution plan for the Neon Control Plane's Activity Monitor led to a significant outage in the AWS us-east-1 region on May 16, 2025, by causing CPU saturation in the database and preventing the suspension of idle Computes. The Neon Control Plane, which manages starting and suspending Neon Postgres VMs, relies on a Postgres query that experienced a dramatic performance drop due to the use of a suboptimal index, increasing execution times and causing an excess number of concurrently running VMs, leading to IP allocation failures. This issue was confined to the us-east-1 region due to region-isolated databases, and mitigation efforts included refreshing statistics with ANALYZE and using a materialized CTE to improve query performance stability. Future plans involve implementing a more active Garbage Collection strategy and potentially moving historical data to an OLAP system to prevent similar outages.

Neon's Import Data Assistant simplifies the migration process of Postgres databases by allowing users to transfer data with just a connection string, eliminating the need for manual exports or configurations. Built into the Neon Console, it automatically verifies compatibility, including Postgres versions, extensions, and regions, and imports data into a new branch of a chosen Neon project. This tool supports migrations from various sources like AWS RDS, Supabase, Heroku, and self-hosted Postgres, and is particularly useful for moving data between providers, upgrading Postgres versions, switching regions, or creating testing environments. While ideal for small databases, Neon offers personalized assistance for larger, complex migrations that require minimal downtime.

Postgres' internal logging offers robust operational monitoring capabilities for database administrators, capturing detailed information such as SQL statements, connection attempts, and error messages. However, it falls short for compliance auditing, which is where PGAudit becomes essential. PGAudit is designed to meet rigorous audit requirements, such as those under SOX, HIPAA, and PCI DSS, by providing granular control over audit logs and tracking sensitive data access. It offers session and object-level auditing, enabling organizations to precisely log database activities affecting protected information. This structured logging is crucial for demonstrating compliance, as it captures essential details like timestamps, operation types, and session tracking. PGAudit's ability to redact sensitive information like passwords and its focus on compliance-specific requirements make it a valuable tool for organizations needing to ensure data integrity and security. By using both Postgres’ native logging and PGAudit, organizations can maintain operational efficiency while meeting stringent compliance standards, particularly in regulated industries like healthcare.

The blog post explores how to create a simple file server within a PostgreSQL database using PostgREST, which transforms Postgres into a web server to expose API endpoints for CRUD operations. Although storing files directly in databases is generally not recommended over dedicated object storage solutions like S3, the post demonstrates a practical approach to implementing core features such as functions as RPC, RLS, and database roles through PostgREST. The tutorial utilizes the Neon Data API for setting up a Postgres instance and creating a table to store binary data with associated metadata. A Python script is employed to populate the database with mock data, and functions are developed to serve files and retrieve metadata. The blog also details implementing access control using row-level security policies to manage permissions for public and authenticated users, emphasizing the importance of setting up proper RLS policies in the Neon Data API environment. The article concludes by highlighting Neon's serverless platform capabilities, which facilitate quick provisioning and management of Postgres instances.

AWS RDS's rigid architecture can lead to inflated bills as teams scale their databases, with costs increasing due to the need for multiple environments, storage volumes that cannot be shrunk after scaling, and compute that is provisioned for peak usage but remains on 24/7. Neon, a serverless Postgres platform, breaks this pattern by separating storage and compute, enabling lightweight branches of the database that can be spun up instantly and automatically scale with demand, reducing costs and improving efficiency. With Neon's branching model, teams can create full-blown instances for staging or QA without incurring high costs, share storage to make dev environments affordable even at TB scale, and restore from any point in time in seconds, making it a modern alternative for scaling Postgres without the architectural baggage that translates into a cost spiral.

The Model Context Protocol (MCP) is an external function calling mechanism used with Large Language Models (LLMs). Despite its evolution, authentication has consistently been a challenge. The author of the agenda.dev project, who was using Better Auth, realized that the auth UUID or bearer token could be accessed in plaintext via the client provider's MCP.json file. This issue led to a search for an MCP OAuth solution, which ultimately resulted in collaborating with Bereket Engida and Andrew Qu from Vercel to implement a simple authentication mechanism using their `@vercel/mcp-adapter` package. This package provides a straightforward way to set up an MCP server within a Next.js project, making it easy to define tools for the LLM to use. The implementation requires minimal code changes, with only 3 files and under 10 lines of code needed to be modified. The solution uses OAuth to handle authentication, allowing users to access their data securely.

AWS RDS, while initially appearing cost-effective, can become expensive at scale due to its rigid architecture, which requires separate instances for each environment and provisions storage and compute for peak usage without flexibility. This leads to inflated costs as teams pay for full-size instances even during idle times and cannot reduce storage volumes after they are scaled. Snapshots, the primary backup solution, are costly and slow for recovery. In contrast, Neon offers a serverless Postgres platform designed to address these inefficiencies by separating storage and compute, enabling autoscaling, and allowing instant, lightweight database branches that do not duplicate storage. This model allows for economical scaling, dynamic storage adjustments, and instant point-in-time restores, ultimately providing a more cost-effective and efficient alternative to RDS for managing large-scale Postgres databases.

The text discusses the challenges and solutions related to OAuth authentication for MCP (Model Context Protocol) servers, emphasizing the use of Vercel's MCP adapter and Better Auth. Initially, the author faced issues with exposing auth tokens in plaintext while working on a project called agenda.dev, leading to the exploration of OAuth for secure authentication. Through collaboration with Bereket Engida from Better Auth and Andrew Qu from Vercel, a solution was developed using the @vercel/mcp-adapter package, which simplifies the creation of an MCP server within a Next.js project. This package allows developers to set up MCP routes easily and define tools for AI models while managing complex protocol details. The implementation required minimal code changes, making it efficient and quick to integrate. The text highlights that OAuth is a promising solution for MCP authentication, and the author expresses excitement for future developments in the MCP landscape. The open-source repositories for the MCP Adapter and Better Auth are available for further exploration.

Nothing works first time: if you are coding, you are debugging. This used to mean console.log(), print statements scattered like breadcrumbs, and hours spent staring at stacktraces trying to decipher what went wrong and where. Now, errors are chucked into AI-powered tools like Claude to decipher in seconds rather than hours. These tools use machine learning to debug code more effectively, allowing developers to build more robust software and learn how not to make mistakes in the first place. There are three levels of AI-assisted debugging: "lazy" AI debugging, interactive debugging agents that actively explore a code's execution, and structured debugging prompts that provide context and clarify intent. Lazy prompting relies on an LLM's innate ability to understand error messages without explicit instructions, while structured prompts mimic how senior developers communicate about bugs, providing precision, context, and constraints. The future of debugging will be AI agents that actively drive a real debugger, set breakpoints, inspect variables, and patch code in an automated loop, significantly expanding the agent's "action and observation space." These agents will enable more informed decisions about code fixes and expand the capabilities of current LLM-based agents. By using these tools and techniques, developers can learn how to debug more effectively and become better engineers.

AI-enhanced debugging offers a transformative approach to software development by leveraging tools like Claude, Cursor, and Microsoft's debug-gym. These AI tools streamline the debugging process through three main levels: "lazy" AI debugging, which involves inputting error messages into large language models (LLMs) for quick fixes; structured prompting, which enhances AI's efficacy by providing context-rich bug reports; and interactive debugging agents, which autonomously explore code execution to identify and rectify issues. While current methods like "lazy prompting" and structured prompts focus on efficient error diagnosis, future developments in AI debugging agents promise a more autonomous approach, where AI can actively interact with code, set breakpoints, and test solutions in real-time. These advancements not only improve error resolution but also offer developers valuable learning opportunities by elucidating the underlying causes of bugs, thus enriching their engineering skills. As AI debugging tools continue to evolve, they are expected to handle the more tedious aspects of bug tracking, allowing developers to focus on creative challenges while maintaining oversight to ensure quality and accuracy in AI-generated solutions.

Replit has launched App History, a unified timeline that allows developers to roll back to earlier versions of their app or preview them live in the browser. This feature uses Neon branching under the hood, capturing both code and data at every checkpoint, making it possible to rewind the database to any point within a 7-day window. With App History, users can comfortably test changes, debug incidents from the past, and let users fork and explore. The feature improves security and reliability by reducing the risk of bad migrations or data corruption, and enables new development patterns such as safe experimentation with AI agents. Replit's integration with Neon allows for fast and lightweight branching, making it possible to build features like App History that feel magical to users.

The Neon team experienced two significant outages on May 16 and May 19, 2025, in the AWS us-east-1 region, affecting customers' ability to create or start inactive databases. The root cause of these incidents was related to IP address allocation issues due to a high number of active pods exhausting available IP addresses in subnets. To mitigate this, the team made changes to their Kubernetes architecture and AWS CNI configuration, including doubling the size of prewarmed compute pools and increasing VPC subnet sizes. These measures prevented future IP allocation errors, but further investigation is ongoing to understand the root causes of these incidents.

Replit has introduced App History, a feature that allows developers to roll back their applications to previous states, including both code and database data, thereby enhancing the development process by enabling experimentation and debugging without the risk of irreversible errors. Powered by Neon's branching technology, this feature provides a seamless integration of code and data snapshots, allowing users to preview and interact with past versions of their applications in a secure environment. This capability supports safe experimentation, as it mitigates the risks associated with code alterations and database changes, making it particularly beneficial in workflows where AI agents are used to suggest or implement changes. The integration with Neon, a serverless Postgres platform, ensures that each App History checkpoint functions as a lightweight branch containing the full state of the app, enabling swift and accurate restoration without the need for traditional backup or manual migration processes. This innovation not only improves user experience but also enhances security and reliability, promoting a more fearless approach to coding and development.

In May 2025, Neon experienced two significant outages in their AWS us-east-1 region, affecting customers' ability to create or activate inactive databases, while running databases remained unaffected. The outages, which totaled 5.5 hours, were attributed to IP address allocation issues due to overloaded clusters and subnet capacity limits. To address these incidents, Neon implemented changes to their IP allocation strategies, adjusted subnet sizes, and redirected some traffic to other regions. They also initiated long-term architectural changes to their Kubernetes setup, known as the Cells project, to prevent future scalability issues. During the incidents, temporary solutions included reconfiguring AWS CNI settings, upscaling control plane databases, and enabling rate limiting to manage traffic, although some customers encountered rate limit errors. The company is actively investigating the root causes, working with AWS Support, and plans to provide further updates while encouraging customers with production databases to avoid scale-to-zero configurations to minimize impact.

Cloning a production database for testing and development is challenging due to provisioning new instances, managing data synchronization, and handling personal identifiable information (PII). Neon provides a solution by offering branches that are instantly created copies of the Postgres database with similar schema and data. These branches can be used as templates for non-production environments, ensuring safe and realistic testing conditions without exposing real user data. The PostgreSQL Anonymizer extension further protects PII by masking sensitive columns with static masking strategies, such as replacing values with fake but realistic-looking alternatives or adding variability to numerical data. By automating the process of creating anonymized branches, developers can efficiently create production-like environments for testing and development purposes.

Endform, a hypergrowth company, was struggling with the bottlenecks of E2E testing due to their fast-paced development velocity. They needed a platform that could handle hundreds of tests per day across multiple deployments. After using Supabase for a while, they realized they wanted more control over their infrastructure and chose Neon as their new database layer. Neon provides Postgres without the constraints of Supabase's suite, allowing Endform to manage their own auth provider and have full control over their infrastructure. The team uses Neon's branching model to create ephemeral databases tied to every pull request, which helps catch issues that wouldn't surface in empty test databases. Their architecture is optimized for speed and scale, using AWS Lambda, Cloudflare, Durable Objects, and Alchemy to provision the environment programmatically. With Neon, Endform aims to build the fastest way to run end-to-end Playwright tests.

Creating realistic and reliable software testing environments can be challenging, especially when dealing with production databases containing sensitive personal information. Neon addresses these challenges by offering a solution that combines its branching architecture with the PostgreSQL Anonymizer extension. This approach allows teams to clone production databases quickly and safely, without the operational burden of provisioning new instances or the risk of exposing personal data. Neon branches enable the creation of instant, isolated copies of a Postgres database, which can be anonymized using the PostgreSQL Anonymizer to replace real data with fake but realistic alternatives. This process ensures compliance with privacy regulations while maintaining the structure, schema, and relationships within the database. Once anonymized, these branches can be used repeatedly for various non-production purposes such as testing, continuous integration, and development, thereby streamlining workflows and reducing data management overhead.

Endform is developing a platform to efficiently scale Playwright end-to-end tests, leveraging technologies like AWS Lambda, Cloudflare Durable Objects, and Neon. Initiated by Oliver Stenbom and team, who have extensive experience in fast-paced engineering environments, the platform focuses on lightweight and scalable solutions, using Neon for its ability to quickly spin up Postgres databases without infrastructure constraints. Originally starting with Supabase, Endform switched to Neon to avoid being locked into specific authentication models and to maintain flexibility in infrastructure choices. The platform utilizes Neon’s branching model to create ephemeral databases for each pull request, enhancing testing workflows by mirroring production environments and catching potential issues early. Endform employs a serverless architecture with AWS Lambda for running browser instances and Cloudflare for frontend deployment, all orchestrated with a new Typescript-native tool, Alchemy, to provide fast, reliable, and scalable testing environments.

Stas, Heikki, and I envisioned a database that could power the next generation of modern applications, including AI-native ones. We built Neon, a cloud-native Postgres architecture that separates storage and compute, introducing a branchable, versioned storage system for instant branching, time-travel, and serverless scale. The project started as research-heavy, focusing on rebuilding the Postgres storage layer from scratch for the cloud, integrating with the upstream Postgres codebase, and adding innovation like S3 integration and branches. We launched Neon publicly in 2022 with a promise of serverless Postgres that feels like magic, which resonated with developers, resulting in organic growth and partnerships with top dev platforms. As AI-native apps took off, we leaned into agent-focused development, making Neon uniquely suited to power them, with over 80% of databases now created by AI agents rather than humans. Today, Neon is joining forces with Databricks after the transaction closes, accelerating our mission with scale and backing, and continuing on an ambitious chapter.

Neon, a cloud-native Postgres database startup, was co-founded by Stas Kelvich, Heikki Linnakangas, and Nikita Shamgunov with the goal of transforming the database industry by overcoming the limitations of traditional monolithic architectures through an innovative storage and compute separation model. Launched in 2022, Neon's serverless Postgres offering gained rapid traction among developers due to its ease of use, auto-scaling capabilities, and unique features like branching and time-travel. As AI-native applications grew, Neon’s architecture became particularly suited to these applications, leading to widespread adoption by AI agents. In a significant development, Neon has been acquired by Databricks, a company recognized for its open-source software and data and AI focus, marking a new chapter in Neon's journey. The acquisition aims to leverage the synergies between the two firms to enhance and expand Neon's offerings, particularly in the AI-native app stack, while maintaining its commitment to developer experience and innovation.

Design teams are constantly battling the clock to validate real concepts, but static prototypes aren't enough. To move beyond static mockups, designers can leverage AI-powered codegen tools like V0 to generate interactive, production-quality prototypes instantly from a simple text prompt, bridging the gap between concept and code. This shift enables designers to build interactive, code-backed prototypes that behave like real products, test nuanced flows and micro-interactions directly with users, and iterate faster while keeping design intent intact. With tools like V0, designers can prototype with real code, moving beyond "Does this look good?" to "Does this actually work for our users?" and raising the bar for design quality by capturing complexity and system logic in interactive, production-like prototypes. By working with AI codegen, designers learn to shape the output, treating it like a developer, being specific in prompts, sanity-checking the output, and unlocking new workflows that enable them to focus on real product challenges rather than pixel tweaks.

Design teams at Neon are leveraging AI-powered code generation tools, specifically V0, to create interactive, production-quality prototypes that closely mimic the final product, significantly enhancing the design process. These tools allow designers to generate React components and UI flows from simple text prompts, enabling the creation of realistic prototypes that can be tested with users much earlier in the development cycle. This approach facilitates faster iteration and maintains design intent from concept to implementation, allowing for more effective collaboration with engineers and sharper design validation. By moving beyond static visual tools like Figma, V0 enables designers to test real product interactions and system logic, leading to improved design quality and quicker feedback loops. This shift empowers designers to be more autonomous and hands-on, directly contributing to product quality by evolving design systems and refining components with greater consistency and efficiency.

Rhythmic is a company building an AI for product people to eliminate repetitive work and make it easier for teams to focus on solving real customer problems. Their platform, currently in Early Access, offers features such as epic story builders, automated backlog planning, internal notes, live sprint planning, proprietary estimation engines, and more. Rhythmic chose Neon on Azure due to its fast provisioning, developer-first experience, no infrastructure babysitting, enterprise-ready foundation, and built-to-scale architecture with privacy in mind. The Neon Azure Native Integration provides a seamless experience for Azure teams, offering one-click org creation, unified billing, SSO, Terraform, Bicep, and CLI support, making it easy to get started with serverless Postgres that scales with the user's needs. Rhythmic is sticking with Postgres as their foundation for RAG, using pgvector for semantic search, and planning for per-project database isolation to make their AI agent infrastructure easier to scale and secure.

Rhythmic is developing an AI copilot for product teams, aiming to automate repetitive tasks and enable product managers to focus on customer engagement and strategy. Utilizing Neon's integration with Azure, Rhythmic benefits from a developer-friendly environment, enterprise readiness, and seamless scalability without the maintenance burden of traditional databases. The platform offers features like an epic story builder, automated backlog planning, and a proprietary estimation engine, all designed to streamline product management workflows. Rhythmic's infrastructure, initially built on Vercel and Trigger.dev, transitioned to Azure for enhanced stability and compliance, with Neon providing fast provisioning and project-level database isolation. By using Postgres with pgvector for semantic search instead of specialized vector databases, Rhythmic maintains a simplified, cost-effective stack suitable for multi-tenant AI deployments. The integration with Azure offers unified billing, SSO, and compatibility with tools like Terraform, facilitating a smooth transition and future scalability.

Postgres 18 Beta 1 has been released, introducing several significant features. The new asynchronous I/O subsystem allows for parallel reads and reduces CPU wait time, improving throughput. Operational teams can now retain planner statistics from the old cluster during upgrades, reducing degraded performance immediately after an upgrade. Postgres 18 also includes more detailed EXPLAIN output with runtime details such as buffer and I/O usage, index scan nodes, and WAL writes. Additionally, new statistics for vacuum and analyze are available, providing insights into total time spent on these operations. The release also introduces a new uuidv7() function to generate timestamp-sortable UUIDs, as well as improvements in performance, including parallelizable GIN index builds and skip scan support in btree indexes. Furthermore, Postgres 18 adds OAuth support for authentication using OAuth 2.0 tokens. With the final release expected to be available on Neon soon, users are encouraged to test against real workloads and provide feedback to help improve Postgres.

Postgres 18 Beta introduces several notable features aimed at improving performance and operational efficiency, including a new asynchronous I/O subsystem that allows for parallel reads, significantly enhancing throughput and reducing CPU wait time, particularly with the io_uring method on Linux. The update also brings enhancements in major version upgrades by retaining planner statistics, reducing performance degradation, and offering options for parallel execution and directory swapping to minimize downtime. Observability improvements include more detailed EXPLAIN output and extended statistics for vacuum and analyze operations, while the addition of UUIDv7 generation supports ordered inserts. The beta also introduces OAuth authentication, providing an extensible method for integrating with identity providers. Postgres 18 Beta is available for testing, with Neon planning to offer support on its serverless platform upon the final release.

Neon's Microsoft Azure Native Integration has reached General Availability, providing a powerful serverless Postgres solution on Azure. This integration allows developers to use Neon like any other native Azure service, fully embedded within their existing Azure workflows, identity systems, and billing structure. With this update, Neon projects, branches, and connection strings can be managed directly through the Azure Command-Line Interface (CLI) and SDK, simplifying security and procurement processes. The integration is beneficial for enterprises with Azure MACC, as it contributes toward committed Azure spend without additional procurement steps or vendor onboarding required. Neon's serverless Postgres architecture delivers efficient scalability, strong recovery guarantees, and developer workflows that align with modern software development practices, making it a perfect fit for AI startups scaling on Azure.

Neon's integration with Microsoft Azure has reached general availability, enabling developers to deploy and manage Neon Serverless Postgres as a native Azure service. This integration offers seamless integration with Azure workflows, including unified billing, Microsoft single-sign-on (SSO), and full Microsoft Azure Consumption Commitment (MACC) eligibility, making it easier for enterprises and AI startups to adopt serverless Postgres within their existing Azure environments. The integration allows for efficient scalability and reliable recovery, with features like automatic scaling, instant restores, and database branching that support modern software development practices. For AI startups, Neon provides the speed and flexibility needed for AI applications, with support for Retrieval-Augmented Generation (RAG) pipelines and direct integration with Azure's Semantic Kernel. This collaboration between Neon and Microsoft aims to deliver a truly native experience within the Microsoft developer ecosystem, with ongoing enhancements planned for the future.

Snapshots are a critical safety net for Postgres teams, but they can be slow and impractical when databases grow large. Restoring from a snapshot in AWS RDS can take 30 minutes to hours, even with point-in-time recovery, which adds additional time due to replaying WAL logs. This limits what you can do with your snapshots, such as inspecting historical data or testing changes before applying them to production. Additionally, restores require duplicate infrastructure, which can be a problem for large databases. However, Neon has implemented a better way to use snapshots, with an architecture that's faster and unlocks new workflows. In Neon, snapshots are point-in-time references to the state of a branch, captured instantly without performance impact, allowing for instant restoration into new branches, queryable data, and attached compute on demand. This enables fast recovery, lower overhead, more confidence, and better workflows for large Postgres databases.

Ephemeral environments refer to the ability to create short-lived copies of your system, allowing developers to work in isolated environments, test data not pollute shared environments, and safely tear down environments once a feature is complete. Neon Serverless Postgres solves problems associated with using ephemeral environments with services that charge on a pay-per-use basis, such as increased uptime costs. It provides features like connection pooling, data API, and data branching, which enable instant branching of the database, automatic seed data import, schema-only branching, and automation of creating and deleting branches. Neon is built around PostgreSQL, separates storage from compute, and allows developers to create ephemeral environments for testing and development purposes, while also using it in CI/CD pipelines to ensure clean and well-defined initial system states.

The blog post explores the concept and implementation of ephemeral environments using Neon, a serverless database platform based on PostgreSQL, which separates storage and compute, allowing developers to efficiently create, use, and dismantle temporary database copies. It highlights the advantages of ephemeral environments, such as isolated development spaces and reduced costs, especially when paired with pay-per-use services like Neon, which offers faster scaling and cold start times compared to Aurora Serverless v2. The post delves into Neon's features, including connection pooling, data API, and data branching, enabling developers to branch databases instantly for testing and development purposes without affecting the primary system. Additionally, it provides a step-by-step guide for setting up and managing these environments, emphasizing automation through scripts and integration into CI/CD pipelines to streamline the development workflow. This approach allows for a seamless and efficient process of testing, validating, and deploying new features while minimizing infrastructure overhead.

Neon offers a novel approach to managing snapshots for large Postgres databases, providing significant advantages over AWS RDS. While RDS snapshots are primarily used for backup and disaster recovery, they can be cumbersome when dealing with large databases due to the slow restoration process, inability to inspect data without a full restore, and the need for duplicate infrastructure. Neon's copy-on-write storage architecture enables snapshots to function as point-in-time references, allowing for instant, cost-effective, and scalable restoration without the need to duplicate instances. This architecture supports advanced workflows, such as testing risky migrations, investigating production issues, and running ad-hoc queries on historical data, by allowing snapshots to be quickly restored into new branches and attached to compute resources on demand. Consequently, Neon transforms snapshots from a backup tool into a versatile component of database management, enhancing recovery speed, reducing overhead, and improving operational confidence for teams managing large-scale databases.

Over the past few decades, the evolution of database architecture has seen significant shifts, from the unified transactional and analytical systems of the '80s to the specialized OLTP and OLAP systems of the '90s and 2000s, leading to the emergence of Hybrid Transactional and Analytical Processing (HTAP) in 2014. Despite technical advancements, HTAP struggled to achieve a strong product-market fit, as cloud data warehouses became the dominant force, largely due to their ability to handle both OLTP and OLAP workloads effectively. The modern data ecosystem has moved towards a modular approach, where data teams assemble custom systems using best-in-class components, such as OLTP systems, stream processors, and real-time query layers, to effectively manage fast OLAP queries on fresh transactional data. This approach, which emphasizes composition over consolidation, signifies how the spirit of HTAP lives on in the disaggregated data stacks of today, even as the original concept of HTAP databases fades.

The text discusses the possibility of generating Model Context Protocol (MCP) servers directly from existing API specs using tools like openapisearch and Tadata. However, it highlights several pitfalls, including LLMs struggling with large amounts of choices, navigating complex JSON payloads, and dealing with ambiguity in API calls. The main argument is that MCP design should focus on workflows and tasks, rather than just exposing raw building blocks of the API spec. A more hybrid approach is suggested, where codegen is used as a starting point, but then tools are pruned and rewritten to provide clear examples and guidance for LLMs. Ultimately, higher-level tools that abstract away common multi-step workflows should be created to leverage the strengths of LLMs.

Exploring the potential of generating Model Context Protocol (MCP) servers directly from existing REST API specifications using OpenAPI schemas, the discussion weighs the pros and cons of this approach. While the appeal lies in leveraging already documented APIs to create comprehensive MCP servers, challenges arise due to the fundamental mismatches between the granular, resource-centric nature of REST APIs and the task-oriented design of MCP servers. Simply mapping every API endpoint to an MCP tool can overwhelm large language models (LLMs) and lead to poor user experiences due to complexity and ambiguity in API interactions. Instead, a hybrid approach is recommended, where initial code generation serves as a foundation, followed by selective pruning and refinement of tools to better align with LLM capabilities. This involves crafting higher-level tools that abstract common workflows and provide clearer guidance for LLMs. An example implementation highlights the use of a TypeScript API SDK to create an MCP server that effectively combines API endpoints and higher-level workflows, emphasizing the need for thoughtful design to maximize utility and efficiency.