Forem: Jaime Morgan Hitchcock

Does the edge need a new database?

Jaime Morgan Hitchcock — Sun, 10 Aug 2025 12:15:25 +0000

It’s been easy to miss just how quickly the centre of gravity in AI has started to drift away from the cloud. Scroll through any recent handset launch and you’ll see phrases like “Gemini Nano on-device” or “runs local LLMs” wedged between megapixel counts and battery stats. Google’s latest Pixel 9 line, Samsung’s S24 family and even the mid-range Galaxy S24 FE can now execute a trimmed-down Gemini model entirely on the handset, with no round-trip to Mountain View required. Yesterday I borrowed a colleague’s Z Flip 7 and watched it transcribe and translate a Spanish conversation on the tiny cover screen using Gemini Live - five years ago that would have taken a server farm; today it happens in your pocket.

This shift is happening everywhere you look. Hobbyists are coaxing full LLaMA derivatives to life on Raspberry Pi 5 boards with nothing more than a fan and a prayer, proving that eight-watt CPU cores can now host chat models that once needed racks of GPUs. Apple’s silicon team quietly tripled neural-engine throughput between the M1 and this year’s M4, making an iPad Pro faster at token generation than some cloud VMs you were renting last Christmas. Qualcomm’s Hexagon NPU now drives forty-plus trillion operations per second while sipping battery, which is why every Android flagship ad suddenly touts “on-device AI” rather than “5G-ready”.

As exciting as the model work is, there’s an elephant in the room: data. Models may have slimmed down, but the storage layer beneath them still looks suspiciously like 2005. The embedded databases that ship with phones, kiosks, cars and even bedside or implantable medical devices were designed to hold contacts and settings, not embeddings, dialogue history or multi-modal world models. If you’ve ever tried to graft vector search onto SQLite or keep LevelDB in sync across a mesh of edge devices, you’ll know the feeling - duct-tape engineering at best, architectural debt at worst.

From cloud calls to local memory

The historic “request–response” pattern placed inference in the cloud for good reasons: horsepower, model secrecy, compliance nerve-wracking. Yet privacy regulations, bandwidth ceilings and plain economics are now reversing the arrow. With quantisation tricks like QLoRA and runtimes such as ggml and llama.cpp, developers can deliver sub-second answers locally. What changes when the answer lives on the device? Everything.

Suddenly an application isn’t just caching a few settings; it is curating a living memory: user preferences, spatial context, even transient sensor feeds that inform the next token. Picture a home-automation agent that remembers the temperature you prefer on rainy Tuesdays, or an industrial robot that adapts pick-and-place routines as parts vary through the shift. These behaviours require rapid, bidirectional read-write loops between model and store - latencies measured in microseconds, not the 100 ms you might tolerate over REST.

Why yesterday’s embedded stores feel like floppy disks

Classic embedded engines did their job magnificently when all they had to do was persist rows and occasionally survive a power cut. But an AI-native edge workload, powering VR headsets, kiosks and autonomous drones, throws six new curveballs at them.

First comes schema drift: a conversational agent can invent new keys or relationships on the fly, so the store must negotiate structure rather than enforce it rigidly. Second is the rise of vectors: storing a 4 096-dimensional float array is the easy part - indexing and querying it efficiently on constrained silicon is the kicker. Third, context windows slide forward every few seconds, so writes and reads happen in a tight loop; any locking or table-alter rebuilds will manifest as user-visible lag.

Concurrency is fourth on the list. A mobile IDE that co-pilots code - or a VR headset juggling sensor streams, spatial meshes and voice commands - needs to handle text embeddings, file trees and chat context all at once; single-writer models like traditional LMDB start to squeal. Fifth, modern privacy mores mean every edge device is a potential breach vector, so row-level security and encryption at rest are no longer optional tick-boxes. And finally, hybrid deployment is the norm: your app should keep working underground or at 35 000 ft and then merge neatly when the network returns. Most bolt-on replication engines assume everything is either always-on or always-offline; reality sits in-between.

What tomorrow’s edge database has to nail

If we scrape away the hype, an edge-ready database has a simple mandate: become the model’s memory. That means letting data shift shape without ceremony: handling graphs, docs, time-series and vectors in the same breath; scaling from a smartwatch to a cluster when an idea takes off; and doing all of that within the energy budget of mobile hardware.

The first ingredient is a genuinely multi-model core - no sidecars, no glue code. When embeddings, relational facts and graph edges co-exist in a single logical store, a retrieval-augmented query can jump from “user bought A and B” to “vector-nearest neighbours of product C” in one round-trip. The second must-have is native ANN indexing that respects memory hierarchies; BLAS calls are cheap on an M4 NPU but murderous on a Cortex-A53 unless they’re tightly fused.

Third, the database has to speak the language of AI frameworks. Developers want to feed LangChain or Ollama a simple connection string, not orchestrate Kafka, Redis and half a dozen ETL scripts. Fourth, security needs to be woven into the protocol: row-level ACLs, zero-trust tokens, end-to-end TLS, even when the node is a kiosk bolted to the floor in a public space. Fifth, replication should look more like Git than a monolithic log - branches, merges, conflict resolution that respects semantic meaning rather than blindly choosing “last writer wins.” Projects like Striim’s streaming RAG pipelines demonstrate the appetite for millisecond-fresh embeddings; a modern store must treat such flows as first-class rather than exotic.

A quick detour into how we’re tackling it at SurrealDB

At SurrealDB we stumbled into this problem because customers kept welding vector stores, graph databases and document engines together just to power a single agent. So we asked: what if the database collapsed that stack? The result is a system that lets an agent think, learn and act in one place. The core understands graph, relational, document, time-series and vector data with the same query language. It can run embedded inside an Arm64 binary for a drone or expand into a petabyte-scale cluster in the cloud without code changes. Developers can stream embeddings straight into tables, run cosine similarity alongside SQL filters, and secure the lot with row-based policies and end-to-end encryption. The upshot is that the model’s “long-term memory” no longer lives in half a dozen services; it sits in one engine that speaks SurrealQL.

I’m not here to pitch you, but it’s worth noting the pattern we see among teams who succeed at the edge: they pick a store that treats vectors as citizens, lets schemas evolve with the agent, and bakes in security so they don’t discover compliance holes after the pilot. Whether you end up on SurrealDB or roll your own, tick those boxes early - you’ll thank yourself when version three of your agent suddenly needs to remember image embeddings or conversation sentiment.

Where this is all heading

Edge AI is about to get weird in the best possible way. Qualcomm is lining up consumer chipsets with always-on sensor fusion that pours event streams straight into local memory. Apple continues to blur the line between neural-engine and GPU, which means complex diffusion and audio models will follow language to the device. Meanwhile, open-weights culture ensures a steady supply of distilled models that fit inside a video-doorbell.

When every gadget can run inference, the database stops being a background utility and becomes the arbitration layer between competing goals. Imagine a home where the vacuum, thermostat and security camera each run their own model yet share a common memory of the household routine. The database mediates: the vacuum learns you hate noise during meetings; the thermostat knows a closed door means “do not disturb”; the security cam flags the same anomaly that woke the dog. None of this conversation leaves the four walls unless you allow it.

In that world, storage morphs into what we’ve started calling Agentic Memory. It is stateful, vector-aware, privacy-respecting and context-rich. It is as close to the silicon as the model itself, sometimes compiled into the same binary. And it syncs opportunistically rather than constantly, because bandwidth, energy and sovereignty demands differ from street to street.

Closing thoughts

A decade ago the question was whether the cloud would kill the edge. The irony is that cloud economics and latency have now conspired to push cognition back outwards. Models have done their part by shedding parameters and learning to run on NPUs the size of thumbnails. The onus is now on data infrastructure to match that agility.

So, does the edge need a new database? My take is that it needs a new kind of database - one that looks less like a ledger and more like a living, breathing notebook for autonomous software. It must juggle relational joins and vector maths, accept that schemas are suggestions, and secure every byte as though the device could be stolen tomorrow.

We’re building SurrealDB because we believe that convergence is inevitable. But even if you never spin up a Surreal cluster, the principles remain: put memory next to the model, let it speak vectors, and design for a world where offline is the default, not the exception. Do that, and you’ll find that edge intelligence stops feeling like a demo and starts behaving like the future - quietly, responsively, and everywhere at once.

SurrealDB.com

Introducing Surreal Sidekick, your personal AI assistant

Jaime Morgan Hitchcock — Mon, 23 Dec 2024 10:29:57 +0000

With the recent release of Surreal Cloud (beta) and the introduction of the Surreal Cloud panel in Surrealist, we introduced a brand new tool to help you increase your SurrealDB productivity. Surreal Sidekick is our fully fledged AI assistant who can help you debug your queries, answer questions based on the latest available documentation, and optimise your use of SurrealDB.

In this post we will explore the advantages of using Surreal Sidekick, how it can supercharge your SurrealDB workflow, and how you can take full advantage of this powerful tool.

Hello! I'm Sidekick

Sidekick is housed within the Surreal Cloud panel in Surrealist, our graphical database management interface, available as both a web and desktop app. The first step to start using Sidekick is to open the Surrealist web app or install Surrealist Desktop on your system.

Once this is done, navigate to the Cloud panel and sign in. If you have not previously created an account, sign up to Surreal Cloud for free. In addition to Sidekick, you will gain access to all other features Surreal Cloud has to offer, including the ability to run your own managed instance of SurrealDB in the cloud.

Once you have entered the Surreal Cloud panel, you can simply navigate to the Sidekick page in the left sidebar to start your very first conversation.

Your personal assistant

Sidekick is continuously learning from all available SurrealDB resources, allowing it to respond to your questions with accurate and up-to-date information. This enabled you to effortlessly learn about any topic in SurrealDB, including the query language, storage drivers, SDKs, and more. You can even communicate with Sidekick in your preferred language, making it easier to get the information you need.

Now, enough about what Sidekick can do, let's actually explore it hands on and see it in action. In this example, I will ask Sidekick how I would perform a nearest neighbour vector search in SurrealDB.

As you can see, Sidekick has provided us with a quick run down of the vector search capabilities of SurrealDB, including explaining the presence of the KNN operator, as well as query snippets demonstrating it in action. After each response, Sidekick will compile the list of resources it used to answer your question, and lists them at the bottom of its response. This allows you to further research the documentation on relevant functionality.

Sidekick is not limited to answering questions about queries and code, it can also help you find solutions using the CLI tool. In this second example, let's ask Sidekick how we can validate SurrealQL files, which we may want to do as part of an automated system.

This time, Sidekick responded with shell commands allowing us to validate surql files using the CLI. Just like in the previous example, this answer also lists out its sources, allowing us to learn more about the CLI tool on the documentation website.

While asking Sidekick broad database questions is extremely useful, we can actually ask Sidekick to perform more specific tasks, for example on the topic of queries.

Your personal writer

Sometimes, you're just not in the mood to write complex queries, it happens to all of us! You can always ask Sidekick to generate queries for you instead. This is one of my personal favourite use-cases of Sidekick, and is a great example of how it can help boost your productivity. While Sidekick will always attempt to respond with a useful query, some generated queries may not always be what you were looking for. In these situations you can simply ask Sidekick to revise a previous response, or generate a completely different query.

In this next scenario, we want to perform a full-text search on a hypothetical post table, while weighing the title above the content. While this is useful for when you want to rank title matches higher, it involves writing some math in our query to compute a combined score. Let's ask Sidekick to generate this query for us.

And just like that, Sidekick gives us a SELECT query that we might only have to touch up slightly before we can use it, how convenient! While this was just one specific example, there are many more different questions we could ask, such as "How can I select all but a specific field from a record", or "How do I select multiple fields from a graph edge?". I won't bother you with more examples, instead, feel free to try it out yourself!

While on the topic of queries, Sidekick can do much more than just create queries. You might come across a query written by your co-worker and just can't wrap your head around it. For these situations, Sidekick can also be your lifesaver.

Your personal teacher

Instead of telling Sidekick to generate a query, we can also flip things around. What if we give Sidekick a query, and tell it to explain it step-by-step?

As an example, let's take this query containing the graph recursion syntax. There is a lot going on, so perhaps Sidekick can help us break it down into individual steps and explain each part.

Nice! We can now learn about each individual segment and start to understand how this query is put together. If something is still not entirely clear to you, feel free to respond back with follow-up questions, which Sidekick will try to answer.

Instead of providing queries for Sidekick to explain, you might also just come across a specific keyword or syntax you haven't seen before. In these situations you can also ask Sidekick to explain them to you. In this example we can take the closure syntax present in SurrealQL, used to create anonymous functions on the fly. Let's see if Sidekick can tell us how it works.

We have now learnt how we can use Sidekick to create queries, and explain them to us, however there is one last use-case which may be even more useful.

Your personal detective

Writing queries can be difficult, but debugging them can be even harder. While SurrealQL is one of the easiest query languages to use, there are still many intricacies behind writing valid, performant, and maintainable queries. You might run into difficulties writing complex queries, or struggle with an error you can't solve. In this situations you can also ask Sidekick to help you out.

For example, in our table of products we want to add a cheese grater, so we run a CREATE statement to create a new record with the id product:cheese-grater, however upon executing this query, we receive the following error

Parse error: Unexpected token `-``, expected Eof

That's a bummer, let's see if Sidekick can help us solve this one by asking it why our record id is being rejected.

Sidekick correctly helped us identity the cause of our error being that the record id must be escaped, as hyphen characters are not allowed by default.

Just like all examples we've discussed in this blog post, this too is just a single use-case out of a sea of possibilities. The next time you run into difficulty debugging a query, I highly recommend you give Sidekick a try yourself, as it might save you valuable time.

The future

While Sidekick is an extremely powerful tool and can help you in many ways, it is currently still in beta. This means responses may not always be entirely accurate. As Sidekick continues to answer questions and help write queries, it will learn and grow from its conversations. We intend to keep improving Sidekick going forward, and keep it up-to-date with knowledge over the latest SurrealDB features.

In addition, we have many further improvements planned to make Sidekick an even bigger asset to your SurrealDB experience.

Aeon's Surreal Renaissance: Learn SurrealDB Through a Story

Jaime Morgan Hitchcock — Sun, 22 Dec 2024 10:02:20 +0000

We are thrilled to have published Aeon’s Surreal Renaissance, SurrealDB’s inaugural book as part of SurrealDB University. It’s an immersive experience that will teach you everything you need to know about SurrealDB in a story where you are the main character. Our goal was to make learning SurrealDB fun and intuitive.

Imagine yourself taking a leisurely walk along your favourite route, enjoying the familiar sights. But today, something feels different. Instead of turning right, as you always do, you choose to turn left, drawn by a sense of adventure. With each step, you make a series of small decisions that lead you somewhere entirely new—a place you’ve never seen before: a tunnel. Tunnels can be eerie, dark, and full of unknowns, yet your curiosity overpowers the fear, and you find yourself stepping boldly inside.

In the tunnel, you find technology rivalling what you see in Star Trek and Star Wars. You realise that it was an advanced civilisation of the past that made it.

Their medical technology is so advanced that it can cure the deadliest of diseases. But their weaponry is just as advanced, and even thinking about it makes you shudder. Should you run away and pretend that you never saw the tunnel in the first place?

This book tells the story of a person much like that, set in our world in the future.

For some reason, humanity in the future is back to riding horses and swinging swords, and they have forgotten about the past. But one day, a person just like you comes across a tunnel with books and computers from our time that somebody set up for some reason. This person is your alter ego in the future, who we are going to call Aeon.

Aeon has an idea: why not put the knowledge from the books into the database? This would make it easy to access, and maybe even help to rebuild all the great inventions of the past.

That is where the book begins, as you follow your alter ego who begins to learn SurrealDB. In each chapter, you follow along with Aeon who is on a long and exciting quest to master the database and restore civilisation.

Just like everyone else, Aeon has good days,

and bad days.

Sometimes working with the new technology is exciting. Sometimes it feels like an impossible task to master. And other times it’s downright scary, like the time Aeon woke up to see all the data in the database deleted (because SurrealDB runs by default in memory unless you choose to save to disk!). That can be intimidating when you grew up in a world where the only way to record data was by writing every word by hand.

But Aeon persists, and so do you, as you go through the book chapter by chapter on a shared journey together. It’s almost like you have your laptop open as you look over Aeon’s shoulders centuries in the future. And as you do so, you get closer and closer to the secret of why humanity lost all of its technology in the 21st century.

That’s the sort of immersion that this book brings, an experience that almost makes you forget that you’re learning.

The hope for this book is that you will say the following two things after it is over:

“Wow, what a great story!”
“Huh! Everything in SurrealDB makes perfect sense to me now.”

The book is beautifully designed, and thanks to the embeddable nature of SurrealDB’s Surrealist app, the majority of the examples are runnable right inside the book! A single click shows you the results inside an interactive frame in which you can experiment with the data on your own.

And if you prefer a traditional book feel, no problem—each example is readable on its own and is followed by the expected output. It’s all up to you and how you prefer to interact with the book.

We hope you enjoy reading this book as much as we do.

We're hiring!

Jaime Morgan Hitchcock — Thu, 01 Feb 2024 17:00:38 +0000

🌟 We're hiring! Join SurrealDB as we continue to shape the future of database technology! 🌟

Current openings:

Senior Software Engineer - Enterprise Platform (EP)
Senior Software Engineer - Query Language (QL)
Head of Marketing
Chief Security Officer
Social Media Manager
Senior Platform Engineer

At SurrealDB, we're not just a startup; we're a visionary team dedicated to crafting the ultimate database for tomorrow's technology. We're on the lookout for exceptional individuals - those who are passionate about their craft and equally passionate about the team they work with to develop and promote groundbreaking technology.

We offer competitive salaries, comprehensive health benefits, and flexible working arrangements. We're committed to maintaining a healthy work-life balance, providing our employees with the support and flexibility they need to thrive in both their professional and personal lives.

Interested? Visit our careers page for more details and to apply: https://surrealdb.com/careers

SurrealDBCareers #TechJobs #NowHiring

SurrealDB - We're hiring! 🚀

Jaime Morgan Hitchcock — Tue, 29 Nov 2022 23:53:36 +0000

We're hiring! 🚀

SurrealDB is a newsql multi-model database, that operates in schemafull or schemaless mode, with tables, inter-document record links (no JOINs), and graphdatabase modelling functionality. You can query it from the backend, or from frontend applications (Chrome, Firefox, Safari, Electron, Tauri) with javascript, with in-built permissions and authentication.

We are a startup with an ambitious mission to build the ultimate multi-model database for tomorrow’s applications. We are seeking to hire the best - people who care deeply about the work they do, and care about the people with whom they create and promote the product. Apart from mere excellence, we value integrity, respect, inclusion and collaboration - in short, we want to create the happiest and friendliest team for whom work is a pleasure. We have offices in New York and London, we also work remotely, and we enable flexible working which we think contributes to a healthy family life. We offer generous benefits, and facilitate full team meetups at least twice a year.

Open positions:
Cloud/Devops Engineer
Developer Advocate
Senior JavaScript Engineer (User Interface)
Senior Rust Engineer (Data Storage)
Senior Rust Engineer (Database)
Senior Rust Engineer (Distributed Systems)
Senior Rust Engineer (Indexing And Full-Text Search)
Social Media Manager

Do you want to join our team? Then we'd love ❤️ to hear from you!

More info on SurrealDB can be found below:
SurrealDB Careers
SurrealDB.com
Our GitHub repo
Indie Hackers

🆕 Just released SurrealDB for Microsoft Windows! 🚀

Jaime Morgan Hitchcock — Sat, 03 Sep 2022 14:55:22 +0000

The easiest and preferred way to get going with SurrealDB on Windows is to install and use the SurrealDB command-line tool. Run the following command in your terminal and follow the on-screen instructions.

iwr https://windows.surrealdb.com -useb | iex

What is SurrealDB?

SurrealDB is a newsql multi-model database, that operates in schemafull or schemaless mode, with tables, inter-document record links (no JOINs), and graph database modelling functionality. You can query it from the backend, or from frontend applications (Chrome, Firefox, Safari, Electron, Tauri) with javascript, with in-built permissions and authentication.

With full graph 📈 database functionality, SurrealDB enables more advanced querying & analysis. Multi-table, multi-depth document relationships can be retrieved efficiently in the #database without complicated #JOINS, & without any table scans. 🥳

Easily ➕ add field and data constraints directly to your data in SurrealDB. Use schemafull or schemaless data access methods, so that the #database always fits to the needs of your data.

Store and query 📍🗺 geographical GeoJSON data directly in the database. SurrealDB is designed to be flexible to use for all developers. 👌

And much, much more...

More info on SurrealDB can be found below:
SurrealDB.com
Our GitHub repo
My previous DEV.to post

🚀 Just launched a new scalable cloud graph database! Any feedback/users/testers appreciated!

Jaime Morgan Hitchcock — Mon, 15 Aug 2022 17:22:00 +0000

My brother and I have just 🚀 launched our scalable cloud graph database SurrealDB in public open beta. We've been working on it for 7 years now, and it's completely free to use. We wanted to create a database that allowed developers to focus on building frontend applications, and not worrying about the backend infrastructure.

Database, API, and permissions

Database, realtime API layer, and security permissions all-in-one

SurrealDB combines the database layer, the querying layer, and the API and authentication layer into one platform. Advanced table-based and row-based customisable access permissions allow for granular data access patterns for different types of users. There's no need for custom backend code and security rules with complicated database development.

Multi-model database

Tables, documents, and graph. Store and model your data in any way.

As a multi-model database, SurrealDB enables developers to use multiple techniques to store and model data, without having to choose a method in advance. With the use of tables, SurrealDB has similarities with relational databases, but with the added functionality and flexibility of advanced nested fields and arrays. Inter-document record links allow for simple to understand and highly-performant related queries without the use of JOINs, eliminating the N+1 query problem.

Inter-document links

Advanced inter-document relations and analysis. No JOINs. No pain.

With full graph database functionality SurrealDB enables more advanced querying and analysis. Records (or vertices) can be connected to one another with edges, each with its own record properties and metadata. Simple extensions to traditional SQL queries allow for multi-table, multi-depth document retrieval, efficiently in the database, without the use of complicated JOINs and without bringing the data down to the client.

Simple schema definition

Simple schema definition for frontend and backend development

With SurrealDB, specify your database and API schema in one place, and define column rules and constraints just once. Once a schema is defined, database access is automatically granted to the relevant users. No more custom API code, and no more GraphQL integration. Simple, flexible, and ready for production in minutes not months.

Connect from the browser

Connect and query directly from web-browsers and client devices

Connect directly to SurrealDB from any end-user client device. Run SurrealQL queries directly within web-browsers, ensuring that users can only view or modify the data that they are allowed to access. Highly-performant WebSocket connections allow for efficient bi-directional queries, responses and notifications.

Flexible querying

Query the database with the tools you want

Your data, your choice. SurrealDB is designed to be flexible to use, with support for SurrealQL, GraphQL (coming soon), CRUD support over REST, and JSON-RPC querying and modification over WebSockets. With direct-to-client connection with in-built permissions, SurrealDB speeds up the development process, and fits in seamlessly into any tech stack.

Realtime live queries

Realtime live queries and data changes direct to application

SurrealDB keeps every client device in-sync with data modifications pushed in realtime to the clients, applications, end-user devices, and server-side libraries. Live SQL queries allow for advanced filtering of the changes to which a client subscribes, and efficient data formats, including DIFFing and PATCHing enable highly-performant web-based data syncing.

Scale effortlessly

Scale effortlessly to hundreds of nodes for high-availability and scalability

SurrealDB can be run as a single in-memory node, or as part of a distributed cluster - offering highly-available and highly-scalable system characteristics. Designed from the ground up to run in a distributed environment, SurrealDB makes use of special techniques when handling multi-table transactions, and document record IDs - with no use of table or row locks.

Embedded functions

Extend your database with JavaScript and WebAssembly functions

Embedded JavaScript functions allow for advanced, custom functionality, with computation logic being moved to the data layer. This improves upon the traditional approach of moving data to the client devices before applying any computation logic, ensuring that only the necessary data is transferred remotely. These advanced JavaScript functions, with support for the ES2020 standard, allow any developer to analyse the data in ever more simple-yet-advanced ways.

Embedded or distributed

Designed to be embedded or to run distributed in the cloud

Built entirely in Rust as a single library, SurrealDB is designed to be used as both an embedded database library with advanced querying functionality, and as a database server which can operate in a distributed cluster. With low memory usage and cpu requirements, the system requirements have been specifically thought through for running in all types of environment.

Quick look...

Set granular 🔑 permissions to ensure that only the right people can 👀 see the right data.

Aggregate views let you pre-compute 📈 analytics queries as data is written to SurrealDB in an efficient and performant way. No more 🥴 complicated queries for dashboard analytics.

Any feedback/users/testers appreciated

We're really pleased with where we've got to so far, but we have such a long journey to go!

We are looking for as much feedback, suggestions, contributors, or advice as possible from this awesome community! 😀 SurrealDB