# Semantica Polyglot Graph Storage: Neo4j, FalkorDB, and AGE Support Explained

> Explore Semantica's support for polyglot graph storage: Neo4j, FalkorDB, and AGE. Access diverse graph databases with a unified interface for flexible data management.

- Repository: [Semantica /semantica](https://github.com/semantica-agi/semantica)
- Tags: deep-dive
- Published: 2026-09-06

---

**Semantica supports three polyglot graph storage backends: Neo4j, FalkorDB, and AgensGraph (AGE), all accessed through a unified GraphStore interface.**

The Semantica framework provides a flexible, backend-agnostic approach to graph data management. Rather than locking users into a single database, its architecture abstracts storage behind a common interface—enabling teams to choose the right engine for their workload or migrate between systems without rewriting application logic.

## What Is Polyglot Graph Storage in Semantica?

Polyglot persistence in Semantica means one codebase can target multiple graph databases with identical high-level APIs. The `GraphStore` façade class in [`semantica/graph_store/graph_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/graph_store.py) exposes methods like `create_node`, `create_relationship`, and `execute_query`. Concrete implementations translate these calls into backend-specific protocols.

This design pattern appears throughout the codebase:

- `Neo4jStore` wraps the official Bolt driver for Cypher-native operations
- `FalkorDBStore` interfaces with Redis-backed OpenCypher queries
- `AGEStore` bridges PostgreSQL's AgensGraph extension

## Supported Graph Storage Backends

### Neo4j: Enterprise Property-Graph with GDS

The **Neo4j** backend delivers full property-graph capabilities with native Cypher support, ACID transactions, and integrated Graph Data Science (GDS) algorithms.

Implementation lives in [`semantica/graph_store/neo4j_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/neo4j_store.py). This store handles:

- Bolt protocol connections
- Cypher query execution
- Transaction batching
- GDS procedure calls

```python
from semantica.graph_store import GraphStore

neo4j_store = GraphStore(
    backend="neo4j",
    uri="bolt://localhost:7687",
    user="neo4j",
    password="secret"
)

neo4j_store.create_node(
    labels=["Person"],
    properties={"name": "Alice", "role": "engineer"}
)

```

### FalkorDB: High-Performance Redis-Based Graph

**FalkorDB** provides ultra-fast property-graph operations built on Redis. It uses OpenCypher syntax and leverages sparse-matrix representations for analytical queries.

The `FalkorDBStore` class in [`semantica/graph_store/falkordb_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/falkordb_store.py) implements this backend, optimized for:

- In-memory speed with Redis persistence options
- Vector similarity search alongside graph traversals
- Horizontal scaling via Redis Cluster

```python
falkordb_store = GraphStore(
    backend="falkordb",
    host="localhost",
    port=6379,
    graph_name="demo"
)

falkordb_store.create_node(
    labels=["Device"],
    properties={"id": "sensor-01", "status": "active"}
)

```

### AgensGraph (AGE): PostgreSQL Native Graph Extension

**AgensGraph** (Apache AGE) extends PostgreSQL with property-graph features, enabling hybrid relational-graph workloads within a mature RDBMS.

The `AGEStore` implementation in [`semantica/graph_store/age_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/age_store.py) connects through standard PostgreSQL drivers:

```python
age_store = GraphStore(
    backend="age",
    host="localhost",
    port=5432,
    user="age_user",
    password="age_pass",
    database="graphdb"
)

age_store.create_node(
    labels=["City"],
    properties={"name": "Paris", "country": "France"}
)

```

## How the Unified Interface Works

All three backends expose identical methods through the `GraphStore` constructor. The `backend` parameter determines which concrete class instantiates:

| Parameter | Module Loaded | Typical Use Case |
|-----------|-------------|----------------|
| `"neo4j"` | `Neo4jStore` | Complex analytics, enterprise deployments |
| `"falkordb"` | `FalkorDBStore` | High-throughput, real-time applications |
| `"age"` | `AGEStore` | Existing PostgreSQL infrastructure, hybrid data |

Method calls dispatch to backend-specific implementations while maintaining consistent return types and exception handling.

## Key Implementation Files

Understanding the source structure helps extend or debug polyglot operations:

- **[`semantica/graph_store/graph_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/graph_store.py)** – Core façade with `GraphStore`, `NodeManager`, and `RelationshipManager` classes
- **[`semantica/graph_store/neo4j_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/neo4j_store.py)** – Neo4j Bolt driver integration
- **[`semantica/graph_store/falkordb_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/falkordb_store.py)** – FalkorDB Redis client wrapper
- **[`semantica/graph_store/age_store.py`](https://github.com/semantica-agi/semantica/blob/main/semantica/graph_store/age_store.py)** – AGE PostgreSQL connector

## Summary

- Semantica's **polyglot graph storage** supports **Neo4j**, **FalkorDB**, and **AgensGraph (AGE)** through a unified API
- The **`GraphStore` façade** in [`graph_store.py`](https://github.com/semantica-agi/semantica/blob/main/graph_store.py) enables backend-agnostic application code
- All backends implement identical methods: `create_node`, `create_relationship`, `execute_query`
- Switching storage requires only changing the `backend` parameter and connection credentials
- Source implementations reside in dedicated modules under `semantica/graph_store/`

## Frequently Asked Questions

### Can I use multiple graph backends simultaneously in one Semantica application?

Yes. Instantiate separate `GraphStore` objects with different `backend` values. Each maintains independent connections, allowing reads from FalkorDB for speed and writes to Neo4j for persistence, or similar hybrid patterns.

### Does Semantica support schema migration tools across these backends?

The unified interface handles CRUD operations consistently, but schema-specific features (indexes, constraints) require backend-native commands through `execute_query`. No automatic cross-backend migration tool ships with the core framework.

### What performance differences should I expect between these polyglot options?

FalkorDB excels at high-velocity ingestion and simple traversals in memory. Neo4j optimizes for complex analytical queries with GDS integration. AgensGraph performs best when graph data must coexist with relational tables, avoiding ETL overhead.