# What RDF and LPG Graph Stores Are Compatible with Semantica

> Discover which RDF and LPG graph stores are compatible with Semantica. Explore supported databases like Neo4j, RDF4J, Neptune, Blazegraph, and more for your graph data needs.

- Repository: [Semantica /semantica](https://github.com/semantica-agi/semantica)
- Tags: compatibility-list
- Published: 2026-09-12

---

**Semantica supports nine graph database backends: four LPG (Property Graph) stores including Neo4j, FalkorDB, Amazon Neptune, and Apache AGE, plus five RDF stores including RDF4J, Blazegraph, Apache Jena (TDB2), Oxigraph, and Anzo.**

The `semantica-agi/semantica` repository provides a unified Python abstraction layer for knowledge graph applications. Understanding what RDF and LPG graph stores are compatible with Semantica enables developers to switch between property-graph and triple-store paradigms without modifying application logic, using the factory methods defined in [`semantica/graph_store/graph_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/graph_store.py) and [`semantica/triplet_store/triplet_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/triplet_store.py).

## Supported LPG (Property Graph) Stores

Semantica implements the **GraphStore** interface in [`semantica/graph_store/graph_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/graph_store.py) and provides four native drivers for property-graph databases that support Cypher or Gremlin query languages.

### Neo4j

The **Neo4j** backend is implemented in [`semantica/graph_store/neo4j_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/neo4j_store.py) and provides access to the industry-standard native graph database. This driver supports the Bolt protocol for efficient client-server communication and implements methods including `connect()`, `create_node()`, and `execute_query()`.

### FalkorDB

The **FalkorDB** driver resides in [`semantica/graph_store/falkordb_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/falkordb_store.py) and connects to this Redis-based graph engine. FalkorDB offers a Cypher-compatible API, allowing Semantica to execute property-graph operations against Redis-backed datasets using the same interface as Neo4j.

### Amazon Neptune

Implemented in [`semantica/graph_store/amazon_neptune.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/amazon_neptune.py), the **Amazon Neptune** backend connects to AWS's fully managed graph service. This driver supports both openCypher and Gremlin endpoints, enabling Semantica applications to leverage managed cloud infrastructure while maintaining compatibility with standard graph query languages.

### Apache AGE

The **Apache AGE** backend in [`semantica/graph_store/age_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/age_store.py) provides a PostgreSQL extension that adds native graph model support. This driver allows Semantica to execute Cypher queries against existing PostgreSQL installations, bridging relational and graph database architectures.

## Supported RDF (Triple) Stores

For RDF datasets, Semantica defines the **TripletStore** interface in [`semantica/triplet_store/triplet_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/triplet_store.py) with five backend implementations supporting SPARQL 1.1 endpoints.

### RDF4J

The **RDF4J** backend in [`semantica/triplet_store/rdf4j_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/rdf4j_store.py) connects to the Java-based SPARQL endpoint over HTTP. This driver handles repository management and implements `add_triplet()` and `execute_sparql()` methods for standard RDF operations.

### Blazegraph

Implemented in [`semantica/triplet_store/blazegraph_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/blazegraph_store.py), the **Blazegraph** driver targets this high-performance RDF store. It supports SPARQL 1.1 queries and provides optimized batch loading capabilities for large-scale knowledge graphs.

### Apache Jena (TDB2)

The **Apache Jena** backend in [`semantica/triplet_store/jena_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/jena_store.py) interfaces with the TDB2 native storage engine. This driver enables Semantica to perform SPARQL queries against Jena's persistent triple store while supporting transactional updates.

### Oxigraph

The **Oxigraph** driver in [`semantica/triplet_store/oxigraph_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/oxigraph_store.py) implements a Rust-based SPARQL engine. Unlike server-based alternatives, Oxigraph can be embedded as a library, offering zero-configuration RDF storage for lightweight applications.

### Anzo

For enterprise deployments, the **Anzo** backend in [`semantica/triplet_store/anzo_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/anzo_store.py) connects to this commercial RDF store. This driver supports Anzo's proprietary extensions while maintaining standard SPARQL compatibility for enterprise knowledge graph initiatives.

## Implementation Examples

The following examples demonstrate initializing specific backends using the unified factory interfaces.

### Connecting to an LPG Store (Neo4j)

To instantiate a Neo4j-backed graph store, import `GraphStore` and specify the backend identifier:

```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()

```

*Alternative LPG backends*: Replace `backend="neo4j"` with `"falkordb"`, `"amazon_neptune"`, or `"age"` and provide the respective connection parameters documented in each backend file.

### Connecting to an RDF Store (RDF4J)

For RDF operations, use `TripletStore` with the appropriate backend string:

```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*: Use `"blazegraph"`, `"jena"`, `"oxigraph"`, or `"anzo"` as the backend parameter with connection arguments specific to each implementation.

### Switching Between LPG and RDF Stores

Semantica allows simultaneous connections to both store types within a single application:

```python

# LPG store for property-graph operations

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

# RDF store for SPARQL queries

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

# Export data between models

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

```

This interoperability pattern enables hybrid architectures where property-graph data can be serialized to RDF formats for semantic web integration.

## Summary

- **Semantica supports nine graph backends**: Four LPG stores (Neo4j, FalkorDB, Amazon Neptune, Apache AGE) and five RDF stores (RDF4J, Blazegraph, Apache Jena, Oxigraph, Anzo).
- **Unified interfaces** are defined in [`semantica/graph_store/graph_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/graph_store.py) (LPG) and [`semantica/triplet_store/triplet_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/triplet_store.py) (RDF).
- **Backend selection** occurs via the `backend` parameter when constructing `GraphStore` or `TripletStore` instances.
- **Driver implementations** reside in separate files within `semantica/graph_store/` and `semantica/triplet_store/` directories.
- **Cross-paradigm operations** allow applications to utilize both property-graph and RDF models simultaneously.

## Frequently Asked Questions

### Can Semantica migrate data between LPG and RDF formats?

Yes. Semantica's unified API allows you to read nodes and relationships from an LPG store via `GraphStore` and serialize them to RDF triples using a `TripletStore` instance. While the library provides the connection abstractions in [`semantica/graph_store/graph_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/graph_store.py) and [`semantica/triplet_store/triplet_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/triplet_store.py), you must implement the specific transformation logic to map property-graph schemas to RDF vocabularies.

### How does Semantica handle authentication for cloud-based graph stores?

Authentication parameters are passed as constructor arguments to the specific backend drivers. For example, the Amazon Neptune driver in [`semantica/graph_store/amazon_neptune.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/amazon_neptune.py) accepts AWS credential configurations, while the Neo4j driver accepts `auth` tuples. Each backend implementation in the `semantica-agi/semantica` repository documents its required authentication parameters in the respective store file.

### Which backend should I choose for high-performance SPARQL queries?

**Blazegraph** and **Apache Jena (TDB2)** provide optimized SPARQL 1.1 engines suitable for high-performance workloads according to the implementations in [`semantica/triplet_store/blazegraph_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/blazegraph_store.py) and [`semantica/triplet_store/jena_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/jena_store.py). For embedded applications without server infrastructure, **Oxigraph** ([`semantica/triplet_store/oxigraph_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/oxigraph_store.py)) offers a lightweight, Rust-based alternative that compiles directly into your Python application.

### Is it possible to use multiple backends simultaneously in one application?

Yes. You can instantiate multiple `GraphStore` and `TripletStore` objects with different `backend` parameters within the same Python process. Each maintains independent connection pools and state, allowing you to query a local **Neo4j** instance while simultaneously writing to a remote **RDF4J** repository, as demonstrated in the switching examples using [`semantica/graph_store/graph_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/graph_store.py) and [`semantica/triplet_store/triplet_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/triplet_store/triplet_store.py) interfaces.