<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[OceanBase Database - Medium]]></title>
        <description><![CDATA[This publication shares product news and engineering best practices about OceanBase, a distributed SQL database at scale, as well as insights on the database industry. - Medium]]></description>
        <link>https://medium.com/oceanbase-database?source=rss----617ed9842a21---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>OceanBase Database - Medium</title>
            <link>https://medium.com/oceanbase-database?source=rss----617ed9842a21---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 01:50:33 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/oceanbase-database" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com" rel="hub"/>
        <item>
            <title><![CDATA[Scale Out Without Downtime: How OceanBase Adds Nodes Online]]></title>
            <link>https://medium.com/oceanbase-database/scale-out-without-downtime-how-oceanbase-adds-nodes-online-af74c5dfeb4d?source=rss----617ed9842a21---4</link>
            <guid isPermaLink="false">https://medium.com/p/af74c5dfeb4d</guid>
            <category><![CDATA[oceanbase]]></category>
            <category><![CDATA[horizontal-scaling]]></category>
            <category><![CDATA[scalability]]></category>
            <dc:creator><![CDATA[OceanBase]]></dc:creator>
            <pubDate>Mon, 17 Aug 2026 09:48:41 GMT</pubDate>
            <atom:updated>2026-08-17T09:48:41.102Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YRJI2aDuzaej_xp1J82ZFw.png" /></figure><p>When businesses grow rapidly, database scaling often becomes one of the biggest challenges for operations teams. For many relational databases, horizontal scaling is never as simple as “adding one more machine.” It usually comes with service interruption risk and requires teams to manually redesign sharding strategies, migrate data, and carefully validate the results.</p><p>Mainstream cloud-native databases offer natural advantages in scaling reads, but writes are often constrained by the architectural bottleneck of a single primary node. When write traffic surges, teams often have to upgrade to a larger instance type, which still involves a database restart or a primary-standby switchover.</p><p>As a native distributed database, OceanBase makes adding nodes much simpler. Users only need to adjust a parameter, and the new nodes can automatically start taking over traffic. The change is largely transparent to applications, and services remain available throughout the process. This turns what was once a high-risk scaling operation into a routine task that can be performed whenever needed.</p><h3>How OceanBase Horizontal Scaling Works</h3><h4>Adjust One Parameter to Scale Out and Rebalance Data Automatically</h4><p>In “<a href="https://yuque.antfin.com/bng8bl/oodzer/afmvew1tuv9sge6q">OceanBase Tenant-Level Scaling: Adjust Resources in Seconds</a>,” we compared an OceanBase cluster to a large business park, where each physical machine is like an office building. When a company, or tenant, moves into the park, it leases a package of offices distributed across different buildings. These offices correspond to the resource units allocated to the tenant.</p><p>In that article, we explained that the fastest way to handle sudden traffic spikes is to add more desks and chairs inside the existing offices — that is, to increase the resource quota within each machine. But when a single machine is already close to its physical limit, the system needs to scale out by adding nodes.</p><p>In OceanBase, horizontal scaling is mainly achieved in two ways:</p><ol><li><strong>Increase the number of resource units.</strong><br>This applies to capacity expansion within the same data center. In the business park analogy, this is like adding new office buildings to the same park and leasing additional offices in those buildings. In technical terms, new nodes are added to the cluster, and the tenant receives more resource units across those nodes. Heavy workloads that were previously concentrated in a small number of offices are redistributed across more offices and processed in parallel, breaking through the compute and storage limits of a single machine.</li><li><strong>Increase the number of primary zones.</strong><br>This applies to service expansion across data centers, allowing nodes in more regions to serve traffic together. It is like a company with offices in cities A, B, and C. Originally, only city A handles customer reception and order processing, while cities B and C mainly handle accounting synchronization, or data backup. When city A reaches its service capacity limit, the branch office in city B can also be promoted into a business center that handles orders. In this way, nodes in multiple regions can directly process read and write requests at the same time. Without adding new physical machines, the system can make better use of previously idle resources.</li></ol><p>No matter which parameter is adjusted, adding nodes and redistributing workloads, or data rebalancing, are handled automatically by the database kernel. After new nodes join the cluster, OceanBase automatically and smoothly migrates some data to the new nodes based on data volume, storage usage, and hotspot distribution.</p><p>For example, if three nodes originally manage 100 data segments, after two new nodes are added, the system may redistribute roughly 20 segments to each new node. Eventually, all five nodes share the workload together, with no service interruption or manual intervention.</p><h3>How Does OceanBase Maintain Consistency During Data Migration?</h3><p>During horizontal scaling, OceanBase does not take the entire database offline or move all data to a new set of nodes at once. Instead, it migrates data gradually at the partition level.</p><p>In a multi-replica architecture, read and write traffic for each partition always follows the corresponding leader replica. During scaling, the system first creates new follower replicas for selected partitions on the new nodes and starts synchronizing data. This synchronization is based on OceanBase’s internal physical logs, known as clog, and the Multi-Paxos protocol.</p><p>Compared with the binlog and relay log processing chain used in MySQL primary-standby replication, this mechanism is more lightweight. It reduces synchronization overhead in high-concurrency scenarios and helps new replicas catch up with the source nodes more quickly.</p><p>After the replicas on the new nodes catch up, the system initiates a smooth leader switchover based on the Multi-Paxos protocol. The current leader does not step down until the necessary log commits are complete. Through majority election and lease mechanisms, the system ensures that the replica on the new node can safely take over as the new leader.</p><p>This mechanism ensures that the same partition never has two valid leaders at the same time, preventing data inconsistency caused by split-brain scenarios. After the switchover is complete, the frontend proxy component automatically detects the change, refreshes routing information, and forwards subsequent requests to the node where the new leader resides.</p><p>The entire handoff is completed at the kernel and routing layers, while business applications continue running steadily.</p><blockquote><strong>Note:</strong> OceanBase’s Multi-Paxos protocol and related mechanisms play a decisive role in balancing data reliability and availability. For details, see the article on <a href="https://en.oceanbase.com/blog/zero-data-loss-fast-failover-oceanbase-multi-paxos?utm_campaign=campaign&amp;utm_source=marketbeam&amp;utm_medium=social&amp;mb_tracking_id=1.77aa93c9">how OceanBase uses Multi-Paxos for consensus and disaster recovery</a>.</blockquote><h3>Why Are Applications Unaware of the Change?</h3><p>After data migration is complete, how does the application know where to find the data?</p><p>The answer is that it does not need to know.</p><p>As mentioned above, OceanBase provides a transparent routing proxy layer, OceanBase Database Proxy (ODP, also known as OBProxy). No matter how the underlying nodes change or where data is migrated, the application continues to connect through a single stable database endpoint.</p><p>Developers do not need to modify database connection strings or change SQL syntax. They can use a continuously expanding cluster just as they would use a conventional single-node database.</p><h3>Performance Scales Near-Linearly as Nodes Are Added</h3><p>The real value of scaling lies in whether performance actually improves as more nodes are added.</p><p>In the publicly available TPC-C benchmark, when an OceanBase cluster expanded from 3 nodes to 1,500 nodes, its transaction throughput per minute, or tpmC, achieved near-linear growth. The cluster maintained this near-linear scaling even when 10% of the workload consisted of distributed transactions.</p><p>Many distributed architectures maintain consensus and synchronization independently for replicas of each data partition. This means that as the number of partitions increases, the total overhead required to maintain data consistency also rises. OceanBase’s design ties this overhead to the number of nodes rather than the number of partitions. As a result, when the cluster scales horizontally, overhead grows smoothly with the number of nodes instead of spiraling out of control as data partitions multiply.</p><p>By contrast, mainstream cloud-native architectures are still essentially based on a primary-standby model. The cluster has only one write node, and simply adding read-only nodes cannot break through the physical ceiling of write capacity.</p><h3>Scaling Duration and Business Impact</h3><p>A practical question for engineers is: how long does the operation take, and how much will it affect the business?</p><p>The time required for scaling is mainly determined by the amount of business data and the available cluster resources at the time, such as network bandwidth and disk I/O. The upper limit of migration speed can be roughly estimated as follows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*G_f7VkOI66mAYVbMcgfIog.png" /></figure><p><strong>Note:</strong> Available bandwidth equals the hardware’s physical limit minus the resources currently consumed by the business. The default migration quota ratio is 60%.</p><p>Put simply, migration can only run as fast as the more constrained resource allows, whether that constraint is disk throughput or network bandwidth. If scaling is performed during peak business hours, business traffic may already be consuming a large amount of these resources. With fewer resources left for migration tasks, scaling naturally takes longer.</p><p>During scaling, background data migration tasks share node resources with frontend business traffic. To avoid resource contention, OceanBase provides resource isolation mechanisms. Operations teams can centrally configure the network bandwidth quota, disk IOPS limit, and CPU weight available to migration tasks. During off-peak hours, they can loosen these limits to accelerate migration. During peak hours, they can tighten them to protect normal business traffic.</p><p>The actual impact on the business depends on cluster load at the time of scaling.</p><ul><li>When the cluster is lightly loaded, such as when CPU and I/O utilization are below 60%, the business is almost unaffected.</li><li>When the cluster is heavily loaded, resource isolation can proportionally limit the bandwidth and CPU consumed by migration tasks, keeping QPS fluctuations within 15% and restoring stability within a few minutes.</li></ul><h3>When Should You Use Horizontal Scaling?</h3><p>OceanBase provides multiple elastic scaling options, and enterprises can choose based on their needs. As the final topic in this series, this article summarizes the recommended approaches for different scenarios:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*at4YhO4JGDcy_iSs6L_FYA.png" /></figure><p><strong>Note:</strong> In the pay-as-you-go mode of OceanBase Cloud, billing based on the new specification starts <strong>as soon as the scaling operation is initiated</strong>, and compute costs increase as nodes are added. After scale-in, node charges also stop immediately, so you do not need to continue paying for idle capacity.</p><h3>Summary</h3><p>Database scaling should not be a disruptive, high-risk engineering project. It should be a routine resource adjustment.</p><p>OceanBase achieves this through a combination of kernel-level mechanisms: consensus protocols protect data during migration, the routing layer keeps applications unaware of topology changes, and the database kernel handles load rebalancing automatically. This design allows the database to scale flexibly with business demand, while helping enterprises avoid long-term over-provisioning for uncertain growth.</p><h3>Further Reading</h3><ul><li><a href="https://en.oceanbase.com/docs/common-oceanbase-database-10000000003450715">Add a node</a></li><li><a href="https://en.oceanbase.com/docs/common-oceanbase-database-10000000003450709">Delete a node</a></li><li><a href="https://en.oceanbase.com/docs/common-oceanbase-database-10000000003452690">sys_bkgd_net_percentage</a></li><li><a href="https://en.oceanbase.com/docs/common-oceanbase-database-10000000003452935">ha_high_thread_score</a></li><li><a href="https://en.oceanbase.com/docs">OceanBase Database Documentation</a></li></ul><p><em>Author:Yiwen Qian</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=af74c5dfeb4d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oceanbase-database/scale-out-without-downtime-how-oceanbase-adds-nodes-online-af74c5dfeb4d">Scale Out Without Downtime: How OceanBase Adds Nodes Online</a> was originally published in <a href="https://medium.com/oceanbase-database">OceanBase Database</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Ontology vs. Semantic Layer: Why Your AI Agent Needs Both]]></title>
            <link>https://medium.com/oceanbase-database/ontology-vs-semantic-layer-why-your-ai-agent-needs-both-a2e24c8060a1?source=rss----617ed9842a21---4</link>
            <guid isPermaLink="false">https://medium.com/p/a2e24c8060a1</guid>
            <category><![CDATA[enterprise]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[data-analytics]]></category>
            <dc:creator><![CDATA[OceanBase]]></dc:creator>
            <pubDate>Fri, 14 Aug 2026 07:27:40 GMT</pubDate>
            <atom:updated>2026-08-14T07:27:40.792Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*okyPh8TZ2qXj89lGE9fwpA.png" /></figure><h3>One Metric, Three Numbers</h3><p>Since we shipped OceanBase DataPilot, one pattern has come up with almost every customer: the same metric returns a different number depending on who asks. Finance says revenue is 10.2M. Marketing says 10.4M. The AI assistant in Slack says $9.8M. Three numbers, no agreement.</p><p>That used to be a people problem, and people could settle it in a ten-minute meeting. An agent won’t ping a colleague to ask how a metric was defined. When it hits a column called rev_ttm_adj_v2, it either invents an answer or takes the first definition it happens to find.</p><p>Injecting modeled domain knowledge into the retrieval path has been shown to cut hallucination rates by around 40% — but only if that knowledge is actually modeled somewhere, rather than living in the heads of the three people who built the tables. This is why we treat the context layer as a first-class part of OceanBase’s AI database architecture. It doesn’t matter how much data you can store or how capable the agent is: if everything between them is raw tables and SQL, the business will never trust the output.</p><h3>The Context Layer</h3><p>Context Layer isn’t a product name. It’s the layer that wraps semantic definitions, domain knowledge, lineage, governance policy, quality signals, and certification status behind one interface that humans and agents can both query.</p><p>Ontologies and semantic layers are its two load-bearing pieces. Vendors like to fold them into a single buzzword, but they solve different problems — and teams that build them in the wrong order end up with AI projects that demo beautifully and never reach production.</p><h3>The Division of Labor, in One Sentence</h3><p><strong>A semantic layer answers “what is our revenue?” An ontology answers “what is a customer?”</strong></p><p>The semantic layer owns metrics: how revenue, MAU, and LTV are calculated, which tables to join, which filters apply. Its job is to make sure every team and every tool computes them identically.</p><p>The ontology owns meaning: what a customer is, how a customer relates to an order, which rules make a customer Platinum, and whether a machine can derive new conclusions from facts it already has.</p><h3>Ontology: Concepts, Relationships, and Reasoning</h3><p>The textbook definition — “an explicit formal specification of a shared conceptualization” — comes down to three parts:</p><ul><li><strong>Classes</strong> — the kinds of things in the domain (Customer, Product, Order, Region)</li><li><strong>Properties and relationships</strong> — how they connect (a Customer <em>places</em> an Order; a Product <em>belongs to</em> a Category)</li><li><strong>Axioms and rules</strong> — the logical constraints (every Order contains at least one Product; a Customer belongs to exactly one Region at any given time)</li></ul><p>Because ontologies are written in W3C standards such as RDF and OWL, machines can do more than read them — they can reason over them. If the ontology says a Platinum customer is one with annual revenue above 1M, and the facts say Acme’s annual revenue is 2M, the engine concludes on its own that Acme is Platinum. Nobody writes the if-else. This is the part semantic layers and BI tools can’t do: they execute calculations you defined in advance, but they never derive a fact you didn’t.</p><p>Ontologies also reconcile vocabulary across systems. CRM calls it a Customer, ERP calls it a Client, Finance calls it an Account — the ontology points all three at the same business object. An agent grounded in an ontology traverses a connected graph instead of guessing its way through a pile of unrelated tables. SNOMED CT in healthcare and FIBO in financial services are the canonical examples; in regulated domains, a formal ontology is effectively table stakes.</p><p>The cost is just as clear. Palantir turned enterprise ontology into a category, but the delivery model is heavy: forward-deployed engineers, hand modeling, six to eighteen months for a full build, and formal-logic skills that are genuinely hard to hire.</p><h3>Semantic Layer: Metrics, Logic, and Numbers That Agree</h3><p>The semantic layer comes from a more pragmatic engineering tradition. Business Objects shipped “Universe” in the 1990s to hide complex schemas behind business language, and the problem it addressed hasn’t changed since: teams calculate revenue differently, the numbers disagree, and trust erodes. What’s new is the blast radius. Inconsistent definitions used to produce an awkward slide; now they produce a hallucinated number inside a decision report.</p><p>A modern semantic layer has four parts: a <strong>metadata repository</strong> that maps mrr_calc_v3 to &quot;monthly recurring revenue&quot;; a <strong>business logic engine</strong> that holds metric formulas in one place, defined once and reused everywhere; <strong>query translation</strong> that generates the joins and filters; and <strong>access control</strong> that applies row- and column-level permissions consistently.</p><p>The tooling has matured quickly. dbt Semantic Layer with MetricFlow put metrics under version control as YAML and compiles them to multiple SQL dialects. Snowflake, Salesforce, dbt Labs, and BlackRock launched OSI (Open Semantic Interchange) in September 2025, and v1.0 shipped in January 2026 as a vendor-neutral standard for exchanging semantic metadata. LookML, DAX, Cube, AtScale, Snowflake Semantic Views, and Databricks Metric Views are all converging on the same idea: the semantic layer is becoming standard infrastructure in an AI-ready data stack.</p><p>It still has a ceiling. It can tell you exactly how revenue is calculated. It cannot tell you how a customer relates to a market and a regulatory framework, or whether an account should be flagged as high-risk under a set of domain rules.</p><p>As Jessica Talisman put it in Metadata Weekly: <strong>the semantic layer is for lookup; the ontology is for context and reasoning.</strong></p><h3>What Breaks When You Only Build One</h3><p><strong>Semantic layer only: accurate but shallow.</strong> Ask which channel drove the highest GMV last month and you get a precise answer. Ask why that channel declined, or whether you should increase spend on it, and you get nothing. The layer has no model of how channels, spend strategy, and customer profiles relate.</p><p><strong>Ontology only: fluent about concepts, useless on numbers.</strong> Ask whether Acme is a Platinum customer and the reasoning is flawless. Ask what Acme’s revenue was last month and you’re back to three answers, because nothing tells the system which fact table to query or how to aggregate it.</p><p>The industry data points the same direction. Gartner expects more than 40% of agentic AI projects to be cancelled by the end of 2027, citing cost, unclear value, and inadequate controls. In a survey of 248 data management leaders, 63% said they lacked the data management practices needed to support AI. Most of these failures aren’t about picking the wrong model; they’re about data with no semantic grounding underneath it.</p><p>The other side of the trend is just as visible. Gartner’s 2026 summit projected that by 2030, universal semantic layers will sit alongside data platforms and cybersecurity as critical infrastructure, and Futurum expects adoption to grow from 16% in 2026 to 30% by 2031. Microsoft Fabric IQ is previewing native ontology support, and Timbr.ai markets “semantic layers with reasoning.” The two paths are merging.</p><h3>Where Knowledge Graphs and Taxonomies Fit</h3><p>A <strong>knowledge graph</strong> holds the instances — actual customers and actual orders as nodes. The ontology is the schema; the knowledge graph is the data. When an agent walks relationships at runtime, it’s walking the graph.</p><p>A <strong>taxonomy</strong> is an ontology with the hard parts removed: parent-child hierarchies, no reasoning, no lateral relationships. Product catalogs, data domain classification, and PII tagging all start here, and that’s a reasonable place to start. You only need to move toward a full ontology once an agent has to reason across categories — “if category A is downgraded, does category B’s inventory get affected?”</p><h3>Putting It Together</h3><p>We think about the context layer in two halves:</p><ul><li><strong>Data context</strong> — ontology, semantic layer, knowledge graph, lineage, quality scores, access policy. This tells the AI what kind of business it is operating inside.</li><li><strong>Application context</strong> — user preferences, conversation history, domain documents, retrieved facts (memory plus RAG). This tells the AI who it is talking to.</li></ul><p>In practice, a single question flows through all four:</p><ol><li>The ontology defines “revenue recognition” as a concept, along with the rules attached to it</li><li>The semantic layer turns that into computation — which tables to join, how to aggregate</li><li>The knowledge graph connects the concept to its metrics, lineage, and downstream consumers</li><li>MCP delivers that context to the agent at inference time</li></ol><p>Everything the context engineering discussion has produced over the past two years lands on the same conclusion: reliable output requires structured context, and ontologies and semantic layers are the two hardest pieces to get right. MCP solves the delivery problem. It does nothing about what you deliver — hand an agent ungoverned tables and SQL, and the protocol will faithfully transport a hallucination.</p><h3>What We Built: OceanBase OSI</h3><p>Rather than shipping another BI semantic layer, we unified metrics, definitions, raw data, the context graph, and the ontology into one open semantic stack: <strong>OceanBase OSI (Open Semantic Interchange)</strong>. It has three layers.</p><ul><li><strong>Semantic layer (bottom).</strong> Metric definitions, calculation rules, and dimension-to-data mappings. It is built on the Ant-OSI standard, compatible with industry OSI, and has been running in production at Ant Group.</li><li><strong>Context graph (middle).</strong> Metrics, objects, events, lineage, and consumers connected as a network. An LLM reasoning over this graph does measurably better than one reading table schemas or YAML alone.</li><li><strong>Ontology layer (top).</strong> Business semantics aligned with database semantics. Workspace-local terminology and enterprise-wide concepts stay linked while evolving on their own schedules.</li></ul><p>The principle underneath all three is <strong>semantic as code</strong>: define the semantics once, then let BI render dashboards, agents generate SQL, and governance tools trace lineage — all against the same definition. No separate semantics for BI, for AI, and for governance.</p><p>Across customer POCs in several industries, DataPilot’s natural-language-to-data accuracy has come out well ahead of the alternatives it was measured against. The model isn’t the differentiator — everyone is calling the same frontier LLMs. The differentiator is the quality of the semantic context. Give an agent accurate business definitions instead of raw tables, and NL-to-SQL accuracy improves in a way no amount of prompt tuning will match.</p><h3>Where to Start</h3><p><strong>Start with the semantic layer if:</strong></p><ul><li>Teams disagree on what “revenue” or “active user” means</li><li>You’re building conversational analytics or chat-with-data</li><li>Your data stack is already centralized and you want returns in two to six months</li></ul><p><strong>Start with the ontology if:</strong></p><ul><li>You’re in finance, healthcare, or government, where compliance requirements are strict</li><li>Your AI has to reason across domains — customer × product × regulation</li><li>The same concept goes by a different name in half a dozen systems</li><li>You need automated classification or rule-based anomaly detection</li></ul><p><strong>For most enterprises, the pragmatic sequence is:</strong></p><ol><li>Build the semantic layer first. Centralize core metrics so BI and AI read the same definitions.</li><li>Keep the ontology light to begin with — a business glossary, not a full OWL modeling effort.</li><li>Layer in governance signals: lineage, quality scores, ownership, certification.</li><li>Expose all of it to agents over MCP, which is what turns the context layer from a diagram into infrastructure.</li></ol><p>dbt won’t give you an ontology. A Palantir-style ontology doesn’t fit every team. Growing from a glossary into a formal ontology is a far more realistic path than trying to land the whole thing in one jump.</p><h3>What’s Next</h3><p><strong>Short term,</strong> we’re rolling the OSI semantic layer out to every DataPilot workspace, with metrics managed centrally in Ant-OSI format and terminology, metrics, and dimensions all discoverable and searchable.</p><p><strong>Medium term,</strong> we’re hardening the OSI ontology layer. Business glossaries, category hierarchies, and entity relationships ship first as a productized taxonomy, then gain cross-system alignment and basic reasoning. That growth happens domain by domain, not top-down.</p><p><strong>Long term,</strong> the hard question is what happens when domains that modeled their semantics independently need to merge them. Reconciling those conflicts — and keeping the relationship between local and global definitions evolvable — is the problem the OSI context graph exists to solve.</p><p><em>Author:Jiannan Ji</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a2e24c8060a1" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oceanbase-database/ontology-vs-semantic-layer-why-your-ai-agent-needs-both-a2e24c8060a1">Ontology vs. Semantic Layer: Why Your AI Agent Needs Both</a> was originally published in <a href="https://medium.com/oceanbase-database">OceanBase Database</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[OceanBase Tenant-Level Scaling: Adjust Resources in Seconds]]></title>
            <link>https://medium.com/oceanbase-database/oceanbase-tenant-level-scaling-adjust-resources-in-seconds-4f57106b98b8?source=rss----617ed9842a21---4</link>
            <guid isPermaLink="false">https://medium.com/p/4f57106b98b8</guid>
            <category><![CDATA[elastic-scaling]]></category>
            <category><![CDATA[oceanbase]]></category>
            <category><![CDATA[scalability]]></category>
            <dc:creator><![CDATA[OceanBase]]></dc:creator>
            <pubDate>Thu, 06 Aug 2026 09:21:21 GMT</pubDate>
            <atom:updated>2026-08-06T09:21:21.394Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-aLHZ1pgDmOH48VQe6ThXw.png" /></figure><p>Traffic fluctuations are inevitable for online services. For many platform engineers and DBAs, the real challenge is not necessarily a consistently high volume of traffic, but traffic that is highly volatile and unpredictable. Promotional events, product launches, flash sales, and new game releases can all create sudden traffic spikes. Estimating database capacity requirements for these events in advance is difficult, and traditional database scaling is often slow, tedious, and involves operational risk.</p><p>To ensure system stability during a major event — such as a highly anticipated game launch or a limited-edition product release — engineers are often forced to perform database scaling during off-peak hours, often late at night.</p><p>Scaling traditional single-node databases like MySQL requires upgrading the server specification, which involves provisioning a new machine, syncing data, and performing a primary-standby switchover. Even with modern cloud-native databases like Amazon Aurora, which eliminate some data migration overhead, upgrading compute instances still requires a restart or a failover that can cause brief connection interruptions. The entire process is time-consuming, and because the switchover can cause service interruptions, it usually has to be scheduled in a maintenance window.</p><p>Worse still, to play it safe, engineers often over-provision resources based on the most extreme scenarios. Once the event ends, they must go through the same cumbersome downscaling process all over again.</p><p>OceanBase handles this differently: adjusting a tenant’s resources is a quota change inside the kernel, which takes effect in seconds and is transparent to applications.</p><h3>How OceanBase Manages Tenant Resources</h3><p>Tenant-level scaling is a change to a tenant’s resource quota, so it helps to start with how OceanBase defines those quotas.</p><p>As a native distributed database, OceanBase organizes multiple physical servers into a unified cluster. On top of this cluster, OceanBase introduces the concept of <strong>tenants</strong>. A tenant can be understood as an independent database instance running within the cluster. Each tenant has its own data and resource quotas, and is fully isolated from other tenants. To an application, connecting to a tenant is identical to connecting to a standalone MySQL or Oracle database instance.</p><p>This multi-tenant architecture is powered by a fine-grained resource management system:</p><ul><li><strong>Unit config</strong>: Defines the allocation of physical resources, including CPU, memory, IOPS, and transaction log disk space.</li><li><strong>Resource unit</strong>: The actual allocation unit for these physical resources, distributed across the nodes of the cluster.</li><li><strong>Resource pool</strong>: A collection of resource units. A tenant obtains its required compute and storage resources by being associated with a resource pool.</li></ul><p>To use an analogy, think of an OceanBase cluster as a large business park, where the physical servers are the office buildings. When a company (a tenant) moves into the park, it leases a package of offices (a resource pool) spread across different buildings. Each individual office is a resource unit. The layout of the office — whether it is configured for 10 or 20 workstations — is defined by the unit config.</p><h3>Scaling by Adjusting Unit Configs</h3><p>In OceanBase, tenant-level scaling can be achieved through two primary paths:</p><ol><li>Adjusting the unit config to increase resource quotas within the existing nodes.</li><li>Adding nodes or additional zones to scale out horizontally.</li></ol><p>This article focuses on the first method — adjusting the unit config — which is a convenient way to address capacity bottlenecks.</p><p><strong>Adjusting the unit config</strong> is a vertical scaling mechanism applied at the tenant level. By modifying a tenant’s unit config, you can quickly increase or decrease the CPU, memory, and IOPS allocated to that tenant on each node.</p><p>Returning to our office analogy: this is equivalent to keeping the number of offices the same but adding more desks and chairs to each existing office to accommodate more employees. Because this process does not require moving any data, the configuration change takes effect in seconds. When a sudden traffic spike hits, administrators can adjust the tenant’s resource specifications at any time — even during peak business hours — quickly increasing the tenant’s processing capacity.</p><p>But where do the extra CPU and memory come from?</p><p>This scaling mechanism assumes that the physical nodes have unallocated, schedulable resources (which administrators can monitor in real time via system views). The cluster does not create additional resources on its own. Instead, it reallocates available physical resources within the existing cluster to the target tenant. This spare capacity typically comes from two sources:</p><ul><li>Reserved resources on each node: When a cluster is deployed, not all physical resources on each machine are assigned to tenants. Some CPU and memory are usually left unallocated for emergency scaling.</li><li>Idle resources from tenants under lighter load: In OceanBase’s multi-tenant architecture, workloads from different business lines often reach their busiest periods at different times. For example, consumer-facing services may see heavier traffic in the evening, while internal enterprise systems are usually busier during working hours. Administrators can temporarily allocate idle resources from tenants that are currently under lighter load to a tenant experiencing a sudden traffic surge. This time-based resource reuse improves overall resource utilization.</li></ul><p>Does this online resource adjustment affect other tenants running in the same cluster? It does not, as long as the cluster has sufficient overall resources. Increasing the quota for Tenant A simply assigns previously unallocated resources to Tenant A’s resource pool. The existing quotas for Tenant B remain unchanged, and its services continue running without disruption. (We will explore OceanBase’s tenant resource isolation mechanisms in an upcoming article in our flexibility series.)</p><blockquote>Note: Tenant-level elastic scaling is still limited by the physical resources available on a single node. When an “office” has no room for additional workstations and the node has no schedulable resources left, resources must be added at the infrastructure layer. This can be done in two ways. The first is cluster-level vertical scaling, such as upgrading to a larger cloud cluster specification or allocating more machine resources to the OceanBase process in an on-premises deployment. The second is horizontal scaling, such as adding physical nodes. We will cover cluster-level vertical and horizontal scaling in a later post.</blockquote><h3>Why Scaling Is Fast and Transparent</h3><p>Traditional database scaling is slow and risky because it is essentially a <strong>physical-layer operation</strong>. In MySQL, for example, scaling requires provisioning a higher-specification server as a standby node, waiting hours for data replication to complete, and then performing a primary-standby switchover, which can briefly interrupt active client connections.</p><p>In contrast, OceanBase’s tenant-level scaling is essentially a logical change in resource scheduling. When adjusting a unit config, the system only needs to perform basic resource availability checks and update the quota online.</p><p>This process involves no machine replacement, no data migration, and no primary-standby switchover, so the entire operation completes in seconds. Existing database connections remain active, and applications require no code modifications or schema changes.</p><p>Because OceanBase avoids time-consuming physical operations, operations teams can scale resources up or down at any time of day without waiting for a late-night maintenance window.</p><h3>Case Study: How POP MART Handles Launch-Day Traffic Spikes</h3><p>How does scaling that takes effect in seconds hold up under extreme, real-world workloads? POP MART’s online blind box business, where users purchase randomized collectible figures, provides a clear example.</p><p>In the past, whenever POP MART released a popular new product, the platform would see nearly one million concurrent users. To handle these sudden traffic spikes, the operations team had to pre-provision expensive, oversized database instances late the night before the launch, and then stay up late again after the rush to scale them back down. This approach not only wasted resources but also placed heavy pressure on the operations team, especially because of the frequent late-night changes.</p><p>After migrating to OceanBase and consolidating dozens of isolated database instances into three multi-tenant clusters, their operational model changed completely:</p><p>Now, on product launch days, administrators simply scale up tenant resource quotas online during the day and scale them back down with a single click once the peak passes. According to <a href="https://en.oceanbase.com/customer/popmart">public data</a>, their database scaling time was cut by 90%. Without any application-level modifications, the system achieved 99.999% service continuity during high-concurrency product launches. For most medium-scale traffic fluctuations, the team can now easily handle the load simply by “adding workstations” to the existing tenants.</p><h3>What Changes for Operations Teams</h3><p>OceanBase’s tenant-level elastic scaling shifts database capacity management from “late-night maintenance with service risk” to “anytime online adjustment.” With no hardware replacement, no failover, and no application changes, OceanBase enables enterprises to adjust capacity safely during business hours and respond to traffic volatility with greater confidence.</p><p>As workloads continue to grow, tenant-level scaling may eventually reach the physical limits of a single machine. At that point, higher-level scaling capabilities become necessary, such as cluster-level horizontal scaling and machine specification upgrades. We will explore these topics in future articles.</p><h3>Further Reading</h3><ul><li><a href="https://en.oceanbase.com/docs/common-oceanbase-database-10000000003450210">Introduction to OceanBase tenants</a></li><li><a href="https://en.oceanbase.com/docs/common-oceanbase-database-10000000003453729">Introduction to scaling in and out</a></li><li><a href="https://en.oceanbase.com/docs">OceanBase Database Documentation</a></li></ul><p><em>Author:Yiwen Qian</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4f57106b98b8" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oceanbase-database/oceanbase-tenant-level-scaling-adjust-resources-in-seconds-4f57106b98b8">OceanBase Tenant-Level Scaling: Adjust Resources in Seconds</a> was originally published in <a href="https://medium.com/oceanbase-database">OceanBase Database</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Start Small, Scale Big: Inside OceanBase’s Distributed Architecture]]></title>
            <link>https://medium.com/oceanbase-database/start-small-scale-big-inside-oceanbases-distributed-architecture-1b3d63cdb0fd?source=rss----617ed9842a21---4</link>
            <guid isPermaLink="false">https://medium.com/p/1b3d63cdb0fd</guid>
            <category><![CDATA[distributed-database]]></category>
            <category><![CDATA[system-availability]]></category>
            <category><![CDATA[database-architecture]]></category>
            <dc:creator><![CDATA[OceanBase]]></dc:creator>
            <pubDate>Wed, 22 Jul 2026 08:26:36 GMT</pubDate>
            <atom:updated>2026-07-22T08:26:36.104Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZcZYMAEnmB8AY1mVtN2oug.png" /></figure><p>For many enterprises, database scaling is not just a performance problem. It is an architectural continuity problem.</p><p>OceanBase addresses this with an integrated standalone-distributed architecture. Businesses can start with a small deployment that behaves much like a standalone database, then scale out to a distributed system as they grow. This helps reduce repeated migrations, sharding complexity, and the operational burden of maintaining multiple database systems.</p><h3>Database Scaling Often Arrives Earlier Than Expected</h3><p>Many companies start with MySQL. It is simple, open source, mature, and familiar to most engineering teams. For early-stage businesses, a standalone MySQL database is often enough.</p><p>As the business grows, database pressure builds quickly. Order volume increases, tables grow, and queries slow down. Teams often add read-write splitting, caching, and eventually sharding. Each step solves an immediate problem, but also adds application changes, migration risk, and operational complexity.</p><p>That is why many CTOs eventually ask: Why should every new stage of business growth require another painful database rebuild?</p><p>The challenge is not only how to scale, but how to scale without repeatedly changing the database architecture.</p><h3>Existing Scaling Paths Still Involve Trade-offs</h3><p>Traditional database scaling usually follows one of two paths:</p><ul><li><strong>Open-source path:</strong> MySQL standalone → MySQL sharding → NewSQL distributed database</li><li><strong>Commercial path:</strong> Oracle standalone → Oracle RAC → NewSQL distributed database</li></ul><p>Both paths can solve problems at certain stages, but they also introduce long-term challenges.</p><p>Standalone databases and shared-storage clusters have scaling limits. Hardware upgrades can relieve pressure, but they do not truly provide linear scale-out for massive data volumes and high concurrency.</p><p>Sharding breaks through the capacity limit of a single machine, but it pushes complexity to applications and operations. Cross-shard queries, distributed transactions, data migration, scaling, and failure handling all become more difficult.</p><p>Cloud-native databases improve elasticity and high availability. However, in many primary-replica architectures, write throughput may still be limited by the primary node.</p><p>NewSQL databases provide horizontal scalability, but they may also involve trade-offs in small-scale cost, standalone performance, operational complexity, and ecosystem maturity.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fU4GFKk2W9Z40JX-oLKqdA.png" /></figure><p>Enterprises do not need another architectural bet. They need a database path that can handle current workloads without limiting future scale-out.</p><h3>OceanBase’s Approach: One Architecture for Standalone and Distributed Deployment</h3><p>OceanBase’s answer is an integrated standalone-distributed approach — one architecture that supports both standalone and distributed deployment. This capability was introduced in OceanBase 4.0 and has since become the foundation of the product’s scaling model.</p><p>The idea is simple: Start small, scale big.</p><p>In the early stage, OceanBase can run as a small standalone deployment, supporting business workloads at a lower cost while keeping performance and operations close to those of a traditional standalone database.</p><p>As the business grows, the same OceanBase system can scale out into a distributed cluster to support larger data volumes, higher concurrency, and stronger high availability.</p><p>The key point is that the deployment model can change without requiring a different database architecture. Teams can start small and scale out as needed within the same system.</p><p>One of the core technologies behind this capability is <strong>dynamic log stream</strong>.</p><h4>Dynamic Log Stream: Combining Standalone Performance with Distributed Capability</h4><p>A key part of this architecture is the dynamic log stream mechanism.</p><p>In many distributed database designs, data is divided into shards. As the number of shards increases, the system may need to manage more log streams. This can make distributed overhead grow with the number of shards, even when the actual deployment size remains small.</p><p>The scaling path may look like this:</p><pre>More data<br>  → More shards<br>  → More log streams<br>  → Higher distributed overhead</pre><p>OceanBase takes a different approach: log streams scale mainly with the number of nodes, rather than simply with the number of shards. As a result, distributed overhead is more closely related to deployment scale, instead of growing directly with the number of data shards.</p><p>In a single-tenant scenario, this can be illustrated as follows:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2Z0QIvfowCjtDskI-eetMQ.png" /></figure><p>Note: The table above is based on a single-tenant scenario. In multi-tenant scenarios, the total number of log streams is also affected by the number of tenants and resource distribution.</p><p>This design brings three key benefits:</p><ol><li>Flexible partition placement: Data partitions can be dynamically bound to different log streams, supporting flexible migration.</li><li>Lightweight standalone deployment: In standalone deployment, there is only one log stream, and the transaction processing path is similar to that of a classic standalone database.</li><li>More controllable scale-out: When the system scales horizontally, log streams increase mainly with the number of nodes, keeping distributed overhead more controllable.</li></ol><p>This is what allows OceanBase to stay lightweight in small deployments while preserving a path to large-scale distributed expansion.</p><h3>Optimizing for the Common Path</h3><p>OceanBase is also designed around a practical observation: in many business systems, most database operations are local to a single user, account, order, or tenant. Only a smaller portion requires cross-node coordination, such as cross-account transactions or global analytics.</p><p>Based on this observation, OceanBase optimizes for the common path:</p><ul><li>For common single-node operations, OceanBase minimizes unnecessary distributed overhead so that performance remains close to standalone databases.</li><li>For cross-node operations, OceanBase uses mechanisms such as two-phase commit, parallel execution, and asynchronous processing to improve execution efficiency.</li></ul><p>This helps OceanBase keep common operations efficient while still supporting distributed execution when needed.</p><h3>Business Value and Best-Fit Scenarios</h3><p>For enterprises, OceanBase’s integrated standalone-distributed architecture delivers value beyond raw performance — it lowers long-term architecture cost and reduces evolution risk.</p><p>In practice, this means:</p><ul><li>Lower total cost of ownership through compression, automatic load balancing, automatic failover, and multi-tenant isolation.</li><li>A smoother scale-out path from small deployments to large distributed clusters.</li><li>High availability for critical workloads, supported by Paxos-based three-replica strong synchronization, RPO = 0, and fast failover.</li><li>Fewer systems to maintain by supporting OLTP, real-time OLAP, Key-Value, JSON, and GIS use cases in one database.</li></ul><p>This makes OceanBase especially relevant for startups, fast-growing companies, large enterprises, and financial institutions that need to scale without repeated migrations, manual sharding, or deep cloud lock-in.</p><h3>Adoption Path: Start with a Small Validation</h3><p>Enterprises do not need to start with a large distributed deployment. A gradual adoption path is often more practical:</p><ol><li>Standalone validation: Start with a non-critical workload and test SQL compatibility, performance, and operations.</li><li>Small distributed deployment: Deploy a three-node cluster and validate high availability, failover, backup and recovery, and monitoring.</li><li>Scale on demand: Expand gradually as workloads grow and promote best practices across more systems.</li></ol><p>This lets teams validate, deploy, and scale within the same database system.</p><p>Database selection should not force enterprises to rebuild their architecture at every stage. It should provide a foundation that evolves with the business.</p><p>That is the goal of OceanBase’s standalone-distributed architecture:</p><p>Start small, scale big — without rebuilding the database architecture at every stage.</p><h3>Further Reading</h3><ul><li><a href="https://en.oceanbase.com/docs/common-oceanbase-database-10000000003453499">OceanBase log streams</a></li><li><a href="https://en.oceanbase.com/docs/common-oceanbase-database-10000000003450101">OceanBase Database architecture</a></li><li><a href="https://en.oceanbase.com/docs">OceanBase Database Documentation</a></li></ul><p><em>Author:Kun Wang</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1b3d63cdb0fd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oceanbase-database/start-small-scale-big-inside-oceanbases-distributed-architecture-1b3d63cdb0fd">Start Small, Scale Big: Inside OceanBase’s Distributed Architecture</a> was originally published in <a href="https://medium.com/oceanbase-database">OceanBase Database</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[OceanBase DataStudio: From Stitched Pipelines to Unified AI Data Production]]></title>
            <link>https://medium.com/oceanbase-database/oceanbase-datastudio-from-stitched-pipelines-to-unified-ai-data-production-74bc24f8d767?source=rss----617ed9842a21---4</link>
            <guid isPermaLink="false">https://medium.com/p/74bc24f8d767</guid>
            <category><![CDATA[hybrid-search]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[multi-model]]></category>
            <dc:creator><![CDATA[OceanBase]]></dc:creator>
            <pubDate>Tue, 21 Jul 2026 09:26:17 GMT</pubDate>
            <atom:updated>2026-07-21T09:26:17.156Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4OJbFVAFtxE_w8fijmmA9Q.png" /></figure><h3>A Request Every ML Data Engineer Knows</h3><p>“Filter me a batch of data: token count under 1000, non-QA, social science category, not synthetic.”</p><p>One sentence. Two days to deliver.</p><p>The delay isn’t in writing SQL — it’s in the data stack underneath. Each feature (token count, QA flag, synthetic flag) lives in a different table, computed by a different UDF, with unclear definitions and unverified logic. You explore value ranges one by one, stitch together a long error-prone query, run it, and then verify the output.</p><p>The root cause: storage, computation, feature management, data governance, and data serving are split across multiple systems. Data moves between them. Consistency and traceability ultimately depend on people.</p><ul><li><strong>Storage</strong> uses file formats in a data lake — adding a feature column means copying data, repeated joins, full table rewrites.</li><li><strong>Features</strong> scatter across UDFs in various pipeline components — filtering and computation are tangled, lineage is unclear, new data arrives with empty feature columns requiring manual backfill.</li><li><strong>Filtering</strong> is funnel-shaped — one UDF scoring stage feeds the next, no cross-feature analysis, no visibility into feature distributions for free combination.</li><li><strong>Filtered subsets</strong> don’t record their logic — not reproducible, not auditable, not shareable.</li></ul><p>Each problem is patchable individually. The structural issue is that the entire pipeline is stitched together from separate systems.</p><h3>What OceanBase DataStudio Is</h3><p>OceanBase DataStudio is a data production, governance, and serving workbench running on top of OceanBase Lakebase. It doesn’t build another storage or compute system — it organizes the full chain of “data comes in, gets processed, gets governed, gets served, gets monitored” into one operational workflow.</p><p>OceanBase Lakebase provides the foundation: structured, semi-structured, unstructured, and vector data managed under a unified architecture. Database transactions, consistency, and real-time serving combine with the open storage and open compute of a data lake. Scalar, full-text, and vector search run on the same data foundation.</p><p>OceanBase DataStudio productizes these capabilities into a workbench that data teams can use directly: data ingestion, data processing, task orchestration, semantic modeling, quality governance, permission management, lineage analysis, dataset publishing, and data services — all in one pipeline.</p><p>Within the OceanBase AI Database product family, Lakebase is the core engine, DataStudio is the data development and governance layer, and OceanBase DataPilot is the business-facing data intelligence agent. DataStudio sits in the middle: Lakebase provides the data foundation; DataStudio makes data manageable and serviceable; DataPilot helps users consume data intelligence directly.</p><h3>Wide-Table Storage: Add a Column, Not a Pipeline</h3><p>A single data record — from raw file to trainable data to derived features — hangs on one wide table, linked by UUID. Large objects like images and video go into Volumes; the table stores only paths.</p><p>Configured as columnar storage, this brings two direct benefits: adding a new feature is just adding a column — no data copying, no repeated joins. Adding or removing feature columns doesn’t trigger full table rewrites. Frequent feature column changes become lightweight operations.</p><p>Because the foundation is OceanBase, it inherits database capabilities natively: row locks, row-level UPSERT/MERGE INTO by UUID, strong consistency. OceanBase also supports hybrid retrieval — scalar, full-text, and vector search in one query. Training data scenarios frequently need vector recall combined with structured filtering, which is exactly this.</p><p>Two additional capabilities come from the base layer:</p><p><strong>AI columns</strong> function as real-time computed columns on the table. When data is written, model computations like embedding and tagging fire automatically, with results written back to the table. The critical property is transactional consistency: a batch of audio files either all completes embedding and tagging, or all fails and rolls back. No dirty half-computed state — the exact thing that makes feature backfill painful.</p><p><strong>Fork Database</strong> creates a complete database copy in seconds, like pulling a Git branch. Under the hood, Copy-on-Write means only incremental space is consumed. You can experiment freely with feature processing logic and filtering conditions on the branch. If it works, MERGE back to main. If it doesn’t, discard — near-zero cost. Training data work is inherently iterative; this capability lets you experiment aggressively.</p><h3>Daft on Ray for Multimodal Processing</h3><p>Feature production frequently handles images and audio — work that calls models. Traditional offline engines like Spark face two problems here: each batch reloads models (expensive), and CPU and GPU can’t be fed simultaneously (wasteful).</p><p>OceanBase DataStudio uses Daft on Ray as its multimodal computation engine. Ray’s Actor model lets models load once and reuse across batches. Each operator is dynamically scheduled by micro-partition, stringing CPU and GPU processing into a pipeline. Large-scale multimodal feature backfill and processing accelerate on these two points.</p><p>Building a feature platform on top becomes simpler — not because DataStudio is a feature platform (it isn’t), but because it provides the foundational capabilities that a feature platform needs.</p><h3>Building a Feature Platform on Top</h3><p>OceanBase DataStudio doesn’t directly provide feature registration or backfill. What it does is prepare the foundation — making it far simpler to build training data production capabilities on top than assembling from scratch.</p><p>Consider what a feature platform typically needs:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SzkxwcBJOYIQx4-EOD_sZQ.png" /></figure><p>These capabilities are straightforward to build because storage, computation, and hybrid search are already provided by DataStudio. Going back to the opening request: with features registered, distributions visible, cross-filtering available, and results traceable — “token count under 1000, non-QA, social science, not synthetic” becomes a single SQL query.</p><p>The complete chain looks like this: raw data enters (images, audio/video, logs batch-imported to the wide table, large objects to Volumes) → processing runs (Daft on Ray orchestrates splitting, frame extraction, embedding, tagging — AI columns auto-supplement on write) → registration (each feature’s logic, type, source columns recorded, lineage auto-extracted) → filtering (cross-conditions run on the wide table, generating subsets with recorded logic) → publishing (subsets delivered as reproducible, auditable, shareable datasets for downstream training).</p><p>The “two-day” request becomes a single traceable SQL query.</p><h3>How It Differs from Stitched Approaches</h3><p>AI training data production already has established tools: Feature Store for features, open table formats for lake data, Spark/Ray/Daft for compute, vector databases and search engines for recall. Each has value individually. But when an enterprise stitches them together, complexity compounds: one system for storage, one for compute, one for feature management, one for search, one for governance. Data moves between every layer. Permissions need alignment. Lineage needs patching. Failures need retries. Consistency needs reconciliation.</p><p>OceanBase DataStudio’s differentiation comes from OceanBase Lakebase’s unified architecture — the core pipeline of AI data production sits on one foundation.</p><h4>Compared to Feature Store Products (Tecton / Feast / Hopsworks)</h4><p>These products specialize in feature management — but they’re feature-layer middleware. They don’t manage underlying multimodal storage or compute. Using Tecton, you still need to configure storage and Spark/Ray underneath, then wire them together.</p><p>With OceanBase DataStudio, storage (wide table, columnar, Volumes), computation (Daft on Ray), hybrid search, and row-level updates are built in. Building a feature platform is simpler, more usable, and doesn’t require repeatedly moving data between the feature layer and storage or reconciling consistency.</p><h4>Compared to Open Lakehouse Formats (Lance / LanceDB / Databricks)</h4><p>Lance is an AI-native open lakehouse format — strong for AI training data and vector retrieval. But its foundation is a file format on object storage: append-biased, with weak row-level updates and transaction capabilities. The most common operation in training data backfill — “update one column of one row by UUID” — often means rewriting a file. On a database foundation, it’s a standard row-level UPDATE.</p><p>Databricks is a mature lakehouse platform, but its foundation is similarly file format plus Spark, with transactions and updates handled through table-format semantics.</p><p>OceanBase DataStudio uses a database as the foundation: row locks, UPSERT/MERGE, strong consistency, add-column-on-demand, and native hybrid search are all built in. This is the value of a database over a pure lake — database capabilities where they matter.</p><h4>Compared to Compute Engines (Spark / Ray Data / Daft)</h4><p>Many platforms still push multimodal processing onto Spark, where model loading is expensive and CPU/GPU utilization stays low. OceanBase DataStudio chose Daft on Ray — a technical path better suited for multimodal workloads (Daft has also shown faster performance than Spark on official TPC-H benchmarks, though this is vendor-reported and should be verified independently) — and integrated it into the platform’s development and scheduling workflow, rather than requiring users to set up their own Ray cluster.</p><h3>Beyond Training Data</h3><p>AI training data production is one scenario. The underlying foundation — combining the lake’s multimodal capabilities with the database’s transaction and retrieval capabilities — applies equally to any business where structured and unstructured data converge with strong transaction requirements and frequent updates.</p><p><strong>Autonomous driving</strong> generates daily volumes of video, images, sensor data, and GPS traces. Teams need to find edge cases — extreme weather, unusual road layouts, collision risks — across massive driving datasets. Data needs splitting, frame extraction, scene recognition, and vectorization, then combined with geographic location, time, vehicle model, and scene tags for hybrid search. This requires not point tools but a unified foundation for managing and processing multimodal data.</p><p><strong>Securities industry</strong> has structured data (market quotes, trades, financials, customer records) alongside unstructured data (research reports, disclosures, policy documents, news sentiment). Real business value comes from combining both — research report parsing, compliance Q&amp;A, investment knowledge retrieval all need structured business data and unstructured text in one data service system.</p><p>As agents become data consumers, this becomes even more critical. Agents need not just a one-time query result but continuous, trustworthy, traceable context — access to business data, documents, vectors, state, memory, and execution records, within permission and governance boundaries.</p><p>This is the combined value of DataStudio and Lakebase. Lakebase provides the lakebase-integrated data foundation. DataStudio organizes data production, governance, and service workflows. The former solves where data lives and how it’s unified and computed; the latter solves how data is produced, governed, delivered, and reused.</p><h3>The Architecture Shift</h3><p>Compressing a training data filtering request from two days to a single traceable SQL query doesn’t come from any single feature. It comes from a change in the underlying data architecture.</p><p>In the past, data scattered across multiple systems — moved by people, stitched by scripts, backed by experience. In the AI era, this approach can no longer support the high-frequency calls from models and agents.</p><p>OceanBase DataStudio puts data ingestion, processing, governance, filtering, tracing, and serving into one pipeline. OceanBase Lakebase makes that pipeline run on a data foundation with multimodal capabilities, hybrid search, transactional consistency, and open compute.</p><p>Training data production is just the first typical scenario. More broadly, for AI applications to truly enter production systems, enterprises must first manage, organize, and serve their data well. That’s the problem OceanBase AI Database is built to solve — not adding a few AI features to a database, but making enterprise data a production-grade asset that models and agents can continuously understand, retrieve, and call.</p><p>To learn more about how OceanBase DataStudio fits into your AI data pipeline, explore the <a href="https://www.oceanbase.com/docs">OceanBase AI Database documentation</a>.</p><p><em>Author:Mingqiang Zhuang</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=74bc24f8d767" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oceanbase-database/oceanbase-datastudio-from-stitched-pipelines-to-unified-ai-data-production-74bc24f8d767">OceanBase DataStudio: From Stitched Pipelines to Unified AI Data Production</a> was originally published in <a href="https://medium.com/oceanbase-database">OceanBase Database</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Multimodel Tables: One Table for Every Modality Your Agent Needs]]></title>
            <link>https://medium.com/oceanbase-database/multimodel-tables-one-table-for-every-modality-your-agent-needs-bb91d2372ae2?source=rss----617ed9842a21---4</link>
            <guid isPermaLink="false">https://medium.com/p/bb91d2372ae2</guid>
            <category><![CDATA[hybrid-search]]></category>
            <category><![CDATA[multi-model]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[OceanBase]]></dc:creator>
            <pubDate>Thu, 16 Jul 2026 08:17:53 GMT</pubDate>
            <atom:updated>2026-07-16T08:17:53.403Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*m5sq-2jO2WijauA5jUX0Qg.png" /></figure><p>For years, OceanBase has evolved toward a unified database — supporting an increasingly broad range of workloads and data, from distributed transaction processing for mission-critical systems to HTAP, multi-model data, and hybrid search.</p><p>OceanBase Lakebase marks a deeper shift. The evolution is no longer just about what the database can process, but also about who it serves. Traditionally, databases were designed for developers, DBAs, and applications. In the AI era, they must also serve a fundamentally new kind of user: the agent.</p><p>This is what defines an AI database. It is not simply a database that supports images, PDFs, or vectors. It is a database designed to provide agents with the complete, timely, and trustworthy context they need to reason and act.</p><p>That leads to the first major challenge: the agent’s data dilemma.</p><h3>The Agent’s Data Problem</h3><p>When an agent handles a single decision, it may need five things at once: user profiles (structured), conversation summaries (text), PDF originals from a knowledge base, semantic results from vector recall, and live business state.</p><p>Today, those five things live in five systems — object storage, search engines, vector databases, business databases, and offline warehouses. No unified transaction. No consistent snapshot. No shared lineage.</p><p>When a PDF gets updated but its embedding still points to the old version, the agent will answer confidently — and wrong. And you won’t know it’s wrong.</p><p>This isn’t a “store more data types” problem. It’s a governance problem: when multimodel data enters the critical path, someone has to guarantee version consistency, computation completeness, traceability, and trust. Today, that “someone” is a pipeline your team owns, debugs, and rewrites every quarter.</p><p>The multimodel table is OceanBase’s answer. It is the core data management capability inside OceanBase Lakebase, and it manages multimodel data — images, audio/video, PDFs, web snapshots, vectors, JSON, and structured fields — as first-class database objects, under one system that provides transactions, consistency, high availability, hybrid search, analytical computation, and online serving.</p><p>The rest of this post walks through why agent workloads demand this, and how the multimodel table delivers it.</p><h3>Why Agents Demand a New Data Model</h3><p>Agent-facing business objects are inherently multimodel. Inputs might be natural language, images, PDFs, web pages, tables, or business context. At runtime, an agent depends on user memory, knowledge bases, RAG results, structured business data, semantic profiles, and model inference intermediates.</p><p>Four shifts follow from this:</p><ol><li><strong>Unstructured data enters the critical path.</strong> It is no longer an attachment sitting in object storage — it is a key input to the agent’s decision.</li><li><strong>Access becomes hybrid search.</strong> A single request may combine structured filters, full-text retrieval, vector recall, and analytical aggregation.</li><li><strong>Real-time requirements spike.</strong> Agents run 24/7. T+1 reporting can’t keep up.</li><li><strong>Features are dynamically generated.</strong> Many fields aren’t written directly — they’re extracted asynchronously by models from raw multimodel data.</li></ol><p>So the real question is: how do you unify raw multimodel data, structured fields, dynamically derived features, and async computation results inside one database — and make them jointly serve online transactions, analytics, and hybrid search, without giving up consistency or visibility?</p><p>That is the design problem the multimodel table solves.</p><h3>Core Capabilities</h3><h4>Unified Management of Multimodel Objects</h4><p>Multimodel tables bring multimodel data under the database’s transaction and version management system. Large objects — images, audio/video, PDFs, web snapshots — support three storage modes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Yf0ryEaNK4Tk0EELbUhN9A.png" /></figure><p>Where the object physically sits matters less than what the database guarantees about it: a stable identifier, an access address, a version, a visibility state, and a transaction boundary.</p><p>This is what ensures a raw object and its derived features — summaries, labels, embeddings, risk scores — always correspond to the same data version. The “object updated, features still pointing to old content” bug simply cannot happen.</p><h4>Dynamic Feature Columns</h4><p>Multimodel data is rich-modal: the same raw object can yield an open-ended set of semantic, structural, quality, and business features. Text produces topics, summaries, embeddings, safety labels, language types, and quality scores. Images accumulate OCR results, tags, risk scores, and business features. The list grows with every new model.</p><p>Under a traditional schema, every new feature requires a DDL. Every DDL triggers cache invalidation, write amplification, and background compaction pressure. Feature velocity dies under table-lock latency.</p><p>Multimodel tables use a lightweight dynamic column mechanism. Feature extension needs no schema change — while queries stay SQL-native, analytical optimization still applies, and hybrid search still hits an index.</p><p>This isn’t a fallback to key-value. Key-value is flexible but blind to SQL analysis and search optimization. The multimodel table makes an explicit engineering trade-off between structured optimizability and dynamic extensibility, and refuses to give up either one.</p><h4>Async Near-Real-Time Computation</h4><p>Many columns in a multimodel table aren’t written by users. They’re generated by computation tasks — embeddings, summaries, OCR, quality scores, full-text indexes, vector indexes — powered by built-in model capabilities, background jobs, or external pipelines.</p><p>Model inference typically takes hundreds of milliseconds to seconds. That is too slow to block an online write. So the multimodel table doesn’t.</p><ol><li>Raw data commits first. Online write latency stays intact.</li><li>Background tasks fire feature extraction, index construction, and backfill based on lineage.</li><li>Derived data becomes visible within a near-real-time window.</li><li>Reads always land on a consistent snapshot.</li></ol><p>The design judgment here is direct: strong synchronization across every derived column is impractical and unnecessary. The right trade-off is a controllable balance between latency, throughput, storage efficiency, and consistency. Computation tasks generate the values. The multimodel table makes those values governable, searchable, analyzable, and consistently readable.</p><h4>Column-Group Consistency</h4><p>Async computation creates a new visibility problem. Once a row is written, feature A, feature B, embeddings, full-text indexes, and quality labels may finish at different times, from different tasks, using different models.</p><p>A query that sees feature B done but feature A pending will silently produce wrong results.</p><p>Column-group consistency fixes this at the storage layer. A business column group only forms a new visible snapshot once every related derived column has completed. Queries and hybrid search always read a consistency snapshot. They never see half-finished data.</p><h4>Storage-Compute Separation with Hot-Cold Integration</h4><p>Multimodel data grows without a ceiling — documents, images, video, vectors, derived features. Keeping everything as hot online data is not viable at scale.</p><p>Multimodel tables sit on a disaggregated storage-compute architecture with shared storage, and treat hot and cold as one continuum:</p><ul><li><strong>Recent data (e.g., within 90 days)</strong> stays cached on SSD for low-latency access.</li><li><strong>Historical data (e.g., beyond 90 days)</strong> settles to low-cost shared storage — still queryable, searchable, and analyzable through the same interface.</li></ul><p>Users never switch systems to hit cold data. They never stitch between an online database, object storage, and an offline warehouse to answer one question. One view, one query surface, one governance model.</p><h4>Lineage and Unified Catalog</h4><p>Which text segment generated that embedding? Which audit model produced that safety label? Which PDF version does that summary correspond to?</p><p>Without lineage, the system cannot decide whether a piece of data is complete, trustworthy, or ready to serve. And without that decision, agents ship wrong answers.</p><p>Lineage and the Unified Catalog are the metadata backbone of the multimodel table. They record the relationships between raw objects, structured fields, dynamic feature columns, model tasks, versions, and permissions. This metadata powers three things:</p><ol><li><strong>Triggering.</strong> Background tasks fire feature extraction, index construction, and backfill automatically based on lineage.</li><li><strong>Completeness.</strong> The system decides whether a column group or snapshot is fully computed before advancing visibility.</li><li><strong>Traceability.</strong> When an agent produces an answer, you can trace it back to the raw documents, images, records, and derived features it relied on.</li></ol><h4>Unified Access: Transactions, Analytics, and Hybrid Search</h4><p>A multimodel table is not a storage structure. It is the shared foundation for three workload types on the same data:</p><ul><li><strong>Online transactions:</strong> business writes, ACID, high availability.</li><li><strong>Analytics:</strong> large-scale scans, aggregations, filters, joins, feature analysis.</li><li><strong>Hybrid search:</strong> structured filters + full-text retrieval + vector recall + tag filtering + business ranking.</li></ul><p>Agent access patterns are inherently multi-step. A single request may filter by structured conditions, then search descriptions by full-text, then find similar content by vector recall, then rank by tags, quality, time, and permissions. No single specialized engine covers all four.</p><p>The core trade-off is near-real-time over strong synchronization. Search and analytics don’t need derived features to complete inside the write transaction — but they do need to become visible within a short, bounded window, and they need to read a consistent snapshot when they do. That is exactly what the multimodel table delivers, and it is what lets one table serve online writes, hybrid retrieval, and analytics without the three-copy stitching tax.</p><h3>What This Eliminates</h3><p>If you’re building an agent today, the multimodel table replaces the following stack:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wHktD6_3F5I-OSMhmbu9DA.png" /></figure><p>The old trade-off between multimodel breadth and database-grade governance is gone.</p><h3>Where Multimodel Tables Help</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jiXPAFmAKHBWmk7vm1nrrA.png" /></figure><h3>Why This Matters</h3><p>The problem multimodel tables solve isn’t whether an AI database can store images, PDFs, or vectors. It’s what happens when agents become a first-class user of the database.</p><p>If the answer is “another isolated system per data type,” you get more surface area to secure, more pipelines to break, and more silent data drift. If the answer is “one governed table that treats every modality as a first-class object,” you get an actual data foundation — not a scaffolding of pipelines pretending to be one.</p><p>Multimodel tables are that answer. They unify structured data, unstructured data, AI-derived features, and business semantics under one transaction, governance, and computation system. In the past, databases unified data. In the AI era, databases need to unify data, semantics, and the operations that produce them. Multimodel tables are the first step OceanBase Lakebase takes toward that goal.</p><h3>How to Get Started</h3><p>Multimodel tables ship as part of OceanBase Lakebase. To evaluate them on your own agent workload:</p><ol><li>Visit the <a href="https://en.oceanbase.com/solution/ai">OceanBase AI Database page</a> for the full Lakebase overview and capability details.</li><li>Fill out the contact form on the same page with a short note about your workload — the data types you need to manage, the agent scenario you’re building, and any performance or governance requirements you already have in mind.</li><li>Our team will reach out to walk you through a preview environment, help you model your first multimodel table, and compare it against the stack you’re replacing.</li></ol><p>If it helps the agent stop shipping wrong answers, it helped.</p><p><em>Author:Yi Zhang</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bb91d2372ae2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oceanbase-database/multimodel-tables-one-table-for-every-modality-your-agent-needs-bb91d2372ae2">Multimodel Tables: One Table for Every Modality Your Agent Needs</a> was originally published in <a href="https://medium.com/oceanbase-database">OceanBase Database</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[OceanBase Lakebase: A Unified Data Foundation for AI-Native Applications]]></title>
            <link>https://medium.com/oceanbase-database/oceanbase-lakebase-a-unified-data-foundation-for-ai-native-applications-e22d5ee9fab5?source=rss----617ed9842a21---4</link>
            <guid isPermaLink="false">https://medium.com/p/e22d5ee9fab5</guid>
            <category><![CDATA[distributed-database]]></category>
            <category><![CDATA[cloud-database]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[OceanBase]]></dc:creator>
            <pubDate>Thu, 09 Jul 2026 11:38:32 GMT</pubDate>
            <atom:updated>2026-07-09T11:38:32.833Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TtshuhlOjnVrFd7doGDYuw.png" /></figure><h3>Enterprises Have Data. AI Needs Context.</h3><p>Enterprise data systems were built around clear boundaries. Databases handled transactions. Data warehouses handled analytics. Data lakes stored large-scale raw data. Search engines indexed documents. Vector databases powered semantic retrieval.</p><p>That separation worked when applications were mostly deterministic and data was mostly structured. AI-native applications behave differently.</p><p>An AI application does not only read rows from a database. It may need a customer profile alongside images, audio and video recordings, PDFs, web snapshots, vector embeddings, and JSON documents — often for the same business entity. An agent may also need persistent memory, session context, business state, execution history, and a safe place to test changes before acting.</p><p>In many enterprises, these data assets already exist. The problem is that they live across different systems, with different metadata, access controls, freshness guarantees, and processing pipelines. The result is a fragmented data stack that makes AI applications harder to build, harder to govern, and harder to run in production.</p><p>This is the problem OceanBase Lakebase is designed to address.</p><h3>What Lakebase Is</h3><p>Lakebase is the core data engine of OceanBase AI Database. It is designed to bring multimodal data management, online serving, real-time analytics, hybrid search, and open compute into one architecture.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*h7N4Nf97WSh9Pctk.png" /></figure><p>It is not a separate data lake. It is not a traditional database with a few AI features added on top. It is an attempt to rethink how enterprise data should be stored, managed, searched, processed, and served when AI-native applications become part of production systems.</p><p>The core idea is simple: structured business data and multimodal data should be managed under one data foundation, with consistent metadata, permissions, lifecycle management, and query access.</p><p>For AI applications, this matters because context is not stored in one format. A complete business fact may include a relational record, a document, an image, a transcript, a JSON object, a vector embedding, and model-generated labels. Lakebase allows these different forms of data to be managed and used together, instead of forcing teams to stitch together multiple systems for every AI workflow.</p><h3>Multimodal Data in One Table Semantics</h3><p>A key design in Lakebase is the multimodal table.</p><p>In a traditional database, a table usually represents structured fields: IDs, timestamps, amounts, statuses, and other typed columns. In Lakebase, a table can also describe richer business entities that include documents, images, audio, video, JSON, large objects, vectors, and model-generated results.</p><p>This does not mean every object must be physically stored in the same way. Different data types may use different storage layouts depending on size, access pattern, and cost. But from the user’s perspective, they can be managed under one table model, one metadata system, and one governance framework.</p><p>This gives AI-native applications a more natural data model. A customer service case, for example, can include structured ticket fields, chat history, call recordings, uploaded images, diagnostic logs, and embeddings. A logistics record can include order metadata, route events, driver notes, proof-of-delivery images, and semantic features. These are not separate pieces of data from the business perspective. They are different representations of the same entity.</p><p>Lakebase makes that entity easier to store, search, govern, and process as a whole.</p><h3>AI Columns: Bringing Model Results into the Data Pipeline</h3><p>Lakebase also introduces the idea of AI columns.</p><p>AI columns allow model-generated outputs such as embeddings, summaries, labels, categories, or extracted features to be materialized as columns in the data system. Instead of moving data out to an external pipeline, generating semantic results, and writing them back manually, teams can bring model processing closer to the data.</p><p>This is useful for several reasons.</p><p>First, it shortens the data processing chain. The fewer systems involved, the fewer places where data freshness, schema mapping, and error handling can break.</p><p>Second, it makes AI-generated results easier to govern. Embeddings and labels are no longer hidden artifacts in a separate pipeline. They become part of the managed data asset.</p><p>Third, it supports more reliable retry and consistency mechanisms. In production AI workflows, embedding generation, summarization, and feature extraction may fail, need retries, or need to be regenerated when source data changes. Treating these outputs as managed columns gives teams a clearer operational model.</p><h3>Hybrid Search Built into the Data Foundation</h3><p>AI applications need search, but not just one kind of search.</p><p>Keyword search is still important when users know the terms they are looking for. Vector search is useful when semantic similarity matters. Structured filtering is necessary when business rules, permissions, time ranges, product categories, or customer segments must be respected.</p><p>In many AI stacks, these capabilities are split across different systems: a transactional database, a search engine, a vector database, and a data pipeline to keep them in sync. That architecture works for prototypes, but it becomes difficult to operate when the application needs fresh data, consistent permissions, and production reliability.</p><p>Lakebase brings structured filtering, full-text search, and vector search into one query path. This allows AI applications to retrieve AI-ready context from fresh operational and multimodal data without relying on multiple external indexes that may drift from the source data.</p><p>For agents, this is especially important. A stale search result is not just a bad answer. If an agent uses stale context to make a decision or trigger an action, it can become a production risk.</p><h3>Built for Agent Workloads</h3><p>Agents change the way databases are used.</p><p>A traditional application usually follows predefined workflows. An agent may read, write, search, plan, test, modify state, generate intermediate results, and call tools repeatedly. It may also run concurrently with many other agents, each with its own memory, context, permissions, and execution history.</p><p>Lakebase is designed to support this kind of workload.</p><p>It provides a foundation for storing and searching agent memory, session context, business state, and execution records. It also supports isolated data environments through database branching and sandboxing, so agents can test changes without directly impacting production data.</p><p>For large numbers of AI-generated applications or lightweight agents, Lakebase also supports finer-grained data isolation patterns. This is useful when each application needs its own schema and SQL capabilities, but the data volume per application is small. Instead of creating a large number of physical databases or tables with high metadata overhead, the system can provide logical isolation on shared infrastructure.</p><p>The goal is not only to help agents retrieve data. It is to help agents operate safely, repeatably, and at scale.</p><h3>Open Storage and Open Compute</h3><p>AI-native workloads will not run inside one engine only.</p><p>SQL remains essential for transactional and analytical workloads. Spark is widely used for large-scale data processing. Ray and related frameworks are increasingly used for AI data processing and distributed model workloads. Enterprises also need to preserve existing investments in object storage, open table formats, and data lake infrastructure.</p><p>Lakebase is built with this reality in mind.</p><p>It supports S3-compatible object storage and open table formats such as Iceberg, while allowing compute engines such as SQL, Spark, and Ray to work on shared data and metadata. This reduces the need to copy data between systems or rebuild a separate data foundation for every new engine.</p><p>Open formats are valuable because they reduce lock-in and improve interoperability. But open formats alone do not provide the full serving, consistency, search, governance, and agent-oriented capabilities required by production AI applications. Lakebase is designed to combine openness with database-grade management and real-time access.</p><h3>How Lakebase Fits into OceanBase AI Database</h3><p>OceanBase AI Database includes three major product layers.</p><p>Lakebase is the core engine. It manages multimodal data, hybrid search, open storage, open compute, real-time serving, and agent-ready data environments.</p><p>DataStudio is the data production, governance, and service workbench built on top of Lakebase. It helps teams ingest, process, govern, model, and serve data so that enterprise data assets become usable by applications, agents, and business users.</p><p>DataPilot is the business-facing data intelligence agent. It allows business users to interact with trusted enterprise data through natural language, generate analysis, ask follow-up questions, and turn data into reusable business insight.</p><p>Together, these products form the OceanBase AI Database system: Lakebase provides the data foundation, DataStudio makes data manageable and serviceable, and DataPilot helps users consume data intelligence directly.</p><h3>Two Deployment Paths</h3><p>Enterprise customers rarely start from a blank slate. Many already operate databases, data warehouses, data lakes, object storage, and analytics platforms. Lakebase is designed to support both new AI-native workloads and existing data environments.</p><p>For new AI applications, Lakebase can be deployed as a standalone data foundation. This is suitable when a team wants to build a new multimodal data platform from the ground up, with storage, search, processing, and serving capabilities in one architecture.</p><p>For existing environments, Lakebase can also connect with current data lakes, object storage, and databases. In this path, customers can add multimodal processing, hybrid search, AI columns, and agent-ready data services without moving all data into a new system first.</p><p>This matters because AI adoption should not require enterprises to discard years of data infrastructure investment. The better path is to make existing data more usable for AI while providing a cleaner foundation for new workloads.</p><h3>Where Lakebase Helps</h3><p>Lakebase is useful in scenarios where structured data and multimodal data need to be processed together.</p><p>In intelligent customer service, an agent may need to combine account data, order history, policy documents, chat logs, call transcripts, and uploaded images to answer accurately and take the right action.</p><p>In financial services, analysts and AI applications may need to connect market data, transaction data, research reports, announcements, compliance documents, and semantic search results under one governed system.</p><p>In autonomous driving and robotics, teams may need to manage large volumes of video, image, sensor, and metadata records, then search for specific events, generate training samples, and feed downstream model pipelines.</p><p>In enterprise knowledge applications, teams may need to combine documents, tables, business records, embeddings, and permissions so that AI-generated answers are accurate, traceable, and safe to use.</p><p>Across these scenarios, the common need is not just storage. It is a governed, searchable, real-time, and open data foundation for AI.</p><h3>Closing</h3><p>AI-native applications are pushing enterprise data systems beyond the boundaries they were originally designed for. The challenge is no longer only how to store more data, or how to run faster queries. The challenge is how to make enterprise data usable by models and agents in a way that is real-time, consistent, governed, and scalable.</p><p>Lakebase is OceanBase’s answer at the data engine layer.</p><p>It brings multimodal data, hybrid search, open compute, and database-grade management into one architecture, so enterprises can reduce fragmented pipelines and build AI applications on a more reliable data foundation.</p><p>For us, the purpose of Lakebase is straightforward: help enterprises turn their existing and future data into AI-ready context, without giving up the reliability, consistency, and operational discipline required in production systems.</p><p><em>Author:Foo Han</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e22d5ee9fab5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oceanbase-database/oceanbase-lakebase-a-unified-data-foundation-for-ai-native-applications-e22d5ee9fab5">OceanBase Lakebase: A Unified Data Foundation for AI-Native Applications</a> was originally published in <a href="https://medium.com/oceanbase-database">OceanBase Database</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Permanent Server Offline in OceanBase: How the Cluster Heals After a Node Is Gone]]></title>
            <link>https://medium.com/oceanbase-database/permanent-server-offline-in-oceanbase-how-the-cluster-heals-after-a-node-is-gone-7d211d8e8b1e?source=rss----617ed9842a21---4</link>
            <guid isPermaLink="false">https://medium.com/p/7d211d8e8b1e</guid>
            <category><![CDATA[system-availability]]></category>
            <category><![CDATA[paxos]]></category>
            <category><![CDATA[distributed-database]]></category>
            <dc:creator><![CDATA[OceanBase]]></dc:creator>
            <pubDate>Mon, 06 Jul 2026 10:38:53 GMT</pubDate>
            <atom:updated>2026-07-06T10:38:53.722Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*r4udFQo-1dEr7KWi6Qp4Ng.png" /></figure><p>An OceanBase cluster runs every log stream on three (or more) replicas coordinated by Paxos. When one of those replicas goes down — an entire OBServer process, usually — the surviving replicas still hold majority, elect a new leader in a few seconds, and keep committing writes. Most high-availability writing stops there, and it’s a fair place to stop if the story is <em>the application didn’t notice</em>.</p><p>But it’s only half the story if the story is the cluster’s health. That log stream is now running on two replicas out of three. Another failure in the same group and there’s no majority left — no quorum, no writes, no reads at consistent isolation. The service is still up; the redundancy that kept it safe is spent.</p><p>The cluster knows this, and it will heal on its own — but not for an hour, by default. This post is about how the healing actually works: the two clocks that gate it, and the operator toolkit for skipping the wait when the node is truly gone.</p><h3>What Root Service Actually Sees</h3><p>OceanBase 4.x runs heartbeats in both directions. Every OBServer pushes a lease request to Root Service to keep its membership alive; Root Service, in turn, polls each OBServer with a heartbeat RPC every two seconds. RS reads the returning packets and classifies each OBServer along <strong>two independent axes</strong> — a <em>heartbeat state</em> driven by the polling window, and a <em>disk-health status</em> carried inside the packet.</p><p>The heartbeat state has three values in code — alive / lease_expired / permanent_offline:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IYhIh0jvCJmwmJs-FPfHZw.png" /></figure><p>The disk-health status is a separate signal on a parallel axis. Each heartbeat packet reports the OBServer’s data-disk status — normal or error. When a packet arrives with disk error, RS internally issues ALTER SYSTEM STOP SERVER against that node: the process is alive and reachable, but its storage can&#39;t be trusted. STOP SERVER stops routing to the node, and Leaders that lived there switch away through re-election — not because RS forcibly moves them, but because they can no longer take traffic. When a later packet reports disk normal again, RS auto-issues START SERVER. Neither the ten-second nor the one-hour clock is involved. This is often surprising the first time you see it: a node has its Leaders gone but its heartbeat state is still alive, because it is.</p><p>Three visible fields sit on top of those two internal axes. DBA_OB_SERVERS.STATUS is ACTIVE / INACTIVE / DELETING. DBA_OB_SERVERS.STOP_TIME is NULL when the node isn&#39;t isolated and a timestamp when it is — set by any of the three isolation verbs below, <em>or</em> by RS itself in the disk-fault path. And &quot;stopped&quot; isn&#39;t a STATUS value: it&#39;s STATUS=&#39;ACTIVE&#39; AND STOP_TIME IS NOT NULL. &quot;Permanently offline&quot; is the heartbeat state, not something you&#39;ll find in STATUS; when you query the views during recovery, you&#39;re reading STATUS and STOP_TIME.</p><p>The two clocks produce this sequence:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/707/1*EasVj3Td0tHii3x4myaJBA.png" /></figure><h4>The Ten-Second Clock: lease_expired</h4><p>lease_time — cluster-level, default 10 seconds, range [1s, 5min] — is the window the cluster spends betting that the outage resolves itself. When RS misses heartbeats for cumulative lease_time, three things happen and three things don&#39;t.</p><p>What flips:</p><ul><li>The heartbeat state becomes lease_expired.</li><li>DBA_OB_SERVERS.STATUS becomes INACTIVE.</li><li>ODP stops routing to the node. Any Leaders that lived there are already gone — the surviving replicas re-elected inside OceanBase’s ~8-second leader-failover RTO.</li></ul><p>What doesn’t flip: no replica movement, no Paxos member change, no locality-triggered ADD REPLICA. The cluster is betting on a reboot or a network blip resolving inside server_permanent_offline_time, and moving data now would be work it might not need to do. Most of the time that bet is right.</p><h4>The One-Hour Clock: permanent_offline</h4><p>server_permanent_offline_time — cluster-level, default 3600s, range [20s, +∞), since V1.4 — is the window RS waits before it accepts the node is gone. Once the timer expires, the heartbeat state flips to permanent_offline and RS begins the self-heal, per affected log stream:</p><ol><li><strong>Remove the missing replica from the Paxos member list.</strong> Metadata change only, executed on the surviving members. The quorum size shrinks by one.</li><li><strong>Schedule a new replica</strong> on some other OBServer in the same Zone that has capacity. The new replica picks a healthy peer as its data source, copies macro blocks plus a log start point, then replays clog to catch up.</li><li><strong>Rejoin the member list.</strong> Once the new replica is current, it joins Paxos. The quorum is whole again; the cluster can absorb the next minority failure without risk.</li></ol><p>You watch this through OceanBase’s replica-task views:</p><pre>-- what&#39;s healing right now<br>SELECT ls_id, task_type, task_status, comment<br>  FROM oceanbase.DBA_OB_LS_REPLICA_TASKS;<br><br>-- what just finished<br>SELECT ls_id, task_type, execute_result, finish_time<br>  FROM oceanbase.DBA_OB_LS_REPLICA_TASK_HISTORY<br>  ORDER BY finish_time DESC LIMIT 20;</pre><p>Convergence is still “the views are empty.” When both queries return zero rows, every log stream is back to its declared locality.</p><p>Two preconditions have to hold, and both are worth naming because a reader in the wrong operational context won’t see the healing happen:</p><ul><li>enable_rereplication<strong> must be </strong>True<strong>.</strong> It&#39;s the cluster-level master switch for automatic replica re-placement (default True, since V1.4). Some upgrade procedures turn it off — if it&#39;s off when a node goes permanently offline, the timer will fire and nothing will move.</li><li><strong>The same Zone must have capacity for the new replica.</strong> If no surviving OBServer can host it, ADD REPLICA waits. Precheck the Zone’s free CPU and memory before assuming healing will complete on its own.</li></ul><p>One more behavior worth stating explicitly, because it comes up when a “dead” node is restored: if the node returns <em>after</em> the timer has fired, its old replicas are already gone from every Paxos member list, so they’re erased on rejoin and the data comes back from healthy peers. There’s no reconciliation of stale state.</p><h3>The Timer Is a Safety Net, Not the Plan</h3><p>An hour at reduced redundancy is a long window to accept for a failure you already know is permanent. During a real minority-node failure, don’t wait for server_permanent_offline_time at all. Intervene:</p><ol><li>STOP SERVER on the bad node — or FORCE STOP SERVER if STOP SERVER fails.</li><li>Add a new OBServer in the same Zone.</li><li><strong>Manually issue </strong>ALTER SYSTEM MIGRATE UNIT<strong> for each unit</strong> on the old node.</li><li>Watch DBA_OB_UNIT_JOBS WHERE JOB_TYPE=&#39;MIGRATE_UNIT&#39; until it&#39;s empty.</li><li>DELETE SERVER on the old node.</li></ol><p>Three reasons the manual path beats the timer:</p><ul><li><strong>Topology stays balanced.</strong> Auto-replicate places replicas wherever there’s capacity; a human placing units by hand can preserve intended balance.</li><li><strong>The reduced-redundancy window shrinks from an hour to whatever the copy takes.</strong></li><li><strong>Bandwidth impact is observable in real time</strong>, so you can throttle if the copy is competing with foreground traffic.</li></ul><p>The timer isn’t wrong — it’s the safety net for the case where nobody is watching. But if someone <em>is</em> watching, give the cluster better information than the timer can.</p><p>For planned operations, tune server_permanent_offline_time to fit what you&#39;re actually doing:</p><ul><li><strong>Cluster upgrade</strong> → 72 hours. OCP sets this automatically for supported upgrades so rolling restarts don’t trip the timer.</li><li><strong>Hardware replacement</strong> → 4 hours. Long enough to swap the box without re-replicating; short enough to heal if the swap fails.</li><li><strong>Clean re-onboarding</strong> → 10 minutes. When you’re deliberately taking a node out and putting it right back.</li></ul><p>Adjust with ALTER SYSTEM SET server_permanent_offline_time = &#39;&lt;value&gt;&#39; (sys tenant only; effective immediately, no restart).</p><h3>Three Isolation Verbs, in Order of Preference</h3><p>Before removing or replacing a node, isolate it from traffic. OceanBase offers three verbs with decreasing safety guarantees. The right default is always the strictest one.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/913/1*q2xM3AMkgkD5En6e2jAd9w.png" /></figure><p>Syntax is uniform — all three accept one or more &#39;ip:port&#39; targets:</p><pre>ALTER SYSTEM STOP SERVER &#39;ip:2882&#39;;<br>ALTER SYSTEM FORCE STOP SERVER &#39;ip:2882&#39;;<br>ALTER SYSTEM ISOLATE SERVER &#39;ip1:2882&#39;, &#39;ip2:2882&#39;;</pre><p>The rule is simple: prefer STOP SERVER. The weaker verbs exist because the strict checks would fail <em>for the wrong reason</em> — not because they&#39;re &quot;the fast option.&quot; FORCE STOP SERVER is what you reach for when you need to isolate node C but node B is dragging in an unrelated way; ISOLATE SERVER is what you reach for when the multiple-zone constraint blocks the safer verbs.</p><p>A failed STOP SERVER is diagnostic — the error text tells you exactly which invariant would break. The ones worth recognizing:</p><ul><li>-4179 Tenant(X) LS(Y) log not sync, stop server not allowed — a follower is more than three seconds behind its leader (the threshold PALF_LOG_SYNC_DELAY_THRESHOLD_US in PALF; the value some docs still cite as 5s refers to an unused constant).</li><li>-4179 Tenant(X) locality is changing, stop server not allowed — you can&#39;t isolate a node while the tenant&#39;s member list is in flux.</li><li>-4179 Tenant(X) LS(Y) has no enough valid paxos member after stop server, stop server not allowed — stopping this node would drop the LS below majority.</li><li>-4660 cannot stop server or stop zone in multiple zones — another Zone already has stopped nodes; only ISOLATE SERVER relaxes this.</li></ul><p>Read the error string before reaching for a weaker verb. Half the time the fix is somewhere else (catch up a lagging follower, finish a locality change) and STOP SERVER succeeds on the next try.</p><h3>The Failure-Driven Replacement Flow</h3><p>Putting it end to end for a permanently failed node in a homogeneous Zone:</p><pre>-- 1. Isolate. Confirms it&#39;s safe to touch the node.<br>ALTER SYSTEM STOP SERVER &#39;10.0.0.5:2882&#39;;<br>-- 2. Add a new OBServer to the same Zone (usual add-node procedure).<br>-- 3. For each unit that was on the old node, move it to the new one.<br>--    List them first:<br>SELECT unit_id FROM oceanbase.DBA_OB_UNITS WHERE svr_ip = &#39;10.0.0.5&#39;;<br>--    Then, per unit:<br>ALTER SYSTEM MIGRATE UNIT 1001 DESTINATION &#39;10.0.0.9:2882&#39;;<br>--    ...one statement per unit.<br>-- 4. Watch migration finish.<br>SELECT * FROM oceanbase.DBA_OB_UNIT_JOBS WHERE job_type = &#39;MIGRATE_UNIT&#39;;<br>-- Empty result = migration done.<br>-- 5. Delete the old node from cluster metadata.<br>ALTER SYSTEM DELETE SERVER &#39;10.0.0.5:2882&#39;</pre><p>Two guardrails worth naming:</p><p><strong>Precheck same-Zone capacity before </strong>DELETE SERVER<strong>.</strong> DELETE SERVER succeeds only after all units on the target have been migrated off. If no surviving OBServer in the same Zone has room, the node hangs in DELETING indefinitely.</p><pre>SELECT svr_ip,<br>       cpu_capacity_max - cpu_assigned_max AS cpu_free,<br>       mem_capacity     - mem_assigned      AS mem_free<br>  FROM oceanbase.GV$OB_SERVERS<br>  WHERE zone = &#39;target_zone&#39;;</pre><p><strong>If it does stall, roll back.</strong> ALTER SYSTEM CANCEL DELETE SERVER &#39;ip:2882&#39; reverses a stuck DELETING back to ACTIVE. Add capacity, then retry.</p><p>Two knobs shape how fast the background copy runs, and both are worth knowing so migration doesn’t starve foreground traffic — or the reverse:</p><ul><li>sys_bkgd_net_percentage (cluster, default 60) — cap on the share of network bandwidth background tasks may use.</li><li>balancer_idle_time (tenant, default 10s, range [10s, +∞)) — the interval at which the balancer issues new migration tasks.</li></ul><p>The shortcut some operators reach for: skip step 3 and go straight to DELETE SERVER. RS will auto-migrate units to whichever same-Zone OBServer has capacity. Same eventual outcome, less control over destination — fine for homogeneous clusters, less fine when servers differ in spec and you care where things land.</p><h3>When Arbitration Mode Changes the Clock</h3><p>A short aside for readers on 4F1A or 2F1A tenants — four or two full-function replicas plus one arbitration member, an Enterprise-only topology.</p><p>For arbitration-enabled tenants, the majority-loss story is different. When the cluster can no longer form a Paxos majority among the F replicas — for example, exactly half the F replicas in a 4F1A tenant have failed — the arbitration service kicks in on a much shorter timer. arbitration_timeout (tenant-level, default 5s, range [3s, +∞)) governs how long the service waits before degrading the log stream: it removes the failed F replicas from the member list <em>without changing locality</em>, so the surviving replicas plus the arbitration member can keep committing at RPO = 0. When the failed replicas come back, the arbitration service upgrades the log stream and rejoins them.</p><p>The rest of this post is written for the multi-replica-only case, where server_permanent_offline_time is the clock that matters. If your topology includes an arbitration member, five seconds — not one hour — is the deadline the service is measuring against.</p><h3>Whose Information Is Better</h3><p>The cluster’s timer is conservative because moving data is expensive and most outages resolve themselves. That’s the correct default for a system with no operator on the other end. But an operator watching a genuinely dead node has information the cluster doesn’t — the machine is scrapped, the cloud instance is terminated, the rack is decommissioned. Don’t make the cluster wait. STOP SERVER, MIGRATE UNIT by hand, DELETE SERVER, watch the same tasks and views you’d watch either way.</p><p>Either path ends in the same place — every log stream back at its declared replica count, the locality contract restored. The DR verbs are identical. The only difference is who decides the node is gone: the clock, or you.</p><p>The next post takes the failure model one step further: not a single node lost, but an entire cluster. That’s the domain of the tenant-level physical standby, and its two role-switch primitives — Switchover for planned recovery, Failover for the unplanned kind.</p><h3>Try It Yourself</h3><p>On a three-Zone OceanBase Community Edition cluster, kill an OBServer process and watch the two-clock progression:</p><pre>-- Within seconds: STATUS flips to INACTIVE.<br>SELECT svr_ip, status, stop_time FROM oceanbase.DBA_OB_SERVERS;</pre><p>To exercise the automatic path without a one-hour wait, shorten the timer in a test cluster:</p><pre>ALTER SYSTEM SET server_permanent_offline_time = &#39;60s&#39;;<br><br>-- After ~60s, the healing tasks appear:<br>SELECT ls_id, task_type, task_status, comment<br>  FROM oceanbase.DBA_OB_LS_REPLICA_TASKS;</pre><p>To exercise the operator path, run the replacement flow above end to end and watch DBA_OB_UNIT_JOBS and DBA_OB_LS_REPLICA_TASKS side by side — one shows units moving, the other shows replicas being added and old ones being removed from Paxos. When both views come back empty, the cluster is whole again.</p><p><em>Author:Zhennan Wang</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7d211d8e8b1e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oceanbase-database/permanent-server-offline-in-oceanbase-how-the-cluster-heals-after-a-node-is-gone-7d211d8e8b1e">Permanent Server Offline in OceanBase: How the Cluster Heals After a Node Is Gone</a> was originally published in <a href="https://medium.com/oceanbase-database">OceanBase Database</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[OceanBase AI Database: Built on a Lakebase Architecture for the AI Era]]></title>
            <link>https://medium.com/oceanbase-database/oceanbase-ai-database-built-on-a-lakebase-architecture-for-the-ai-era-7bddf6173dea?source=rss----617ed9842a21---4</link>
            <guid isPermaLink="false">https://medium.com/p/7bddf6173dea</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[distributed-database]]></category>
            <category><![CDATA[cloud-database]]></category>
            <dc:creator><![CDATA[OceanBase]]></dc:creator>
            <pubDate>Fri, 03 Jul 2026 07:22:48 GMT</pubDate>
            <atom:updated>2026-07-03T07:22:48.861Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nQt-fxIJprGiiwolTJCaAA.png" /></figure><p>Over the past few decades, enterprise data systems evolved along several major lines: OLTP databases for online transactions, data warehouses for analytics, and big data systems for large-scale processing. Yet most of them were built around the same assumption: applications, designed around human-defined workflows, would perform deterministic transactions and structured analytics.</p><p>That assumption is changing. AI agents are no longer limited to reading data and answering questions. They call tools, generate code, execute tasks, modify state, and participate in business processes. The users of databases are expanding from human-driven applications to large numbers of autonomous agents. This raises a fundamental question: when agents need to read, write, search, experiment, roll back, and continuously build context, should the database remain what it was?</p><p>I believe the answer is no. AI changes three things at once. First, <strong>who</strong> uses the database: from applications alone to applications and agents. Second, <strong>what</strong> the database manages: from mostly structured data to structured, semi-structured, unstructured, and multimodal data. Third, <strong>what workloads</strong> the database must support: from transactions and analytics to search, context engineering, AI computation, and agent experimentation.</p><p>An AI database is not a traditional database with a few AI functions bolted on. Nor is it a vector database with SQL capabilities retrofitted. It must solve the data infrastructure problem that emerges when AI enters production systems. multimodal data must be managed on a unified foundation. Online serving and offline compute must converge. Agents need real-time, trustworthy, continuous context. And all of this — reads, writes, experimentation, rollback, governance — must maintain database-grade consistency and reliability.</p><p>This is not a feature enhancement. It is a redesign of database architecture for the AI era.</p><h3>Moving Toward Unified Data Platforms</h3><p>Across the industry, different vendors are approaching this problem from different starting points. Databricks and Snowflake started from the lakehouse side and are steadily adding OLTP transaction capabilities. OceanBase and Oracle started from transactional databases and are expanding into OLAP and big data territory. MongoDB, Milvus, and Elasticsearch started as specialized systems and are becoming more general-purpose. Regardless of starting point, all these paths are converging toward a unified data platform capable of handling transactions, analytics, search, vectors, and AI compute simultaneously.</p><p>OceanBase has pursued a unified architecture from the beginning. We started with distributed OLTP, solving scalability and reliability for online transactions. We then added real-time OLAP support on top of OLTP, eliminating the data movement pipeline between transactional and analytical workloads. Last year, we shipped multimodal integration — bringing vector, full-text and JSON capabilities into the same database engine. Today, we are releasing <strong>lakebase integration</strong>: bringing the real-time transaction capabilities of a database and the open storage and open compute capabilities of a data lake into a single unified platform.</p><h3>What a Unified Lakebase Architecture Means</h3><p>A real Lakebase architecture cannot stop at bolting a data lake onto the side of a database. Nor can it merely add a few online query interfaces to a lakehouse. To be production-ready, it must merge three boundaries.</p><p><strong>First, data boundaries must be unified.</strong> Structured data, semi-structured data, unstructured data, vectors, graphs, and full-text indexes cannot live in separate systems with separate management. They should be governed under a single table semantic.</p><p><strong>Second, compute boundaries must be unified.</strong> SQL queries, real-time analytics, hybrid search, Spark ETL, and Ray-based AI compute should all operate on the same data — without constant export, transformation, and intermediate materialization.</p><p><strong>Third, governance boundaries must be unified.</strong> Metadata, permissions, row-level controls, auditing, versioning, and lifecycle policies must apply consistently across all data types. If structured columns have access controls but vector retrieval bypasses them, that system cannot enter enterprise production.</p><p>This is the design philosophy behind <strong>OceanBase Lakebase</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5M9u3RshnGl7rXR3" /></figure><p>A multimodal table contains both traditional relational columns for structured data and multimodal columns plus AI columns for unstructured data. Unstructured data can be written into the multimodal table as vectors or text after external embedding or tagging, or written directly as LOBs (large objects). OceanBase supports highly flexible LOB storage: if the LOB is small, it’s stored inline within the row to minimize I/O; if the LOB is large, it’s chunked and stored in object storage with only chunk location metadata kept inline; if the LOB is very large, it supports referencing existing files in external object storage while the database stores only metadata. To the application layer, it still looks like a single table.</p><p>Why not use other open source lake format directly? Iceberg format can not support multi modal data, Lance format is not good for structured data and both of them need lots of additional work to achieve realtime and consistency.</p><p>On top of multimodal tables, we designed <strong>AI columns</strong>. Think of them as real-time computed columns on a table: when data is written, embedding, tagging, or other model computations are automatically triggered, and results are written back into the table. The critical property here is transactional consistency semantics. When a batch of audio files is written, either all of them complete embedding and tagging, or none of them do. Partial success is not acceptable.</p><h3>Hybrid Search: Search as a First-Class Workload in AI Database</h3><p>With multimodal tables in place, the next step is executing AI workloads on them. In an AI database, the fundamental query pattern evolves from relational lookup to <strong>hybrid search</strong> — completing relational filtering, full-text search, vector search, graph traversal, and AI computation within a single table.</p><p>Why isn’t vector search alone sufficient? Vector search will certainly be the most common computation pattern in AI databases. But in real-world scenarios, we typically first apply relational filters to narrow the global dataset to a smaller candidate set (e.g., “only orders from the last 30 days”), then perform vector, full-text, and graph hybrid search on that candidate set. The database narrows the scope first; the model processes only high-value candidates — lower inference cost, more accurate results, more controllable pipelines.</p><p>In the AI era, search will return to the database as a native workload, alongside OLTP and OLAP.</p><p>On performance, we’ve conducted systematic benchmarks. Using the HNSW algorithm in 768-dimension and 1536-dimension test scenarios, OceanBase’s vector search performance significantly outperforms Milvus, Elasticsearch, and pgvector at equivalent recall rates. On hybrid search, using the MS MARCO dataset, OceanBase’s hybrid search performance exceeds Elasticsearch by over 30%. These aren’t theoretical projections — they’re reproducible results on standard datasets.</p><h3>Open Compute and Unified Catalog</h3><p>An AI data pipeline goes beyond SQL queries — it includes ETL processing, AI inference, and multimodal understanding. The traditional approach uses many separate systems: Kafka for ingestion, Flink for stream processing, Spark for batch processing, HDFS for persistence, ClickHouse for analytics, HBase for wide tables, Elasticsearch for search, and Presto for federated queries.</p><p>OceanBase Lakebase takes a different approach. The bottom layer uses multimodal tables on object storage to enable data sharing across compute engines — one copy of data simultaneously serves all compute engines. OceanBase’s SQL engine handles online queries and transactions. Spark handles PB-scale batch ETL. Daft on Ray handles AI inference. This eliminates the data consistency gaps and compute latency that plague multi-system architectures.</p><p>Different compute engines do what they are good at, while sharing the same governed data foundation. This requires a <strong>unified, open Catalog</strong> to manage data. Tables, views, schemas, lineage, row-level permissions, and column-level authorization are all managed in one place. Every operation entering the OceanBase AI database passes through a unified metadata and access control plane — preventing unauthorized data access. We also support the finest-grained row-level security (RLS) controls.<br>In production AI systems, governance is not optional. It is part of the architecture.</p><h3>Designed for Agents: Branching, Isolation and Elastic Scale</h3><p>For agents to enter production systems, the database must provide more than read access. Agents need a place to experiment, write intermediate state, compare results, and roll back safely.</p><p>This is where Fork Database becomes important. Fork Database is designed to create lightweight branches of a database using copy-on-write, like pulling a branch in git. Even a PB-scale database can be forked in under a second, consuming only incremental space (Copy-on-Write: unmodified data blocks point to the same storage on the lake, no physical copies). After branching, agents can perform all kinds of AI development, testing, and experimentation on the branch. If the experiment succeeds, commit. If it fails, roll back — essentially zero cost.</p><p>Combined with DIFF and MERGE, agents gain complete data version control capabilities — Fork to create branches, DIFF to inspect changes (down to row and value level), MERGE to integrate back according to strategy. This isn’t an analogy to Git. It’s a native SQL-level implementation.</p><p>The other dimension is scale. The volume of agent data will be enormous — potentially billions or even trillions of agents running in parallel in the future, each with its own schema and tables. This creates a schema explosion problem. Traditional databases optimize for “few databases + massive data” — one cluster hosting dozens of databases, each with billions of rows. The agent scenario is the inverse: millions of agents, each with only hundreds of rows, but an astronomical number of instances.</p><p>OceanBase’s <strong>logical table</strong> design gives each agent the appearance of independent logical tables, while the underlying storage is a single physical table. The logical abstraction layer solves schema explosion. Fork Database provides isolated environments; logical tables handle instance scale — together, they enable individual agents to safely experiment while massive numbers of agents run in parallel at low cost.</p><h3>The Context Layer: Helping AI Understand Enterprise and Users</h3><p>An AI database needs more than just an engine. Between the engine and applications, there’s a missing layer — <strong>context</strong>.</p><p>The context layer has two components. <strong>Data context</strong> addresses data semantics and data governance, helping AI understand the enterprise. <strong>Application context</strong> addresses Memory and RAG, helping AI understand users.</p><p>On the memory dimension, an agent’s memory cannot simply be a growing pile of context. It must be an evolvable, structured asset. For this we developed <strong>PowerMem</strong>, and its cloud-based product <strong>seekdb M0</strong>. PowerMem is built on top of the AI database — memory retrieval itself is a hybrid query combining structured filtering with semantic similarity. More critically, it supports memory self-evolution — including experience evolution and skill evolution.</p><p>We validated this using the AppWorld fair distillation experiment — same trajectories, same model, with the only variable being the distillation and retrieval approach. Results: seekdb M0 achieved a 39% pass rate versus Hermes at 22%; to complete the same tasks, M0 required 6.2 steps versus Hermes at 10.4; overall token consumption dropped by 32%.</p><p>On the semantic dimension, high-quality data semantics enable AI applications to truly understand the enterprise. <strong>OceanBase OSI</strong> doesn’t aim to build yet another BI semantic layer — it unifies metrics, definitions, raw data, context graphs, and ontology layers. The bottom layer is the semantic layer — metrics, calculation definitions, and raw data, designed on the Ant-OSI semantic layer standard, compatible with the open OSI standard, and validated extensively within Ant Group. The middle layer is the context graph — large models reason against the context graph to improve accuracy. The top layer is the ontology layer — unifying business semantics with underlying database semantics, balancing global and local semantics. The core philosophy is <strong>“semantics as code”</strong> — data semantics defined once, consumed everywhere: BI tools render reports, agents generate SQL, governance tools perform lineage analysis — all reading the same definition.</p><p>We also developed the OceanBase <strong>DataPilot</strong> product based on OceanBase OSI. In POC tests across different industry customers, feedback consistently shows accuracy far exceeding other products in the market. The difference isn’t in the model — it’s in the quality of semantic context. When AI has access to precise business metric definitions, the accuracy of natural language to SQL translation improves fundamentally.</p><h3>One Stack to Reduce Engineering Complexity</h3><p>The most direct value of this architecture is reducing system complexity.</p><p>In the traditional approach, enterprises often need many systems to process multimodal data and support AI workloads: databases, data lakes, warehouses, search engines, vector databases, ETL systems, governance tools, and serving layers. Stitching them together creates a cascade of problems: CDC latency, ETL retries, inconsistent permissions, duplicated metadata, multiple monitoring systems, and multiple operational teams.</p><p>A unified Lakebase architecture does not mean every component disappears. But it does mean the core data foundation becomes simpler. One copy of data can support multiple workloads. Governance can be defined once and applied consistently. Online serving and offline processing can operate closer to the same data. Hybrid search can run with fresher and more trusted context.</p><p>For AI applications, this simplicity matters. The gap between a demo and a production system is often not the model. It is the data infrastructure around the model.</p><h3>Conclusion: The AI Database for the Agent Era</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*P5voWzQTY1U7Z0cq" /></figure><p>When you put all these capabilities together, the OceanBase Lakebase architecture can be summarized in three layers. The bottom layer is the lakebase engine — multimodal tables running on object storage, supporting open compute: OceanBase’s SQL compute (OLTP, OLAP, search) plus Spark ETL and Daft on Ray AI compute. The middle layer is the context layer — data context helps AI understand the enterprise, application context helps AI understand users. The top layer consists of the application agents we’ve developed: a data development agent for data engineers, and a data analysis agent for business analysts.gent for data engineers, and a data analysis agent for business analysts.</p><p>For enterprises to truly put AI to work, the most important and fundamental step is to manage their own data through a unified AI database. Only after managing their data well can enterprise AI become more accurate, more efficient, faster, and more secure.</p><p>OceanBase Lakebase is our answer to this challenge: a unified Lakebase architecture designed for the agent era.</p><p><em>Author:Charlie Yang, CTO of OceanBase</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7bddf6173dea" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oceanbase-database/oceanbase-ai-database-built-on-a-lakebase-architecture-for-the-ai-era-7bddf6173dea">OceanBase AI Database: Built on a Lakebase Architecture for the AI Era</a> was originally published in <a href="https://medium.com/oceanbase-database">OceanBase Database</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Rethinking the Database for the AI Era]]></title>
            <link>https://medium.com/oceanbase-database/rethinking-the-database-for-the-ai-era-db1efd2d54a4?source=rss----617ed9842a21---4</link>
            <guid isPermaLink="false">https://medium.com/p/db1efd2d54a4</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[cloud-database]]></category>
            <category><![CDATA[distributed-database]]></category>
            <dc:creator><![CDATA[OceanBase]]></dc:creator>
            <pubDate>Tue, 30 Jun 2026 08:59:33 GMT</pubDate>
            <atom:updated>2026-06-30T08:59:33.637Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dTpttQXxMPDG0DQTrecERA.png" /></figure><p>Over the past three years, the most striking story in technology has been the leap in AI capabilities — models that iterate week by week, learning to reason, generate, and understand language. Enterprises have answered with their wallets, driving a massive surge in AI investment directed at both the models themselves and the underlying compute power.</p><p>But there’s a B-side. The spending climbs; the business value doesn’t keep pace. <a href="https://www.gartner.com/en/documents/7290730">Gartner</a> predicted 60% of AI projects will be abandoned for failing to meet production requirements — most often for a lack of high-quality data. Between a model’s general intelligence and the intelligence an enterprise actually needs lies a gap of <em>business context</em>. Closing it is, at bottom, a data problem. The next generation of enterprise AI will not be limited by model intelligence alone. It will be limited by whether enterprises can turn their data into real-time, trusted, and actionable context.</p><p>This brings me to the question I’ve spent the past year on, and the real subject of this piece: in the age of AI, what should a database <em>become</em> — what must change, and what must be inherited.</p><h3>Two assumptions just broke</h3><p>For decades, a database rested on two assumptions: that its user was a person — someone writing SQL or reading a dashboard — and that the data worth managing was structured, in tidy rows and columns. AI broke both at once:</p><ul><li><strong>The user is no longer just human.</strong> It is increasingly an <strong>agent</strong> — software that runs continuously, calls tools, reads and writes data, holds state, and acts at machine speed. Gartner expects 33% of enterprise applications to embed agentic AI by 2028, up from less than 1% in 2024</li><li><strong>The data is no longer only structured.</strong> Roughly 80% of enterprise data is unstructured — documents, messages, images, audio, video, logs — and AI has, for the first time, made it computable rather than mere archive.</li></ul><p>Neither is a simple feature request. Each break asks the database for something it was never designed to give.</p><h4>What an agent demands</h4><p>An agent is a new kind of data consumer — it runs around the clock, calls data on its own, and gets better by trial and error. A year of building for them has surfaced three demands no human user ever made.</p><ul><li><strong>Scale — but not the scale you think.</strong> Database scalability used to mean making one database bigger. The agent era inverts the problem. When generating an application costs almost nothing, their number explodes. Ant’s Lingguang, a consumer platform that turns a prompt into an app, already carries some 30 million of them. Each holds little data, most stay dormant, and any may need to wake in an instant. Give each its own resources and the cost is impossible; let them share blindly and the data boundaries collapse. So “massive” now means a massive <em>number</em> of small databases, not one large one — millions that must coexist cheaply, stay isolated, scale on demand, and fall to near-zero when idle. <strong>Few traditional databases were designed for this pattern: millions of small, isolated, mostly dormant data environments that must wake instantly and scale cheaply.</strong></li><li><strong>Context — the ceiling on every agent.</strong> An agent’s primary workload is essentially <strong>search</strong>. From processing natural language to driving foundational components like RAG and Memory, agents constantly search and retrieve data to build context. When this retrieval must span both structured and unstructured data simultaneously, <strong>hybrid search becomes a strict necessity</strong>. The ability to return accurate context in a single recall determines whether an agent can support production-grade workloads in scenarios like risk management, AI commerce, and investment research. <strong>Ultimately, an agent’s ceiling is defined not just by the model, but by its capacity to build high-quality context.</strong></li><li><strong>Evolution — room to try and fail.</strong> An agent stays accurate only by iterating — finding bad cases, fixing them, re-evaluating — and each evaluation may rewrite data, change a flow, or swap a strategy. None of it can touch the running system, yet a faithful test needs a full copy of the agent’s data, memory and context included — slow and heavy on a database built for stable storage rather than constant experiment. What an agent needs instead is a data environment that works like a code repository: branch on demand, experiment in isolation, merge what works, discard what doesn’t. For an agent, that is the precondition for getting better.</li></ul><p>Scale, context, and evolution each pull on a different dimension — cost, accuracy, and efficiency. An <em>agent-friendly</em> data foundation is one that holds all three at once, instead of buying one at the expense of another.</p><h4>What the new data demands</h4><p>If those three demands are about how an agent <em>uses</em> data, three more are about the data itself — how it’s shaped, how it moves, and how we reach it.</p><ul><li><strong>Form — from cost center to computable asset.</strong> Most of an enterprise’s core records are structured, but most of its data is not — documents, emails, recordings, video that used to sit in archives, queried after the fact if at all. As Jensen Huang put it at GTC, <em>“unstructured data is the context of AI”</em> ; the mirror is just as true — <strong>structured data is the context of the <em>enterprise</em></strong>. AI finally makes that unstructured half computable, but storing it isn’t enough and indexing it isn’t either: it has to be managed, governed, and queried <em>alongside</em> structured data on one foundation, with hybrid retrieval — scalar, full-text, and vector — built into the data layer rather than rebuilt by every application.</li><li><strong>Flow — from one-way pipeline to closed loop.</strong> Software is changing character: programs improved when someone shipped new code; agents improve when data flows back to them — outputs settling into samples, labels, embeddings, and policy, then returning as fresh context. That loop is the data flywheel, and it’s what makes an application sharper with use. Today’s architecture blocks it: online databases, offline warehouses, and training platforms sit in separate systems linked by slow ETL, so a problem surfaced online today is fixed only tomorrow. The loop closes only when online serving and offline analysis run on the same data, not two systems that reconcile overnight.</li><li><strong>Interaction — from SQL to semantics.</strong> For decades the way in was SQL: an engineer writes a query, the database returns rows. Now agents reach data through natural language and intent, which asks the database to do more than store and retrieve. Schema and relations were once the whole of its “understanding”; for an agent to grasp what the data <em>means</em> — and act on it — the foundation now needs a semantic layer: the business entities, relationships, metrics, and policies that connect raw facts to the business they describe.</li></ul><p>Form, flow, interaction — together they hand the data layer a job it never had before.</p><h4>From system of record to context layer</h4><p>Put both shifts together, and what a database is <em>for</em> has changed. It is no longer only a system of record; it is becoming the <strong>context layer for AI</strong> — the place an agent turns to assemble what it knows before it decides or acts. That is the real reframing. And it sets up the question I find most important, and most often gotten wrong: if the database is becoming all of this, what about it must <em>not</em> change?</p><h3>The constant: AI makes the bottom lines matter more, not less</h3><p>Whenever a “new category” appears, the temptation is to assume everything before it should be torn down. With databases, the opposite is true.</p><p>AI has rewritten how a database is <em>used</em>. It has made the database’s oldest guarantees more important than ever.</p><ul><li><strong>Consistency</strong> changed meaning. It used to be about keeping replicas in step; now it has to hold <em>across modalities</em> — the records, text, vectors, and files that today live as four drifting copies in four systems. A context an agent trusts can’t be eventually consistent with itself: once agents decide in production, one stale record isn’t a metric, it’s an incident.</li><li><strong>Scalability</strong> changes shape but not stakes: from making one database big to letting a million small ones coexist cheaply — scaling out when needed, to zero when idle.</li><li><strong>Reliability</strong> becomes a lifeline. An agent runs around the clock with no operator watching. The financial-grade high availability we spent fifteen years earning — once there to protect core transactions — becomes the lifeline of every single agent.</li><li><strong>Real-time</strong> is non-negotiable — and the bar just rose. The unit of work has gone from a single request to a full inference, and from simple reads and writes over structured rows to hybrid retrieval and multi-path recall over multimodal data — all of it now in the live path of a decision. An agent that can’t assemble its context in real time can’t support a live business. That is exactly why an agent’s data foundation needs the reflexes of a production transactional database, not the lag of an offline analytical one.</li></ul><p>What AI asks you to rewrite is the architecture; what it asks you never to compromise is the engineering floor. That tension — what changes, and what must not — is the whole question.</p><h3>So what is an AI database?</h3><p>Put the change and the constancy together, and a definition falls out — less an assertion than a consequence of everything above. An AI database has to be four things at once, and they come from two different places.</p><p><strong>By workload demand.</strong></p><ul><li>It has to be <strong>unified</strong> — multimodal data and online-and-offline computation on a single, strongly consistent, real-time foundation, so data is never split, never shuttled between systems, and the flywheel can turn.</li><li>It has to be <strong>multimodal</strong> — structured data, vectors, text, and JSON processed and retrieved in one engine, because an agent’s memory is cross-modal by nature.</li></ul><p><strong>By design principle</strong> —</p><ul><li>It has to be <strong>agent-friendly</strong> — memory, isolation, branching, rollback, and natural-language access as native capabilities, not a rack of external systems bolted togethe</li><li>It has to be <strong>open</strong> — storage and compute decoupled, data in open formats on shared storage, and a free hand across infrastructure, clouds, and models, so the enterprise keeps three freedoms: where it runs, which models it uses, and ownership of its data.</li></ul><p>Four things, none optional. And only one architecture satisfies all four at once — joining the openness, scale, and multimodality of the data lake with the transactions and real-time of the database, in a single system. The industry is starting to call that shape a <strong>lakebase</strong> — where the data lake and the database become one.</p><h3>OceanBase’s answer</h3><p>Our answer is <strong>OceanBase AI Database</strong>. A database is strong on consistency, real-time, and reliability; a lake is strong on multimodal storage and open compute — and the AI era requires the two to become one. Relating multimodal data so it stays consistent, processing it in real time, and managing it as one is exactly the bottleneck that decides whether a model’s, and an agent’s, power can land inside an enterprise.</p><p>Making that merge work isn’t a matter of gluing a lake and a database together. A lakebase has to grow outward from a kernel mature enough to be trusted with money — extending transactions and real-time to the lake, rather than bolting the hardest guarantees onto a lake or a vector engine after the fact. That is why we can build it: OceanBase has been heading toward this shape for years — from a distributed database in one engine, to transactions and analytics in one engine, and now to a lakebase.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rBpEGIQQvooglKHqZU01eg.png" /></figure><p>Here is what that core makes possible:</p><ul><li><strong>One foundation, one copy of the data.</strong> The lake’s open formats and scale and the database’s transactions, consistency, and real-time in a single system — structured, semi-structured, and unstructured data under one catalog, with permissions and lineage holding across all of it.</li><li><strong>Multimodal tables.</strong> Text, images, audio, documents, JSON, and vectors enter the table itself, managed under one set of transactions, permissions, and lifecycle — and model outputs like embeddings, summaries, and labels persist alongside them as AI columns.</li><li><strong>Hybrid search in one query path.</strong> Scalar filters, full-text, and vector retrieval run together inside the database, with multi-path recall and ranking kept consistent with the source data — so an agent’s context comes back accurate and fresh.</li><li><strong>Agent-friendly primitives.</strong> Long-term memory, context, and state are native; Fork Database spins up isolated sandboxes for safe trial and rollback; and millions of lightweight agents coexist at high density, waking on demand.</li><li><strong>An open design.</strong> Built on S3-compatible storage, Iceberg open tables, and a unified catalog, open to engines like Spark and Ray — so data isn’t copied, converted, or locked in.</li></ul><h4>Building OceanBase for the AI Era</h4><p>For the past fifteen years, OceanBase has been hardened in some of the most demanding production environments: systems where data cannot be wrong, service cannot stop, and recovery must happen fast enough that users do not feel the failure. Those requirements are not tied to one era of computing. They are the permanent floor for any system that businesses depend on.</p><p>And today, we are sharpening this lakebase capability inside Alibaba’s and Ant’s most demanding AI workloads. Just as how double 11 shopping festival once forced a distributed database into being, AI applications are now pushing the next generation of database architecture into shape. That is OceanBase’s particular way of evolving — and over the next decade, our goal is a simple: to build OceanBase for the AI era.</p><p><em>If you’re working on the data layer for AI, this is the problem we built OceanBase AI Database to solve. [Explore </em><a href="https://en.oceanbase.com/solution/ai"><em>OceanBase AI Database</em></a><em> Now]</em></p><p><em>Author:Yang Bing</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=db1efd2d54a4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/oceanbase-database/rethinking-the-database-for-the-ai-era-db1efd2d54a4">Rethinking the Database for the AI Era</a> was originally published in <a href="https://medium.com/oceanbase-database">OceanBase Database</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>