# What RDF and LPG Graph Stores Does Semantica Support? A Complete Backend Guide

> Semantica supports Neo4j, FalkorDB, Neptune, AGE for LPG and RDF4J, Blazegraph, Jena, Oxigraph, Anzo for RDF. Explore this backend guide for seamless integration.

- Repository: [Semantica /semantica](https://github.com/semantica-agi/semantica)
- Tags: backend-guide
- Published: 2026-09-13

---

**Semantica supports four property-graph (LPG) backends—Neo4j, FalkorDB, Amazon Neptune, and Apache AGE—and five RDF triple stores including RDF4J, Blazegraph, Apache Jena (TDB2), Oxigraph, and Anzo, all unified under abstracted `GraphStore` and `TripletStore` interfaces.**

Semantica is an open-source semantic AI framework from `semantica-agi/semantica` that eliminates vendor lock-in by providing unified abstractions over diverse graph database technologies. Whether you are building knowledge graphs requiring SPARQL semantics or high-performance traversals with Cypher, understanding which RDF and LPG graph stores Semantica supports enables optimal infrastructure decisions. The framework automatically selects the appropriate driver based on a simple `backend` configuration parameter, allowing seamless migration between stores without application code changes.

## LPG Graph Stores Supported by Semantica

Semantica implements a unified **Property-Graph (LPG)** interface in [`semantica/graph_store/graph_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/graph_store.py), with concrete drivers for four production-grade backends. Each driver translates Semantica’s generic node and relationship operations into native queries.

### Neo4j

The **Neo4j** backend ([`semantica/graph_store/neo4j_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/neo4j_store.py)) provides the industry-standard native graph database implementation using the Bolt protocol. It supports Cypher query language execution and is ideal for transactional graph applications requiring ACID compliance.

### FalkorDB

**FalkorDB** ([`semantica/graph_store/falkordb_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/falkordb_store.py)) offers a Redis-based graph engine with a Cypher-compatible API. This backend suits high-velocity scenarios where in-memory performance and Redis ecosystem integration are priorities.

### Amazon Neptune

The **Amazon Neptune** driver ([`semantica/graph_store/amazon_neptune.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/amazon_neptune.py)) connects to AWS’s fully-managed graph service, supporting both openCypher and Gremlin query languages. This backend is optimized for cloud-native deployments requiring automatic scaling and high availability.

### Apache AGE

**Apache AGE** ([`semantica/graph_store/age_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/age_store.py)) implements a PostgreSQL extension that adds native graph modeling capabilities to existing relational infrastructure. It enables Cypher queries within PostgreSQL, making it suitable for organizations seeking to extend current RDBMS investments with graph functionality.

## RDF Triple Stores Supported by Semantica

For **RDF (Resource Description Framework)** workloads, Semantica provides the `TripletStore` abstraction defined in [`semantica/triplet_store/triplet_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/triplet_store.py), with SPARQL-compatible implementations for five distinct engines.

### RDF4J

The **RDF4J** backend ([`semantica/triplet_store/rdf4j_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/rdf4j_store.py)) connects to Java-based SPARQL endpoints over HTTP. It serves as a robust choice for standards-compliant RDF storage and federation scenarios.

### Blazegraph

**Blazegraph** ([`semantica/triplet_store/blazegraph_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/blazegraph_store.py)) delivers high-performance RDF storage with full SPARQL 1.1 support. This backend excels in analytics-heavy applications requiring fast batch loading and complex join operations.

### Apache Jena (TDB2)

The **Apache Jena** driver ([`semantica/triplet_store/jena_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/jena_store.py)) interfaces with Jena’s native TDB2 persistent storage engine via SPARQL. It is the preferred choice for research environments and applications requiring sophisticated inference rule processing.

### Oxigraph

**Oxigraph** ([`semantica/triplet_store/oxigraph_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/oxigraph_store.py)) provides a Rust-based SPARQL engine that can be embedded as a library. This backend targets performance-critical applications requiring memory-safe, low-latency RDF operations.

### Anzo

The **Anzo** backend ([`semantica/triplet_store/anzo_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/anzo_store.py)) supports Cambridge Semantics’ enterprise-grade RDF store. This commercial backend is designed for enterprise knowledge graphs requiring advanced data governance and semantic layer capabilities.

## Core Architecture and Abstraction Layers

Semantica’s architecture decouples application logic from storage implementation through two primary abstract base classes.

The **Graph Store core** ([`semantica/graph_store/graph_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/graph_store.py)) defines the `GraphStore` interface, which exposes methods like `create_node()`, `execute_query()`, and `connect()`. Concrete implementations in the individual backend files inherit from this base and handle protocol-specific connection management, authentication, and query translation.

The **Triplet Store core** ([`semantica/triplet_store/triplet_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/triplet_store.py)) specifies the `TripletStore` interface, standardizing operations such as `add_triplet()` and `execute_sparql()`. Each RDF backend implements these methods to translate SPARQL queries into native API calls, whether HTTP requests to RDF4J or direct library invocations for Oxigraph.

## Practical Implementation Examples

### Connecting to an LPG Store (Neo4j)

Initialize a Neo4j-backed graph store by specifying the `backend` parameter and connection credentials:

```python
from semantica.graph_store import GraphStore

store = GraphStore(backend="neo4j", uri="bolt://localhost:7687", auth=("neo4j", "secret"))
store.connect()
store.create_node(labels=["Person"], properties={"name": "Alice"})
results = store.execute_query("MATCH (n:Person) RETURN n")
print(results["records"])
store.close()

```

To switch to **FalkorDB**, **Amazon Neptune**, or **Apache AGE**, change `backend="neo4j"` to `"falkordb"`, `"amazon_neptune"`, or `"age"` respectively, and adjust the connection parameters according to each backend’s requirements in the corresponding source files.

### Querying an RDF Store (RDF4J)

Instantiate an RDF backend using the `TripletStore` factory with the appropriate endpoint configuration:

```python
from semantica.triplet_store import TripletStore

store = TripletStore(backend="rdf4j",
                     endpoint="http://localhost:8080/rdf4j-server",
                     repository_id="myrepo")
store.connect()
store.add_triplet(subject="http://example.org/Alice",
                 predicate="http://xmlns.com/foaf/0.1/name",
                 obj="Alice")
sparql = "SELECT ?s ?p ?o WHERE { ?s ?p ?o } LIMIT 5"
result = store.execute_sparql(sparql)
print(result["bindings"])
store.close()

```

Alternative RDF backends like **Blazegraph**, **Jena**, **Oxigraph**, or **Anzo** require only changing the `backend` argument to `"blazegraph"`, `"jena"`, `"oxigraph"`, or `"anzo"` and updating endpoint URLs.

### Integrating LPG and RDF Workflows

Semantica allows simultaneous connections to both store types for hybrid knowledge graph architectures:

```python
from semantica.graph_store import GraphStore
from semantica.triplet_store import TripletStore

# LPG store for property-graph traversals

graph = GraphStore(backend="neo4j", uri="bolt://localhost:7687")
graph.connect()

# RDF store for semantic triple operations

triple = TripletStore(backend="blazegraph",
                      endpoint="http://localhost:9999/blazegraph")
triple.connect()

# Export LPG node to RDF format

node = graph.create_node(labels=["Concept"], properties={"id": "C1", "label": "Planet"})
rdf = f"<{node['properties']['id']}> <http://example.org/hasLabel> \"{node['properties']['label']}\" ."
triple.add_rdf(rdf)

```

This pattern enables workflows where operational data resides in high-performance LPG stores while semantic reasoning occurs in specialized RDF engines.

## Summary

- **Four LPG backends**: Neo4j, FalkorDB, Amazon Neptune, and Apache AGE, implemented in `semantica/graph_store/` with a unified `GraphStore` interface.
- **Five RDF backends**: RDF4J, Blazegraph, Apache Jena (TDB2), Oxigraph, and Anzo, implemented in `semantica/triplet_store/` with a unified `TripletStore` interface.
- **Unified abstraction**: Core interfaces in [`graph_store.py`](https://github.com/semantica-agi/semantica/blob/main/graph_store.py) and [`triplet_store.py`](https://github.com/semantica-agi/semantica/blob/main/triplet_store.py) decouple application logic from storage specifics.
- **Backend switching**: Change the `backend` initialization parameter to migrate between stores without modifying query logic.
- **Hybrid support**: Simultaneous connections to both LPG and RDF stores enable complex data pipelines leveraging the strengths of each paradigm.

## Frequently Asked Questions

### Can I migrate between different graph stores without rewriting my application code?

Yes. Semantica’s abstract `GraphStore` and `TripletStore` interfaces allow you to switch backends by changing only the `backend` parameter and connection configuration during initialization. Your `execute_query()` or `execute_sparql()` calls remain identical across Neo4j, FalkorDB, Amazon Neptune, and Apache AGE for LPG workloads, and across all five supported RDF engines for triple store operations.

### Does Semantica support both Cypher and SPARQL query languages?

Yes. LPG backends including Neo4j, FalkorDB, Amazon Neptune, and Apache AGE support **Cypher** (or openCypher) through the `GraphStore.execute_query()` method. RDF backends including RDF4J, Blazegraph, Jena, Oxigraph, and Anzo support **SPARQL** through the `TripletStore.execute_sparql()` method, as implemented in their respective store files.

### Which RDF backend offers the best performance for embedded applications?

**Oxigraph** ([`semantica/triplet_store/oxigraph_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/oxigraph_store.py)) is optimized for embedded, high-performance scenarios. Built in Rust, it provides memory-safe operations and can be embedded as a library, eliminating network overhead and delivering lower latency than HTTP-based alternatives like RDF4J or Blazegraph.

### Is Amazon Neptune supported for both property-graph and RDF data?

According to the `semantica-agi/semantica` source code, Amazon Neptune is currently implemented as an **LPG store** ([`semantica/graph_store/amazon_neptune.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/amazon_neptune.py)) supporting openCypher and Gremlin. For pure RDF workloads, you should use one of the dedicated triple store backends such as RDF4J, Blazegraph, or Apache Jena.