# How to Switch Between RDF and LPG Graph Stores in Semantica

> Easily switch between RDF and LPG graph stores in Semantica. Learn how to select the correct facade class and configure your backend for seamless data management.

- Repository: [Semantica /semantica](https://github.com/semantica-agi/semantica)
- Tags: how-to-guide
- Published: 2026-08-17

---

**Switch between RDF and LPG stores in Semantica by choosing the appropriate facade class—**`TripletStore`** for RDF triplets or **``GraphStore``** for labeled property graphs—and specify your backend via the **``backend``** parameter or environment variables.**

Semantica provides distinct storage facades for **Resource Description Framework (RDF)** triple stores and **Labeled Property Graph (LPG)** databases, allowing you to abstract concrete backends behind a unified API. Whether you need semantic web compatibility via Blazegraph or Jena, or high-performance graph analytics via Neo4j or Apache AGE, the `semantica-agi/semantica` codebase enables seamless transitions without rewriting your data access logic.

## Understanding the Storage Architecture

Semantica separates graph storage into two primary models:

| Model | Primary API | Typical Backends |
|-------|-------------|------------------|
| **RDF (triplet) store** | `semantica.triplet_store.TripletStore` | Blazegraph, Jena, RDF4J, Anzo, Oxigraph |
| **LPG (labeled property graph) store** | `semantica.graph_store.GraphStore` | Neo4j, Apache AGE, FalkorDB, Amazon Neptune |

Both classes act as facades that hide implementation details behind a single `backend` constructor argument. This design allows you to swap underlying databases while maintaining identical CRUD operations across your application.

## Configuring the RDF Store (TripletStore)

The **RDF facade** supports multiple backends listed in the class constant `SUPPORTED_BACKENDS` defined in [`semantica/triplet_store/triplet_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/triplet_store.py)【semantica/triplet_store/triplet_store.py#L48-L55】.

To instantiate an RDF store with a specific backend, pass the backend name and connection parameters:

```python
from semantica.triplet_store import TripletStore

# Default Blazegraph backend

rdf_store = TripletStore(backend="blazegraph", endpoint="http://localhost:9999/blazegraph")

# Switch to Apache Jena

rdf_store = TripletStore(backend="jena", endpoint="http://localhost:3030/ds")

# Switch to RDF4J

rdf_store = TripletStore(backend="rdf4j", endpoint="http://localhost:8080/rdf4j-server")

```

All operations—including `add_triplet()`, `add_triplets()`, and `execute_query()`—remain consistent regardless of which backend you select.

## Configuring the LPG Store (GraphStore)

The **LPG facade** (`GraphStore`) reads default configuration from `GraphStoreConfig._set_defaults` in [`semantica/graph_store/config.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/config.py)【semantica/graph_store/config.py#L81-L86】, defaulting to Neo4j if no environment variable is set.

```python
from semantica.graph_store import GraphStore

# Uses default backend from GRAPH_STORE_DEFAULT_BACKEND env var or config (defaults to neo4j)

lpg_store = GraphStore()

# Explicitly specify Neo4j with URI

lpg_store = GraphStore(backend="neo4j", uri="bolt://my-host:7687")

# Use Apache AGE backend

lpg_store = GraphStore(backend="age", host="localhost", port=5432)

```

Supported LPG backends include `"neo4j"`, `"age"`, `"falkordb"`, and `"neptune"`, each activated through the same `backend` parameter.

## Runtime Switching and Data Migration

Because the two facades are independent, you can maintain concurrent connections and migrate data between paradigms:

```python

# 1. Load from RDF source

rdf_store = TripletStore(backend="blazegraph")
triplets = rdf_store.get_triplets()

# 2. Convert triplets to LPG entities using Semantica helpers

from semantica.utils.helpers import triplets_to_lpg
nodes, relationships = triplets_to_lpg(triplets)

# 3. Persist to LPG store

lpg_store = GraphStore(backend="neo4j", uri="bolt://localhost:7687")

for node in nodes:
    lpg_store.create_node(labels=node.labels, properties=node.props)

for rel in relationships:
    lpg_store.create_relationship(
        rel.start, rel.end, rel.type, rel.props
    )

```

For exporting data back to RDF formats, use the export subsystem:

```python
from semantica.export import RDFExporter, LPGExporter

# Export LPG to Cypher

lpg_exporter = LPGExporter()
lpg_exporter.export(lpg_store, file_path="graph.cypher")

# Export LPG to RDF/Turtle

rdf_exporter = RDFExporter()
rdf_str = rdf_exporter.export_to_rdf(lpg_store, format="turtle")

```

The conversion utilities are implemented in [`semantica/utils/helpers.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/utils/helpers.py), while export functionality resides in [`semantica/export/rdf_exporter.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/export/rdf_exporter.py) and [`semantica/export/lpg_exporter.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/export/lpg_exporter.py).

## Environment-Driven Backend Selection

For declarative configuration, set environment variables before launching your application:

```bash
export GRAPH_STORE_DEFAULT_BACKEND=age   # Switches LPG to Apache AGE

export RDF_STORE_DEFAULT_BACKEND=jena    # Switches RDF to Apache Jena

python my_semantica_app.py

```

When `GRAPH_STORE_DEFAULT_BACKEND` is set, `GraphStore()` initializes without requiring an explicit `backend` argument:

```python
from semantica.graph_store import GraphStore
store = GraphStore()  # Automatically uses Apache AGE from environment

```

## Summary

- **Choose the correct facade**: Use `TripletStore` for RDF triplets and `GraphStore` for property graphs.
- **Specify backends via constructor**: Pass `backend="blazegraph"` or `backend="neo4j"` to switch databases instantly.
- **Leverage environment variables**: Set `GRAPH_STORE_DEFAULT_BACKEND` or `RDF_STORE_DEFAULT_BACKEND` for configuration-free initialization.
- **Migrate data at runtime**: Use `triplets_to_lpg()` helpers and export classes to convert between storage models without data loss.
- **Consistent API**: All CRUD methods remain identical across backends, ensuring your application logic stays portable.

## Frequently Asked Questions

### Can I use both RDF and LPG stores in the same application?

Yes. The `TripletStore` and `GraphStore` classes operate independently, allowing you to instantiate both simultaneously. You can read from an RDF backend using `semantica.triplet_store.TripletStore`, transform the data using `semantica.utils.helpers.triplets_to_lpg()`, and write to an LPG backend via `semantica.graph_store.GraphStore` in a single script.

### How do I check which backends are supported by my Semantica installation?

For RDF stores, inspect the `SUPPORTED_BACKENDS` class attribute in [`semantica/triplet_store/triplet_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/triplet_store.py). For LPG stores, check the `GraphStoreConfig` class in [`semantica/graph_store/config.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/config.py), which defines available backends and their default connection parameters.

### What is the default backend if I do not specify one?

`GraphStore` defaults to Neo4j (`"neo4j"`) as defined in `GraphStoreConfig._set_defaults` unless overridden by the `GRAPH_STORE_DEFAULT_BACKEND` environment variable. `TripletStore` typically defaults to Blazegraph if no backend argument is provided, though this depends on your specific Semantica version configuration.

### Can I switch backends without restarting my Python process?

Yes. Since the backend selection occurs at instantiation time, you can create new store instances with different backends while the process runs. However, existing store objects maintain their original backend connections. To switch an active connection, instantiate a new `TripletStore` or `GraphStore` with the desired `backend` parameter and migrate data as needed using the export and conversion utilities.