rushdb
ProductSolutionsDevelopersPricingResourcesCompanyGitHub
Sign InStart building

Understand

Context layer

Why shared operational context needs its own infrastructure layer.

Product overview

Create, inspect, retrieve, use, and operate connected context.

Architecture

See the data model, query surfaces, and deployment boundaries.

Build

Ingestion and live schema

Turn evolving payloads into typed, inspectable structure.

Graph and relationships

Preserve known links and review suggested patterns.

Semantic retrieval

Combine similarity, exact filters, and connected records.

Smart Search

Generate inspectable SearchQuery from natural language.

Operate

Query and analytics

Use one query shape across records, schema, and metrics.

Deployment options

Use managed cloud, an External Database, or self-hosted infrastructure.

Security

Review privacy, controls, and deployment posture.

Explore the product →

Primary workflows

Agent context and memory

Durable state, decisions, tool output, and semantic recall.

GraphRAG

Retrieve connected evidence, not only similar chunks.

Applications

Build operational software on connected context.

Operational analytics

Analyze current values, relationships, and change.

Solution patterns

Customer intelligence

Connect customer, product, support, and event data.

Search and discovery

Power semantic, faceted, and connected discovery.

Evidence and compliance

Keep operational evidence connected and inspectable.

Blueprints

Agent systemsConnected applicationsAnalytical systemsAll blueprints
Explore all solutions and blueprints →

Documentation

Concepts, tutorials, deployment, and API guides.

Quickstart

Create a project and run your first query.

TypeScript SDK

Type-safe access for browser and Node.js applications.

Python SDK

Sync and async access for services and data workflows.

MCP server

Expose RushDB operations to MCP-compatible clients.

Agent skills

Install task guidance for memory, querying, and modelling.

Open documentation →

Guides

Evergreen explanations and implementation paths.

Comparisons

Evaluate RushDB against graph, vector, and memory tools.

Blog

Product updates and technical articles.

Architecture

Understand the data path and current boundaries.

Changelog

Follow product and platform releases.

LMPG research

Separate the property-centric implementation from research direction.

Explore resources →

Contact

Discuss product, architecture, or enterprise requirements.

Security

Security, privacy, and responsible disclosure.

Open source

Review the source, open issues, and contribute.

Contact RushDB →
rushdb

Open-source context infrastructure for agents, applications, and analytics, with connected records, live schema, semantic retrieval, and operational queries through one API.

GitHubDiscord

Product

Context layerProduct overviewArchitecturePricingSecurityDeployment

Solutions

Agent contextGraphRAGApplicationsOperational analyticsBlueprint library

Developers

DocsQuick startAPI referenceTypeScript SDKPython SDKMCP serverAgent skills

Resources

GuidesComparisonsBlogChangelogOpen sourceContactSelf-hosting

© 2026 Collect Software Inc.

PrivacyTermsCookies
Engineering4 min read6th July 2025

Rethinking the Graph: How Labeled Meta-Property Graphs Unlock Structure Without Sacrificing Flexibility

By RushDB Team
On this page
  1. A Metadata-Centric Breakthrough for Data Teams Battling Schema Chaos
  2. The Core Problem: Properties as Second-Class Citizens
  3. Enter LMPG: The Metadata-First Graph Model with Structural Guarantees
  4. RushDB: The First Production Graph Engine Built on LMPG
  5. LMPG in the Wild: Real-World Wins
  6. Final Thoughts: Structure That Evolves With You

On this page

  1. A Metadata-Centric Breakthrough for Data Teams Battling Schema Chaos
  2. The Core Problem: Properties as Second-Class Citizens
  3. Enter LMPG: The Metadata-First Graph Model with Structural Guarantees
  4. RushDB: The First Production Graph Engine Built on LMPG
  5. LMPG in the Wild: Real-World Wins
  6. Final Thoughts: Structure That Evolves With You

RushDB

Give your agent a memory.

Push any JSON. Get graph relationships and vector search instantly — no schema, no pipeline, no setup.

Start building free →

FAQ

Related reading

GraphRAGVector SearchRAG Architecture

Vector RAG vs GraphRAG vs Agentic RAG: Why There Is No Winner

Vector RAG, GraphRAG, and Agentic RAG preserve different context. Learn when each works, where each fails, and how to combine them in one app.

28 min readRead →
AI agentsagent memorypersistent memory

Persistent Agent Memory for OpenClaw and Hermes with RushDB

RushDB brings scoped, durable, lifecycle-aware memory to OpenClaw and Hermes Agent through native connectors and one shared event contract.

10 min read
Read →
vector searchgraph databasehybrid retrieval

Vector Search Doesn't Understand Data Structure

Embeddings rank similarity but ignore joins, cardinality, and constraints. Learn how RushDB combines semantic retrieval with explicit graph relationships and live schema discovery.

15 min readRead →

A Metadata-Centric Breakthrough for Data Teams Battling Schema Chaos

In today’s world of messy, evolving, and high-dimensional data, property graphs are the de facto choice for modeling relationships. But there’s a problem. Traditional property graphs—where key-value pairs are embedded inside nodes—are starting to feel like rigid spreadsheets trapped in a graph’s body.

As datasets grow in complexity, and metadata becomes just as important as the data itself, a new model is emerging from research labs and production systems alike: the Labeled Meta-Property Graph (LMPG).

Let’s break it down.


The Core Problem: Properties as Second-Class Citizens

In conventional property graphs, properties are just passive attributes—strings, numbers, flags—sitting on the sidelines. They have no identity, no metadata, no traceability. You can’t query “What kind of properties exist in my graph?” or “Which entities have a property of type string called color?” without scanning everything.

This leads to three major issues:

  • 💀 No Schema Discovery You can't reliably answer what your data looks like—at least not without dumping and diffing half the graph.

  • 🕳 No Metadata-Driven Querying Good luck finding all records that use the same field across labels or domains.

  • 🔧 Fragile Schema Evolution Adding new property types or changing usage patterns risks breaking implicit assumptions baked into your app logic.


Enter LMPG: The Metadata-First Graph Model with Structural Guarantees

Labeled Meta-Property Graphs (LMPGs) advance the concept of Meta-Property Graphs by making one architectural decision clear:

Each property node is not only queryable—it is labeled with a name and type that define how the value behaves.

In RushDB’s implementation:

Text
(Record A {temperature: 42}) <-[:PROPERTY_RELATION]- (Property {name: "temperature", type: "number"})

This simple topology enables semantically typed metadata—where every piece of data knows exactly which property name and type it’s associated with.

This enables:

  • 🧠 Typed Traversals Traverse to all records that use string properties called "status" or all number properties named "concentration", without touching full-text.

  • 🔍 First-Class Schema Indexing Property nodes act like centralized indexes for fields across labels—fully inspectable, filterable, and linked.

  • 🧬 Evolution Without Breakage New properties? No problem. They become new Property nodes. Existing data stays untouched, queries stay consistent.


RushDB: The First Production Graph Engine Built on LMPG

While others experiment, RushDB natively implements the Labeled Meta-Property Graph architecture as its core data model. This isn't an overlay or plugin—it’s the foundation.

Here's how RushDB does it:

  • ✅ Metadata Nodes with Labels and Types Every property is modeled as a Property node with enforced {name, type} structure—allowing type-safe semantics and query planning.

  • ✅ Records Store Values Inline, Structure via Graph For performance, values live inside Record nodes—but structure is captured relationally in the graph itself.

  • ✅ Automatic Property Discovery & Linking on Ingest RushDB’s BFS JSON parser walks nested data and autogenerates labeled Property nodes on-the-fly, linking every record through PROPERTY_RELATION edges.

  • ✅ Self-Descriptive, Introspectable Graphs Any dataset ingested becomes its own living schema. Just query MATCH (p:Property) to explore the ontology.


LMPG in the Wild: Real-World Wins

Use CaseHow LMPG via RushDB Helps
🔬 Scientific lab dataUnify LIMS/ELN fields by type+name, detect anomalies in measurements
📊 Schema governanceTrack field usage across records dynamically without external docs
⚖️ Regulatory reportingProve field type and lineage without brittle schema migrations
🧠 AI/ML preprocessingSelect semantically compatible fields for training pipelines
🧱 Schema-on-read at scaleAdd structure post-ingest without up-front schema constraints

Final Thoughts: Structure That Evolves With You

Most graph databases either go rigid schema or total schema-less chaos. RushDB, powered by Labeled Meta-Property Graphs, gives you the best of both:

  • Schema emerges as your data grows
  • Metadata becomes actionable infrastructure
  • Querying becomes semantically grounded

If you're building anything with unstructured, API-fed, JSON-heavy, cross-domain data—and want schema governance without rigidity—RushDB is ready to serve your use case.

This is not a theory. It’s real, open-source, production-ready graph infrastructure that thinks in terms of labels, types, and relationships—even at the property level.


Start modeling with context, not just connections.

→ Try RushDB now

→ Explore the open-source SDK

→ Want help modeling your dataset? Book a free consult