Amazon Neptune

Amazon Neptune uniquely supports two industry-standard graph data models within a single service.

• Property Graph Model: Uses the Apache TinkerPop Gremlin traversal language. Nodes and edges can have arbitrary key-value properties, ideal for flexible, application-centric graphs.
• RDF (Resource Description Framework) Model: Uses the W3C-standard SPARQL query language. Data is stored as subject-predicate-object triples, forming a semantic web-compliant knowledge graph. This dual support allows enterprises to choose the model that best fits their use case, such as fraud detection (property graph) or life sciences ontologies (RDF).

Neptune's performance is driven by a distributed, log-structured storage engine optimized for graph access patterns.

• Index-Free Adjacency: Nodes store direct pointers to connected nodes and edges, enabling millisecond traversals across deeply connected data without expensive global index lookups.
• Optimized for SSD: The storage layer is designed for low-latency SSD-backed volumes, ensuring fast read and write performance for complex join-heavy queries.
• Scalable Read Replicas: You can add up to 15 read replicas across Availability Zones to elastically scale read throughput and provide high availability.

Neptune provides robust security controls essential for enterprise knowledge graphs containing sensitive data.

• Network Isolation: Deploy instances within an Amazon VPC. Use security groups and network ACLs to control traffic. Private Endpoints keep all traffic within the AWS network.
• Encryption: Data is encrypted at rest using AWS Key Management Service (KMS) keys and in transit using SSL/TLS.
• Fine-Grained Access Control: Integrates with AWS Identity and Access Management (IAM) for authentication and authorization. For RDF graphs, use SPARQL 1.1 Update with HTTP Auth for granular data access policies.
• Compliance: Certified for standards including SOC, PCI DSS, ISO, and HIPAA eligibility.

As a managed service, Neptune automates time-consuming database administration tasks.

• Automated Provisioning & Patching: Instance deployment, software patching, and minor version upgrades are handled by AWS with minimal downtime.
• Automated Backups: Continuous backups to Amazon S3 with point-in-time recovery. You can restore to any second within your retention period (1-35 days).
• Health Monitoring: Integrated with Amazon CloudWatch for metrics on query throughput, latency, storage, and errors. Performance Insights provides a visual dashboard to identify and troubleshoot bottlenecks.
• Serverless Option: Neptune Serverless (preview) automatically scales compute capacity based on workload demands, eliminating the need for capacity planning.

Neptune extends beyond OLTP queries to support graph analytics and ML workflows.

• Neptune Analytics (separate service): A purpose-built, fast in-memory engine for running complex graph algorithms like PageRank, community detection, and shortest path on billion-edge graphs without impacting the transactional database.
• Graph Embeddings: The Neptune ML feature uses Deep Graph Library (DGL) to train Graph Neural Network (GNN) models within Neptune for tasks like link prediction, node classification, and generating node/edge embeddings for vector similarity search.
• Streaming Integration: Supports change data capture via the Neptune Streams feature, publishing every change to the graph as a sequenced log to Amazon Kinesis, enabling real-time analytics and event-driven architectures.

Neptune offers a comprehensive suite of tools for development, migration, and visualization.

• Bulk Loader: High-performance tool for parallel ingestion of billions of RDF triples or property graph records from Amazon S3.
• Query Languages: Full support for open-source standards: Gremlin (Java, Python, JavaScript), SPARQL 1.1, and openCypher (preview).
• Visualization: Integrates with the Neptune Workbench (Jupyter-based) for notebook analytics and Neptune Explorer for interactive graph visualization and exploration.
• Graph ETL: AWS offers the Neptune Bulk Loader and AWS Glue for building managed graph ETL pipelines to transform relational or document data into graph models.

A graph data model where entities are represented as nodes and relationships as edges, both of which can have associated properties (key-value pairs). This model excels at representing connected, semi-structured data with rich attributes. Neptune supports this model via the Apache TinkerPop framework and the Gremlin query language. It is the primary model used for applications like fraud detection, recommendation engines, and network analysis.

A database system architected to store and retrieve data structured as Resource Description Framework (RDF) triples. An RDF triple consists of a subject, predicate, and object, forming a standardized, semantic statement. Neptune functions as a high-performance triplestore, supporting the SPARQL query language. This model is foundational for the Semantic Web, enterprise knowledge graphs, and data integration where formal semantics and inference are required.

The graph traversal language and virtual machine of the Apache TinkerPop framework. Gremlin is a functional, data-flow language used to express complex graph traversals and mutations across both property graph and RDF models. In Neptune, Gremlin is the primary interface for interacting with the property graph side of the database.

• Declarative and Imperative: Supports both pattern-matching and step-by-step navigation.
• Vendor Agnostic: Queries are portable across different TinkerPop-enabled graph systems.

A web service interface, typically accessed via HTTP, that accepts and executes SPARQL queries over an RDF knowledge graph. Neptune provides a SPARQL 1.1-compliant endpoint, returning query results in standard formats like JSON or XML. This endpoint enables programmatic access for applications, data integration via federated queries, and interoperability with a vast ecosystem of Semantic Web tools and libraries.

An open-source graph computing framework that provides the Gremlin query language and a standard API for building graph applications. It abstracts over different underlying graph database implementations. Neptune's property graph capabilities are built on TinkerPop, providing a standards-based, portable interface. The framework includes:

• Gremlin Server: A service wrapper for executing traversals.
• Graph Computer: APIs for OLAP (analytical) graph processing.