February 2026 Summaries

SurrealDB has launched the JavaScript SDK v2, marking a significant update aimed at enhancing developer ergonomics, flexibility, and experience. This update includes full compatibility with SurrealDB 3.0, multi-session support, automatic token refreshing, and a redesigned live query API. Additionally, a new query builder pattern simplifies data interactions, while the WebAssembly and Node.js SDKs have been integrated into the JavaScript SDK repository to ensure consistent updates. Notable features include support for running the WASM SDK inside a Web Worker, type-safe event listeners through surreal.subscribe(), and a diagnostics API for inspecting communication at the protocol level. The SDK overhaul introduces improvements such as explicit parameter handling, enhanced query methods, an Expressions API for dynamic expression building, and a value encode/decode visitor API for advanced data processing. The release also aligns the major and minor versions of the WASM and Node.js SDKs with SurrealDB, providing clear version identification and ensuring embedded SurrealDB instances remain current. Comprehensive documentation and a Quickstart guide are available to assist users in navigating the new features and capabilities of the updated SDK.

SurrealDB 3.0 introduces experimental native file support, allowing users to store files directly within the database instead of externally. This feature is enabled by defining a "bucket" for file storage, which can be set to a physical location or in-memory, and utilized across all namespaces and databases with a global bucket environment variable. Users can manipulate files using file pointers and associated functions like .put(), .get(), and .rename(). SurrealDB also enhances type conversions for bytes, supporting functions like type::string_lossy() to handle partially corrupted data. Additionally, encoding and decoding bytes into SurrealDB types is possible, facilitating applications such as temporary shopping cart storage. Future developments aim to integrate with large-scale object storage solutions like Amazon S3, further expanding SurrealDB's capabilities for apps relying on lightweight file storage.

SurrealDB has announced the completion of a $23 million Series A funding extension, bringing its total funding to $44 million, with new investors Chalfen Ventures and Begin Capital joining existing supporters. This investment underscores SurrealDB's rapid growth and its aim to become the primary database for AI-native applications by providing a unified platform for various data models. The company's latest release, SurrealDB 3.0, is designed to offer a seamless data infrastructure that supports AI systems' needs for persistent memory, real-time performance, and synchronized context across data sources. This funding will be used to enhance the database's reliability, security, and cloud scalability, further establishing SurrealDB as a leader in the evolving AI era.

SurrealDB 3.0 introduces a significant feature called DEFINE API, which allows developers to create custom API endpoints directly within the SurrealQL query language, simplifying the traditional three-layer architecture of client, middleware, and database into a more streamlined client-to-database interaction. This enhancement reduces infrastructure complexity, improves performance, and facilitates management, as demonstrated in a real-world scenario where rate limits for guest users in a social application are efficiently managed using this new feature. By incorporating middleware functions such as api::timeout, developers can control server time for guest users, while the DEFINE API statement specifies API endpoints, ensuring that data is returned according to defined criteria. SurrealDB also supports custom middleware functions, enabling developers to enhance API responses further, and with the power of API design integrated into the database, users can redefine architectural possibilities without needing additional frameworks.

SurrealDB 3.0 represents a major advancement in database technology, focusing on improved stability, performance, and developer experience to meet the growing needs of modern applications, especially in building AI agents. This version introduces key changes such as separating values from expressions, implementing computed fields, adopting ID-based storage, enabling default synced writes, and redesigning document handling for enhanced stability and predictability. SurrealDB 3.0 also stabilizes GraphQL support, bringing robust features like mutation support and security hardening. It further enhances the developer experience with custom API endpoints, client-side transactions, and record references, and introduces Surqlize, a TypeScript ORM to facilitate seamless integration. The database evolves into a multi-modal platform enabling AI agents with features like native file support, advanced vector search, and a new WebAssembly extension system called Surrealism. This extension system allows custom logic execution within the database, supporting AI model integration and 'datagentic' workflows. These enhancements collectively transform SurrealDB 3.0 into a powerful memory engine for intelligent systems, pushing the boundaries of database capabilities.

SurrealDB 3.0 introduces significant performance improvements over its predecessor, SurrealDB 2.0, by restructuring its execution engine and enhancing its benchmarking capabilities. The new version of this multi-model database, which integrates relational, document, graph, time-series, key-value, vector, geospatial, and full-text workloads, has been optimized to address high-throughput, business-critical workloads. Key enhancements include a more efficient query execution model that transitions from AST to LogicalPlan to ExecutionPlan, resulting in substantial speed increases for operations like graph queries, large table scans, and vector searches. The introduction of an open-source benchmarking tool, crud-bench, facilitates thorough testing across various workloads, ensuring transparent and balanced performance evaluations. SurrealDB 3.0's architectural updates have led to dramatic improvements in concurrency and throughput, making it a robust option for enterprises like Tencent that require scalable and reliable database solutions. Additionally, future updates promise to expand and optimize the database's capabilities further, focusing on streaming execution and indexing improvements.

SurrealDB 3.0 represents a significant evolution in database technology, offering enhanced stability, performance, and developer experience. Key architectural changes, such as separating values from expressions, introducing computed fields, and adopting ID-based storage, improve database efficiency and predictability. Synced writes by default and redesigned document handling further enhance reliability. The update also stabilizes GraphQL support, introduces client-side transactions for increased flexibility, and allows custom API endpoints directly within the database. Additionally, SurrealDB 3.0 supports advanced AI agent functionalities, including file handling, vector search, and a new WebAssembly extension system called Surrealism, which allows developers to integrate custom logic and AI models directly into the database. The introduction of Surqlize, an experimental TypeScript ORM, aims to enhance the developer experience with type-safe schema definitions and a fluent query builder. Overall, SurrealDB 3.0 pushes boundaries by transforming the database into a multi-modal platform, enabling more intelligent, scalable, and adaptable applications.

SurrealDB 3.0 introduces Surrealism, an open-source extension framework that allows developers to write modular, programmable logic in Rust, with plans to support JavaScript and Python, directly within the database at runtime. This framework compiles functions to WebAssembly, providing a secure, deterministic, and high-performance execution environment ideal for both single-tenant systems and multi-tenant clusters. Surrealism enables seamless integration with AI models and supports dynamic API behaviors, policy enforcement, and auditing, all within SurrealDB. With built-in AI support, plugins can interact with external APIs for various tasks such as text generation and sentiment analysis, transforming SurrealDB into a programmable data and logic layer suitable for intelligent applications. This integration allows developers to create sophisticated applications entirely within the database, leveraging SurrealDB's query engine and its ability to handle structured and unstructured data. As an open-source tool, Surrealism provides a new frontier in database development, enabling developers to integrate their own code and ideas directly into the data layer.

SurrealDB 3.0 is a comprehensive database solution built to handle document, relational, graph, vector, full-text, and temporal queries in a single unified engine, offering a stark contrast to MongoDB, which started as a document store and later added separate subsystems for additional features. SurrealDB's architecture eliminates the need for global or table-level locking, providing ACID transactions across all data models without the associated overhead seen in MongoDB's coordination-heavy concurrency controls. By integrating all query primitives within a single execution plan, SurrealDB reduces coordination overhead and simplifies scaling, whereas MongoDB's document-centric approach and reliance on separate systems for search and vector queries can introduce complexity and increase costs. SurrealDB emphasizes correctness, composability, and consistent semantics, offering native support for temporal graph querying and flexible schema management, which stands in contrast to MongoDB's limitations in these areas. Additionally, SurrealDB's open-source model and unified platform design promise lower total cost of ownership and greater operational efficiency compared to MongoDB's commercial offerings, which depend heavily on the Atlas-managed services for advanced features and scalability.

SurrealDB 3.0 offers a unified database solution that natively supports vectors, full-text search, and graph traversal, contrasting with PostgreSQL, which relies on extensions and workarounds like pgvector for similar capabilities. While PostgreSQL requires manual joins, indexes, and added complexity for handling AI and retrieval workloads, SurrealDB simplifies operations by directly integrating these features, reducing the need for secondary indexing and manual sharding. This design enables SurrealDB to compress datasets by 70-80%, significantly lowering storage and infrastructure costs while maintaining operational efficiency and scalability. SurrealDB is distributed by design and supports live schema evolution without downtime, offering high availability and fault tolerance. It is particularly suitable for environments where retrieval accuracy, operational efficiency, and scale are critical, as it provides a seamless and cost-effective alternative to traditional relational databases like PostgreSQL.

SurrealDB 3.0 emerges as a versatile, multi-model database designed for continuously updated, large-scale workloads, distinguishing itself from Neo4j, which is optimized for static, read-heavy graph operations. SurrealDB supports a wide array of data types, including graph, document, vector, and temporal data, within a single engine, allowing for efficient storage and horizontal scalability across distributed nodes. This makes it particularly suitable for AI applications that demand real-time data updates and complex queries. While Neo4j relies on an in-memory page cache for performance, which can degrade under sustained write-heavy workloads, SurrealDB is optimized for concurrent updates and high write throughput. Furthermore, SurrealDB's open-source model offers cost advantages and flexibility, in contrast to Neo4j's proprietary enterprise offerings. The unified platform approach of SurrealDB reduces the need for multiple databases, thereby minimizing operational overhead and enhancing data consistency, making it ideal for live, large-scale production systems.

The blog post introduces the concept of knowledge graphs and their significance in enhancing AI agents, particularly in multi-agent Retrieval-Augmented Generation (RAG) architectures. It explains that knowledge graphs provide structured, interconnected data that aids AI agents in making accurate decisions and performing tasks by compensating for the large language models' (LLMs) limitations, such as memory fuzziness. The post outlines the steps required to create a knowledge graph from unstructured data, including extraction, transformation, and loading (ETL), while highlighting the benefits such as deterministic accuracy, multi-hop reasoning, and reduced hallucinations. It also compares knowledge graphs to vector stores, suggesting situations where one might be more beneficial than the other, and provides practical examples of how to parse, chunk, and embed data for integration into a knowledge graph.