Skip to content
little big brain

Changelog

Each dated entry is a public product change, stamped with the date it shipped.

August 2026

Section titled “August 2026”

  • 31 Aug: OWL data properties import as property fields. Defining an ontology from Turtle, RDF/XML, or JSON-LD now routes owl:DatatypeProperty declarations (and untyped properties whose every rdfs:range is a datatype) into property fields with the matching native value type (xsd:integer to integer, xsd:decimal to number, xsd:boolean to boolean, date and time datatypes to datetime, everything else to text). Data properties no longer surface as relations declared over every class in the vocabulary. Object properties, owl:inverseOf, symmetric, and transitive declarations import exactly as before, and owl:AnnotationProperty declarations become searchable concepts without a relation or field. Graphs keep the ontology they were created with; define the ontology again on a fresh graph to adopt the new shape. GET /v1/graph/schema-summary also gains literal_predicate_counts, the data-property sibling of resource_predicate_counts, and the console’s Ontology workbench reads it when present. SDK releases @littlebigbrain/client 0.13.0 and Python littlebigbrain 0.13.0 add a typed schemaSummary() / schema_summary() method for the endpoint.

  • 28 Aug: Ontology hierarchy is visible in the console and API. The Ontology screen renders the active class lattice with direct parents and children instead of presenting a flat concept search. GET /v1/ontology and GET /v1/schema expose each class’s frozen stable identity, canonical query IRI, and direct superclass stable ids, keeping same-local-name imports distinguishable without a global SPARQL scan. Defining Turtle/RDF on an already-created graph now preserves additive rdfs:subClassOf links instead of flattening the imported hierarchy. The console’s inferred-subclasses view expands instance membership through this structural lattice and does not invoke unrelated owl:sameAs identity reasoning.

  • 25 Aug: Query-time OWL entailment. SPARQL reads accept entailment=owl, a strict superset of entailment=rdfs. On top of the RDFS rules it derives equivalence (owl:equivalentClass, owl:equivalentProperty), inverse, symmetric, and transitive properties, bounded acyclic owl:propertyChainAxiom composition, the owl:unionOf, owl:intersectionOf, and owl:oneOf class constructors, the owl:hasValue, owl:someValuesFrom, and owl:allValuesFrom restriction rules, and asserted owl:sameAs identity. Property-rule answers can feed downstream restrictions within the same bounded rewrite. The closure is derived at query time from the published data, so the mode works with no republish. An ontology past the mode’s bounds refuses entailment=owl with a clear error while asserted queries keep working. Existential superclasses, cardinality-derived inference, and owl:imports are out of scope. See Reasoning & inference.

  • 24 Aug: Query-time RDFS entailment. SPARQL reads accept entailment=rdfs for the practical RDFS rules (subclass membership and transitivity, subproperty transitivity and value propagation, and domain/range type derivation) and entailment=subclass for the class-only subset. The engine derives the closure at query time from the rdfs:subClassOf, rdfs:subPropertyOf, rdfs:domain, and rdfs:range triples in the published data, so the modes work on already-published data with no republish. The default stays entailment=none. A superclass COUNT under entailment=subclass answers from a per-class table computed with each new generation. reason=true now returns a typed 400, because rule-derived edges are folded in at publish time. See Reasoning & inference.

  • 24 Aug: Named-graph writes are refused instead of silently lost. The published RDF tier serves one default graph per little big brain database graph. A named-graph statement used to import or commit successfully and then answer no query. Every write entrance now refuses it with a clear error: RDF import counts and reports each named-graph statement (?strict=true fails the request), the graph_uri import parameter is rejected, SPARQL INSERT DATA into a named graph is rejected, and a Graph Store request must target ?default. Model isolation with graphs and branches. See the HTTP API.

  • 24 Aug: SHACL publishing is strict, and reports explain themselves. POST /v1/schema/publish now parses every shape at publish time and rejects anything the validator could not run: a malformed or prefix-unresolvable SPARQL constraint, an sh:ask validator, a SPARQL-based target, or an unrecognized sh:path expression. A schema that publishes is a schema that validates. SPARQL constraints gain sh:prefixes/sh:declare support, sh:message templates substitute {$this}, {$value}, and {$path} into report results, and composite violations carry nested details naming the inner constraint that failed. See the SPARQL & SHACL guide.

  • 24 Aug: SDK SHACL surface matches the server. TypeScript @littlebigbrain/client 0.12.0 and Python littlebigbrain 0.12.0 no longer ship the request-time JSON SHACL query types. Publish RDF SHACL shapes through the schema namespace, then inspect the durable ontology conformance report; MCP continues to reject the removed query modes.

  • 23 Aug: RDF-only graphs work throughout Explorer. The observed schema now connects classes through their relationships, the instance inspector shows native RDF fields and relationship groups, and one-hop expansion and schema-driven traversal work across RDF graphs. Publication delays now show a recovery panel with clear retry guidance.

  • 22 Aug: Graph ontologies start empty, and definitions are reusable. POST /v1/graph/create no longer installs the built-in AI-context vocabulary. POST /v1/ontology/define is safe to rerun: an identical definition is a no-op, additive changes evolve the ontology, and narrowing or identity-breaking changes fail without writing. The starter vocabulary is now explicit and opt-in with merge_default: true. See the HTTP API.

  • 22 Aug: Publication waiting is first-class in the SDKs. TypeScript @littlebigbrain/client 0.11.1 and Python littlebigbrain 0.11.1 give publication waiters their own deadline, continue through retryable 429 responses, and treat a missing first generation as normal build progress. Waiters finish when the requested data is queryable. MCP 0.4.1 includes the same behavior.

  • 22 Aug: Faster Explorer class browsing. Opening a populated class now loads a bounded sample instead of transferring the whole graph, keeping the Explorer responsive as datasets grow.

  • 22 Aug: Hosted account and stack administration is simpler. First-stack provisioning derives ownership from the authenticated WorkOS identity and no longer waits on graph publication. Owner and admin now share one administrator capability model, including member and access-key management. The console makes graph cards directly selectable, removes the unfinished Billing and Status views, and trims read-only Settings states.

  • 21 Aug: SPARQL is the only public query surface. The HTTP API keeps /v1/query/sparql, /v1/query/sparql-text, /sparql, /update, and /rdf-graph-store; the search-family, embedding, grounding, graph-traversal, and structured-DSL routes were removed. TypeScript and Python 0.11.0 and MCP 0.4.0 carry the same breaking surface change. The underlying lexical, vector, and hybrid engine remains in the product and will return to public APIs as those surfaces stabilize.

  • 21 Aug: Faster graph-shaped SPARQL. Exact multi-hop and selective relationship queries now do less work while returning the same results.

  • 21 Aug: Corpus-scale RDF ingest. RDF imports can defer publication while a large, chunked load is in progress, then publish once at the final watermark. The bulk loader supports bounded memory and resumable input for corpora with hundreds of millions of triples. See Load RDF data.

  • 20 Aug: Reliable SPARQL joins across all RDF term orders. Join results are now independent of the order in which RDF terms entered a graph.

  • 19 Aug: Temporal extraction over Gregorian fragments. YEAR() accepts xsd:gYear and xsd:gYearMonth alongside xsd:dateTime and xsd:date, and MONTH() accepts xsd:gYearMonth, so SUM(YEAR(?o)) over a corpus that types years as gYear (DBLP does) answers the sum instead of silently returning zero. Component-less combinations stay type errors, and an aggregate whose every input errored now comes back unbound. See FILTER comparisons and datatypes.

  • 18 Aug: Faster range filters and string functions. Numeric, date, and string filters now avoid scanning unrelated values, with the improvement verified on a 568.8-million-fact DBLP corpus.

  • 18 Aug: Clearer FILTER behavior for temporal values. Value comparison is now defined for same-datatype temporal and duration types: xsd:dateTime, xsd:date, xsd:time, the Gregorian fragments, and the two duration types. Undefined comparisons are reported distinctly from a valid comparison that matched no rows.

  • 15 Aug: Whole-graph statistics from publish-time artifacts. Grouped statistics, key histograms, and predicate inventories answer from artifacts computed when a generation publishes, so schema-wide rollups skip the scan of the full graph.

  • 14 Aug: Faster scans with per-query memory bounds. Streaming scans read ahead in parallel windows, each read is admitted against a memory budget, and result sets are bounded, so one heavy query cannot destabilize a serving node.

  • 13 Aug: Faster counting and point lookups. COUNT and COUNT(DISTINCT ...) aggregate through sorted-run merges with tiered distinct counting, and point queries anchored at a known entity read a bounded set of index blocks.

  • 9 Aug: Interrupted publications resume, and unreferenced index storage is reclaimed. A publication that stops partway resumes from its last durable step instead of restarting, and index objects that no published generation references are deleted under retention rules.

  • 6 Aug: Incremental index maintenance. Steady-state writes fold into the published indexes incrementally, so update cost tracks the size of the change instead of the size of the graph.

  • 6 Aug: Bounded reads on highly connected entities. Reading an entity back costs work proportional to that entity’s own connections, and neighborhood listings apply explicit per-direction caps, so densely connected entities stay fast to inspect.

  • 2 Aug: Memory-bounded indexing at every scale. Every index build runs within a fixed memory budget regardless of graph size, verified in production under a 4 GiB ceiling.

July 2026

Section titled “July 2026”
  • 30 Jul: Durable large imports. An import runs as a durable job that continues across restarts and reports progress while it runs, and the TypeScript and Python 0.9.0 clients stream NDJSON request bodies instead of buffering them. See Load RDF data.
  • 27 Jul: SHACL remains active as ontologies evolve. Active shapes move to the new ontology version atomically, and common minCount and maxCount constraints stay reliable on large graphs.
  • 27 Jul: Sign-in stays available during heavy indexing. Account sign-in and stack sessions respond independently of index publication load.
  • 24 Jul: Redesigned ontology and instance navigation. Explorer navigates from ontology classes to their instances and back with grouped relationships, and the console is simplified around published snapshots.
  • 21 Jul: Selectable read consistency. Reads default to the published snapshot, a writer immediately reads its own writes, and a request can select the freshest view when it needs read-after-write across clients. The console Query and Explorer views expose the same option.
  • 20 Jul: Graph fork and reload. Fork copies a graph into a new graph through copy-on-write metadata without duplicating stored data, and reload replaces a graph’s contents as one declarative operation. Both are in the HTTP contract and the TypeScript and Python 0.7.0 clients.
  • 20 Jul: Revocable access keys. Stack access keys have an explicit lifecycle, and revoking a key takes effect immediately.
  • 19 Jul: Faster SPARQL on large graphs. SELECT results stream as rows, decoding runs in parallel, ORDER BY ... LIMIT answers from sorted indexes, storage blocks are columnar and compressed, and a snapshot-keyed result cache returns repeated queries without re-execution.
  • 18 Jul: Faster summaries and bounded exploration. The graph summary, conformance, and metadata endpoints respond faster, and Explorer reads on large graphs are bounded, with the applied caps reported.
  • 16 Jul: Dedicated stack endpoints. Every stack serves at its own address, <tenant-short-id>--<stack-slug>.db.eu.littlebigbrain.com, and the SDKs and docs use the stack endpoint everywhere.
  • 16 Jul: Named access keys and guided onboarding. A stack issues multiple named access keys alongside its default key, and the console shows a first-run checklist from stack creation to first query.
  • 15 Jul: Managed embeddings with a model catalog. Pick an embedding model by name and the service embeds documents and queries with it. Committed bring-your-own vectors keep working alongside.
  • 15 Jul: Uniform backpressure with automatic retries. Overload answers 429 with a Retry-After header on every route, and the TypeScript and Python 0.6.0 clients retry within a request deadline.
  • 12 Jul: Build identity for support. Every database response identifies its build and replica, making deployment issues easier to diagnose.
  • 11 Jul: Bulk export. A graph exports as full-fidelity NDJSON, usable for backup and for moving data between stacks.
  • 10 Jul: SPARQL and SHACL run against persisted graphs. The full query and validation engines execute directly over graphs in object storage, with worst-case-optimal joins for multi-way graph patterns.
  • 10 Jul: Set-valued properties. A property holds a set of values, with indexed membership filters for shapes such as tags and categories.
  • 10 Jul: Turtle imports in the console. The console imports RDF Turtle files directly.
  • 7 Jul: Entity canonicalization. SAME_AS edges merge renamed and duplicate entities into one result, carrying the merged names in an aliases field.
  • 6 Jul: Validate-then-merge branches (POST /v1/graph/branch/merge). Replay a child branch onto its fork parent as one validated commit, with supersedure_race conflicts enumerated in the response. See branch-per-session workspaces.
  • 6 Jul: Time-travel everywhere. The bitemporal cursor (as_of_commit_seq / as_of_valid_time) pins every read surface, so any cited result set stays reproducible. See time-travel audit.
  • 6 Jul: Write-repair errors. A rejected write names the violated constraint and suggests the nearest valid input, so an agent can self-correct instead of guessing.
  • 6 Jul: One-call grounded answers. POST /v1/ask takes a question, retrieves the supporting facts, and returns an answer with cited evidence and an explain block that shows the retrieval steps.
  • 5 Jul: Console browsing with your session. A signed-in console session browses stack data directly; entering an access key is no longer required for reading.
  • 2 Jul: Redesigned console. The console is rebuilt with reorganized navigation, a visual ontology editor, and guided activation steps for a new stack.

June 2026

Section titled “June 2026”
  • 30 Jun: 3x faster bulk ingest. Commit writes to object storage are pipelined, measured at 3x the previous bulk-ingest throughput.
  • 26 Jun: SPARQL-subset aggregation. COUNT, SUM, and AVG with GROUP BY over entity, scalar-attribute, and calendar date-bucket keys, on a typed value channel, so a per-area or per-month rollup is one server-side query. See SPARQL & SHACL.
  • 26 Jun: Bulk NDJSON import, stable external keys, and retraction. POST /v1/graph/import ingests NDJSON streams, a record can carry a stable external key so a re-import updates the same entity instead of creating a duplicate, and retract removes previously asserted facts. The SDKs and MCP expose all three. See Load RDF data.
  • 25 Jun: Type-closure reasoning. An RDFS subClassOf hierarchy resolved at query time, so a query for a broad type returns its subtypes with no rebuild. See reasoning.
  • 24 Jun: Ontology conformance reports. /v1/ontology/conformance audits published data against the active ontology, available through the SDKs, MCP, and the console.
  • 23 Jun: Additive ontology evolution. Widen a relation’s domain or range or add entity types by name, with ontology-version stamping, preserving every existing record.
  • 21 Jun: Typed value channel. Typed literals, so numbers and dates filter and aggregate server-side instead of matching strings.
  • 20 Jun: Bounded SHACL-AF inference rules. Derive new edges to a bounded fixpoint and include them in queries with reason.
  • 19 Jun: Hosted MCP. Connect an MCP client to a stack with your account sign-in over OAuth; agents query and write through MCP tools without handling raw access keys.
  • 11 Jun: Reliable reads during ongoing writes. Published graph snapshots keep queries stable while new data continues to arrive.