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

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, 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) 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) 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) 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) 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, with SPARQL-compatible implementations for five distinct engines.

RDF4J

The RDF4J backend (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) 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) 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) 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) 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) 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) 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:

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:

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:

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 and 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) 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) 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}