Amazon Neptune features

Neptune Serverless automatically determines the resources required and scales capacity based on the workload’s changing requirements to maintain consistent performance, removing the need to manually manage capacity. It instantly scales up in fine-grained increments to hundreds of thousands of queries and scales down when resources are not in use.

With Neptune Serverless, you only pay for the resources you use making it cost-effective to run even the most demanding and unpredictable applications. You can start with Neptune Serverless without any upfront investment, and can save up to 90% on database costs as compared to provisioning for peak capacity.

The three most popular graph query languages – Apache TinkerPop Gremlin, openCypher, and SPARQL – are supported on Neptune Serverless. You can create a serverless Neptune graph within minutes through the AWS Management Console, the AWS Command Line Interface (AWS CLI), or APIs, specifying the minimum and maximum capacity limit to manage costs.

With a few clicks, you can scale compute and memory resources powering your production cluster up or down by creating new replica instances of the desired size or by removing instances. Compute scaling operations typically complete in a few minutes.

Neptune Database uses a distributed storage architecture that will automatically grow as your database storage needs grow. When a cluster is created, it is allocated a single segment of 10 GiB. As the volume of data increases and exceeds the currently allocated storage, Neptune automatically expands the cluster volume by adding new segments and it can grow to a maximum size of 128 TiB in supported AWS Regions except China and GovCloud. You don't need to provision excess storage for your database to handle future growth.

With Neptune Database, you can increase read throughput by creating up to 15 database read replicas which share the same underlying storage as the source instance. This frees up more processing power to serve read requests and reduces the replica lag time—often down to single-digit milliseconds. Neptune also provides a single endpoint for read queries so the application can connect without having to keep track of replicas as they are added and removed.

Neptune Database uses an in-memory optimized architecture to support fast query evaluation over large graphs using Gremlin, openCypher, or SPARQL query languages. It processes 100k+ queries per second. Neptune Analytics can easily analyze tens of billions of relationships across structure and unstructured data within seconds.

Neptune Global Database is designed for globally distributed applications, allowing a single Neptune database to span multiple AWS Regions. It replicates your data with little impact to database performance, enables fast local reads with low latency in each Region, and provides disaster recovery in case of Region-wide outages.

With Global Database, you can deploy a primary Neptune database cluster in one Region and replicate its data in up to five secondary read-only clusters (with up to 16 read replicas each) in different Regions. Global Database uses storage-based replication with typical latency of less than 1 second. As it utilizes dedicated infrastructure in the storage layer, it keeps your database resources in the primary and secondary Regions fully available to serve application needs.

If your primary Region suffers a performance degradation or outage, you can promote one of the secondary Regions to take read/write responsibilities. A Neptune cluster can recover in less than 1 minute even in the event of a complete Regional outage. As it provides local reads, Global Database lets you easily scale database reads across Regions and place your applications close to your users.

You pay for the resources used in the Regions where your Neptune cluster is present based on the prices for that Region. In addition, you pay for replicated write I/Os, which will capture writes, inserts, and deletes between the primary and each secondary cluster. For full pricing and regional availability, please refer to Neptune pricing.

On instance failure, Neptune uses Multi-AZ to automate failover to one of up to 15 Neptune replicas you have created in any of three AZs. If no Neptune replicas have been provisioned in the case of a failure, Neptune will attempt to automatically create a new database instance for you.

The health of your Neptune database and its underlying Amazon EC2 instance are continuously monitored. In the event of failure, the database and associated processes are automatically restarted. Neptune does not require the potentially lengthy replay of database redo logs, which greatly reduces restart times. As such, your instance restart times are typically under 30 seconds. Neptune also isolates the database buffer cache from database processes, allowing the cache to survive a database restart.

Neptune Database uses fault-tolerant storage meaning each 10 GiB chunk of your database volume is made durable across three AZs. It can transparently handle the loss of up to two copies of data without affecting database write availability and up to three copies without affecting read availability. Neptune Database storage is also self-healing as data blocks and disks are continually scanned for errors and automatically replaced.

Backups in Neptune Database enable point-in-time recovery for your instance. This allows you to restore your database to any second during your retention period, up to the last 5 minutes. Your automatic backup retention period can be configured up to 35 days. Automated backups are stored in Amazon S3 , which is designed for 99.999999999% durability. Neptune backups are automatic, incremental, and continuous, and have no impact on database performance.

Neptune is integrated with AWS Identity and Access Management (IAM), which provides you with the ability to control the actions that your IAM users and groups can take on specific Neptune resources including database instances, database snapshots, database parameter groups, database event subscriptions, and database options groups. In addition, you can tag your Neptune resources and control the actions that your IAM users and groups can take on groups of resources that have the same tag (and tag value). For example, you can configure your IAM rules to ensure developers are able to modify "Development" database instances, but only database administrators can modify and delete "Production" database instances. Additional information about IAM integration is available in Neptune documentation about IAM policies. 

Neptune provides fine-grained access to users retrieving Neptune data plane APIs with IAM for performing graph-data actions, such as reading, writing, and deleting data from the graph, and non-graph-data actions, such as starting and monitoring Neptune ML activities and checking the status of ongoing data plane activities. For example, you can create a policy with read-only access for data analysts who do not need to manipulate the graph data, a policy with read and write access for developers using the graph for their applications, and a policy for data scientists who need access to Neptune ML commands.

Neptune allows you to encrypt your databases using keys you create and control through AWS Key Management Service (AWS KMS). On a database instance running with Neptune encryption, data at rest is encrypted as are the automated backups, snapshots, and replicas in the same cluster. For encryption in transit, Neptune requires TLS version 1.2 and recommends TLS 1.3.

Neptune helps you log database events with minimal impact on database performance. Logs can later be analyzed for database management, security, governance, regulatory compliance, and other purposes. You can also monitor activity by sending audit logs to Amazon CloudWatch .

Neptune has over 20 international compliance standards ranging from FedRAMP (Moderate and High) to SOC (1, 2, 3), and it is also HIPAA eligible. The full list of standards that Neptune is compliant with can be found in the AWS Services in Scope by Compliance Program list.

There is no upfront commitment with Neptune. You only pay an hourly charge for each instance that you launch or the database resources you consume for serverless. When you’re finished with a Neptune database instance, you can delete it. You do not need to overprovision storage as a safety margin, and you only pay for the storage you actually consume. Additional information is detailed in the Neptune pricing page.

Neptune offers the flexibility to optimize your database spend by choosing between two configuration options - Neptune I/O-Optimized and Neptune Standard - based on your price-performance and price-predictability needs. Neither option requires upfront I/O or storage provisioning and both can scale I/O to support your most demanding applications. Neptune Standard offers cost-effective pricing for the vast majority of applications with low to moderate I/O usage. With Neptune Standard you pay for database instances, storage, and pay-per-request I/O.

Neptune I/O-Optimized delivers improved price performance for customers with I/O-intensive workloads such as payment processing systems, ecommerce systems, and financial applications. If your I/O spend exceeds 25% of your total Neptune database spend, you can save up to 40% on costs for I/O-intensive workloads with Neptune I/O-Optimized. You only pay for database instances and storage, and there are no charges for read and write I/O operations resulting in price predictability for all applications regardless of I/O variability.

You can launch a new Neptune database instance or Neptune Analytics graph using the AWS Management Console. Neptune database instances are preconfigured with parameters and settings appropriate for the database instance class you have selected. You can launch a database instance and connect your application within minutes without additional configuration. Database parameter groups provide granular control and fine-tuning of your database.

It is also easy to operate a high performance graph database with Neptune as you do not need to create custom indexes over your graph data. Neptune provides timeout and memory usage limitations to reduce the impact of queries that consume too many resources.

Neptune provides Amazon CloudWatch metrics for your database instances. You can use the console to view over 20 key operational metrics for your database instances, including compute resources, memory, storage, query throughput, and active connections.

Neptune can notify you by email or SMS of important database events such as automated failover. You can use the AWS Management Console to subscribe to different database events associated with your Neptune databases.

Neptune supports quick, efficient cloning operations, where entire multi-tebibyte database clusters can be cloned in minutes. Cloning is useful for a number of purposes including application development, testing, database updates, and running analytical queries. Immediate availability of data can significantly accelerate your software development and upgrade projects and make analytics more accurate.

You can clone a Neptune database with just a few steps in the console, without impacting the production environment. The clone is distributed and replicated across three AZs.

Amazon Bedrock Knowledge Bases offer one of the world's first fully managed GraphRAG capabilities, using Neptune under the hood. It automatically manages the creation and maintenance of graphs and embeddings, enabling you to provide more relevant responses to your end users. With this capability, you avoid the need for deep graph expertise, including creation of chunking strategies or complex RAG integrations with LLMs and vector stores. 

GraphRAG uses both graph analytics and vector search to enhance the accuracy and explainability of AI responses. It makes multi-hop connections between related entities or topics, retrieving the most relevant and comprehensive information to ground generative AI applications. GraphRAG use cases include:

• Customer service: GraphRAG can be used to improve IT service desk and contact center. For instance, GraphRAG can enable Security Operations Center (SOC) teams to interpret alerts more accurately to help secure critical systems. A healthcare member support chatbot can quickly find relevant information from large volumes of medical literature to answer complex questions about patient symptoms, treatments, and outcomes.
• Enterprise data discovery and insights: GraphRAG applications can provide insights for corporate functions. For instance, corporate legal teams can more effectively find information about tax laws, regulations, and case precedents to ideate on case strategies. Marketing teams can create customer 360 views based on a prospect’s social connections and purchase history.
• Industry-specific use cases: Companies across industries benefit from GraphRAG. For example, in the pharmaceutical industry, R&D teams can use GraphRAG to speed up drug research and trials. In the investment banking space, GraphRAG's ability to map complex relationships and provide a holistic view of corporate filings, which helps due diligence teams to uncover insights - such as regulatory rights and competitive dynamics - with RAG that are otherwise not readily apparent.

If you are looking to self-host or connect to custom data sources/third-party products (foundational models, vector stores, data stores), you have two choices.

• AWS GraphRAG Python toolkit: The new open source GraphRAG toolkit supports up-to-date foundational and graph models. It provides a framework for automating the construction of a graph from unstructured data, and for querying this graph when answering user questions.
• Open source frameworks: Neptune simplifies the creation of GraphRAG applications by integrating with both LangChain and LlamaIndex. This makes it easy to build applications with LLMs such as those available in Amazon Bedrock. AWS supports and contributes to both these popular open source projects.

Neptune Analytics offers native vector search to improve the accuracy of your generative AI applications. You can use vector search to augment your large language models (LLMs) by integrating graph queries for domain-specific context with the results from vector search on embeddings imported from LLMs (hosted in Amazon Bedrock), GNNs in GraphStorm, or other sources. Neptune is integrated with LangChain, an open-source Python framework that makes it easier to develop generative AI applications using LLMs.

Neptune Analytics supports algorithms for path finding, detecting communities (clustering), identifying important data (centrality), and quantifying similarity.

• Path finding algorithms efficiently determine the shortest or most optimal route between two nodes. They allow you to model real-world situations, such as road networks or social networks, as interconnected nodes and edges. Finding the shortest or most optimal paths between various points is crucial in applications such as route planning for GPS systems, logistics optimization, and even in solving complex problems in fields like biology or engineering.
• Community detection algorithms calculate meaningful groups or clusters of nodes within a network, revealing hidden patterns and structures that can provide insights into the organization and dynamics of complex systems. This is valuable in fields such as social network analysis, biology (for identifying functional modules in protein-protein interaction networks), and in understanding information flow and influence propagation in various domains.
• Centrality algorithms help identify the most influential or important nodes within a network, providing insights into key players or critical points of interaction. This is valuable in fields such as social network analysis where it helps pinpoint influential individuals, or in transportation networks where it aids in identifying crucial hubs for efficient routing and resource allocation.
• Graph similarity algorithms allow you to compare and analyze the structural similarities or dissimilarities between different graph structures, enabling insights into relationships, patterns, and commonalities across diverse datasets. This is invaluable in various fields such as biology (for comparing molecular structures), social networks (for identifying similar communities), and recommendation systems (for suggesting similar items based on user preferences).

If you’re unfamiliar with query languages such as Gremlin or openCypher, Neptune integration with NeptuneOpenCypherQAChain enables you to question your Neptune graph database using natural language. For example, you can translate English questions into openCypher queries and return a human-readable response. This chain can be used to answer questions such as “Which US airport has the longest and shortest outgoing routes?”.

Neptune ML automatically creates, trains, and applies ML models on your graph data. It uses open source Deep Graph Library (DGL) for training and deploying Graph Neural Networks (GNNs), powered by Amazon SageMaker) to make fast and more accurate predictions with graph data. With Neptune ML, you can make ML-based predictions on graph data in hours instead of weeks while improving the accuracy of most predictions by over 50% when compared to making predictions using non-graph methods.

Property graphs are familiar to developers that are used to relational models. Gremlin traversal language provides a way to quickly traverse property graphs. Neptune supports the property graph model using the open source Apache TinkerPop Gremlin traversal language and provides a Gremlin Websockets server that supports TinkerPop version 3.3. With Neptune, you can quickly build fast Gremlin traversals over property graphs. Existing Gremlin applications can easily use Neptune by changing the Gremlin service configuration to point to a Neptune instance.

Resource Description Framework (RDF) provides flexibility for modeling complex information domains. There are a number of existing free or public datasets available in RDF including Wikidata and PubChem (database of chemical molecules). Neptune supports the W3C’s Semantic Web standards of RDF 1.1 and SPARQL 1.1 (Query and Update), and provides an HTTP REST endpoint that implements the SPARQL Protocol 1.1. With Neptune, you can easily use the SPARQL endpoint for both existing and new graph applications.

OpenCypher is one of the most popular query languages for developers working with graph databases. Developers, business analysts, and data scientists like openCypher’s SQL-inspired syntax because it provides a familiar structure to compose queries for graph applications. For Neptune Database, openCypher and Gremlin query languages can be used together over the same property graph data. Support for openCypher is compatible with the Bolt protocol to run applications that use the Bolt protocol to connect to Neptune.

Neptune supports fast, parallel bulk loading for property graph data that is stored in Amazon S3. You can use a REST interface to specify the Amazon S3 location for the data. It uses a CSV-delimited format to load data into the nodes and edges. Additional information is detailed in the Neptune property graph bulk loading documentation.

Neptune Database supports fast, parallel bulk loading for RDF data that is stored in Amazon S3. You can use a REST interface to specify the Amazon S3 location for the data. The N-Triples (NT), N-Quads (NQ), RDF/XML, and Turtle RDF 1.1 serializations are supported. Additional information is available in the Neptune RDF bulk loading documentation.