# Semantica Polyglot Graph Storage Options: Supported Backends and Unified APIs

> Explore Semantica's polyglot graph storage options. Seamlessly switch between RDF triple stores and Labeled Property Graph databases with unified APIs and zero code changes.

- Repository: [Semantica /semantica](https://github.com/semantica-agi/semantica)
- Tags: api-reference
- Published: 2026-08-22

---

**Semantica supports interchangeable RDF triple stores (Oxigraph, Blazegraph, Apache Jena, RDF4J) and Labeled Property Graph databases (Neo4j, FalkorDB, Apache AGE, Amazon Neptune) through unified `GraphStore` and `TripletStore` APIs that require zero code modifications when switching backends.**

The semantica-agi/semantica framework implements a polyglot persistence layer that abstracts diverse graph storage technologies behind consistent Python interfaces. This architecture allows developers to prototype with lightweight embedded databases and migrate to production-grade distributed systems by modifying only connection parameters. Understanding the full range of **Semantica polyglot graph storage options** enables optimal backend selection for semantic web workloads, high-performance traversals, and vector-augmented retrieval.

## Graph Models and Supported Backends

Semantica distinguishes between two major graph storage paradigms, each with multiple swappable implementations.

### RDF Triple Store Options

For **semantic-web queries** and SPARQL-driven analytics, Semantica supports:

- **Oxigraph** – Embedded, zero-configuration store ideal for development and testing
- **Blazegraph** – High-performance SPARQL endpoint for production analytics
- **Apache Jena** – Mature Java-based triple store with comprehensive ontology support
- **Eclipse RDF4J** – Flexible SPARQL engine with broad standard compliance

These backends handle ontology-centric workloads and complex inferencing tasks through the `TripletStore` abstraction.

### Labeled Property Graph (LPG) Databases

For **graph traversals** and relationship-rich analytics, the `GraphStore` API supports:

- **Neo4j** – Production-grade graph database using the Cypher query language
- **FalkorDB** – Redis-backed ultra-low-latency graph for real-time applications
- **Apache AGE** – PostgreSQL extension that exposes Cypher over relational storage
- **Amazon Neptune** – Managed AWS graph service supporting OpenCypher

These options excel at recommendation engines, pathfinding, and real-time relationship queries.

### Vector Storage Extensions

Semantica optionally integrates **vector stores** including PGVector, FAISS, and Qdrant for storing dense embeddings. This enables similarity search and semantic retrieval capabilities alongside traditional graph storage.

## Implementing Polyglot Storage with GraphStore

The **`semantica.graph_store.GraphStore`** class presents a single, unified interface to all LPG backends. Instantiation requires only the `backend` parameter and connection-specific arguments.

### Connecting to Neo4j

```python
from semantica.graph_store import GraphStore

neo = GraphStore(
    backend="neo4j",
    uri="bolt://localhost:7687",
    user="neo4j",
    password="password",
)
neo.connect()
neo.create_node(labels=["Person"], properties={"name": "Alice"})
neo.close()

```

### Connecting to FalkorDB

```python
falkor = GraphStore(
    backend="falkordb",
    host="localhost",
    port=6379,
    graph_name="semantica",
)
falkor.connect()
falkor.create_node(labels=["Person"], properties={"name": "Bob"})
falkor.close()

```

### Connecting to Apache AGE

```python
age = GraphStore(
    backend="age",  # or "apache_age"

    connection_string="host=localhost dbname=agedb user=postgres password=secret",
    graph_name="semantica",
)
age.connect()
age.create_node(labels=["Person"], properties={"name": "Charlie"})
age.close()

```

### Connecting to Amazon Neptune

```python
neptune = GraphStore(
    backend="neptune",  # or "amazon_neptune"

    endpoint="my-cluster.neptune.amazonaws.com",
    port=8182,
    region="us-east-1",
    iam_auth=True,
)
neptune.connect()
neptune.create_node(labels=["Person"], properties={"name": "Dana"})
neptune.close()

```

Each implementation supports the `connect()`, `create_node()`, and `close()` methods with identical signatures, ensuring consistent behavior across vendors.

## SPARQL-Ready RDF Storage with TripletStore

For RDF-centric workloads, the **`semantica.triplet_store.TripletStore`** class automatically selects the appropriate triple-store implementation based on the `backend` parameter.

```python
from semantica.triplet_store import TripletStore

ts = TripletStore(backend="oxigraph")  # or "blazegraph", "jena", "rdf4j"

ts.connect()
ts.add_triplet("<http://example.org/Alice>", "rdf:type", "foaf:Person")
results = ts.query("SELECT ?s WHERE { ?s a foaf:Person }")
ts.close()

```

This abstraction handles SPARQL query translation and triple serialization regardless of whether the underlying engine is embedded (Oxigraph) or remote (Blazegraph).

## Architecture and Source Code Organization

The polyglot capabilities are implemented through adapter patterns in specific modules:

- **`semantica/graph_store/`** – Contains concrete LPG adapters including `Neo4jStore`, `FalkorDBStore`, `ApacheAgeStore`, and `AmazonNeptuneStore`
- **`semantica/triplet_store/`** – Implements RDF adapters including `OxigraphStore`, `BlazegraphStore`, `JenaStore`, and `RDF4JStore`

Documentation for these implementations resides in:
- [`docs/reference/graph_store.md`](https://github.com/semantica-agi/semantica/blob/main/docs/reference/graph_store.md) – Defines the unified `GraphStore` API and backend configurations
- [`docs/reference/triplet_store.md`](https://github.com/semantica-agi/semantica/blob/main/docs/reference/triplet_store.md) – Describes RDF abstractions and engine-specific parameters
- [`README.md`](https://github.com/semantica-agi/semantica/blob/main/README.md) – Provides high-level polyglot storage concepts and quick-start guides

## Zero-Code Migration Between Backends

Because all backends share identical method signatures, migrating from development to production requires only configuration changes. Switching from **Oxigraph** (local) to **Blazegraph** (production) involves changing only the `backend` argument and connection parameters—no source-code modifications are necessary.

Similarly, LPG migrations between **Neo4j**, **FalkorDB**, or **Amazon Neptune** rely solely on updating the `GraphStore` initialization dictionary. This polyglot approach decouples application logic from storage infrastructure, allowing teams to optimize for performance, licensing, or operational requirements without refactoring queries or data models.

## Summary

- **Semantica supports eight primary graph backends** across RDF and LPG models, plus optional vector stores
- **`GraphStore`** unifies Neo4j, FalkorDB, Apache AGE, and Amazon Neptune behind identical Python methods
- **`TripletStore`** abstracts Oxigraph, Blazegraph, Apache Jena, and RDF4J for SPARQL workflows
- **Backend adapters** live in `semantica/graph_store/` and `semantica/triplet_store/` modules
- **Zero-code migration** is possible because only configuration parameters differ between implementations

## Frequently Asked Questions

### What backends does Semantica support for property graph storage?

Semantica supports **Neo4j**, **FalkorDB**, **Apache AGE**, and **Amazon Neptune** through the unified `GraphStore` API. These backends cover local development (Neo4j Desktop), ultra-low-latency caching (FalkorDB on Redis), PostgreSQL-compatible deployments (Apache AGE), and fully managed cloud infrastructure (Amazon Neptune).

### How do I switch from a local development backend to production in Semantica?

Change only the `backend` parameter and connection arguments when instantiating `GraphStore` or `TripletStore`. For example, replace `backend="oxigraph"` with `backend="blazegraph"` and update the endpoint URI. All method calls—including `connect()`, `create_node()`, and `query()`—remain identical, requiring no application code changes according to the semantica-agi/semantica source code.

### Does Semantica support vector storage for embeddings?

Yes, Semantica optionally integrates vector stores including **PGVector**, **FAISS**, and **Qdrant** for dense embedding storage and similarity search. These vector capabilities complement the graph storage layer for semantic retrieval workflows, though they operate as optional extensions rather than core graph backends.

### Where are the backend adapter implementations located in the Semantica codebase?

Concrete adapter implementations reside in `semantica/graph_store/` for LPG backends (`Neo4jStore`, `FalkorDBStore`, `ApacheAgeStore`, `AmazonNeptuneStore`) and `semantica/triplet_store/` for RDF backends (`OxigraphStore`, `BlazegraphStore`, `JenaStore`, `RDF4JStore`). API documentation is maintained in [`docs/reference/graph_store.md`](https://github.com/semantica-agi/semantica/blob/main/docs/reference/graph_store.md) and [`docs/reference/triplet_store.md`](https://github.com/semantica-agi/semantica/blob/main/docs/reference/triplet_store.md).