AllegroGraph® is a modern, high-performance, persistent graph database. AllegroGraph uses efficient memory utilization in combination with disk-based storage, enabling it to scale to billions of quads while maintaining superior performance. AllegroGraph supports SPARQL, RDFS++, and Prolog reasoning from numerous client applications.

AllegroGraph New Features

AllegroGraph New Features

Additional New Features

The primary emphasis of this release has been additional enterprise functionality, efficiency and overall scalability. Please refer to the release notes for a complete list of enhancements and improvements.

  • AllegroGraph is 100 percent ACID, supporting Transactions: Commit, Rollback, and Checkpointing.
  • Full and Fast Recoverability
  • 100% Read Concurrency, Near Full Write Concurrency
  • Online Backups, Point-in-Time Recovery, Replication, Warm Standby
  • Dynamic and Automatic Indexing – All committed triples are always indexed (7 indices)
  • Advanced Text Indexing – Text indexing per predicate
  • SOLR and MongoDB Integration
  • SPIN support (SPARQL Inferencing Notation). The SPIN API allows you to define a function in terms of a SPARQL query and then call that function in other SPARQL queries. These SPIN functions can appear in FILTERs and can also be used to compute values in assignment and select expressions.
  • All Clients based on REST ProtocolJava Sesame, Java Jena, Python, Clojure, Perl, Ruby, Scala, and Lisp clients
  • Completely multi-processing based (SMP) – Automatic Resource Management for all processors and disks, and optimized memory use. See the performance tuning guide here, and server configuration guide here
  • Column-based compression of indices – reduced paging, better performance
  • Triple Level Security with Security Filters
  • Cloud-Hosted AllegroGraph - Amazon EC2
  • The AllegroGraph RDF server can be scripted using the JavaScript API
  • JavaScript-based interface (JIG) for general graph traversal
  • Soundex support - Allows Free text indexing based on phonetic pronunciation
  • User-defined Indices - fully controllable by system administrator
  • Client-Server GRUFF with Graphical Query Builder
  • Plug-in Interface for Text Indexers (use SOLR/Lucene, Native AG Full Text Indexer, Japanese Tokenizer)
  • Dedicated and Public Sessions – In dedicated sessions users can work with their own rule sets against the same database
  • Visit our Learning Center
  • Mark Watson's new book: Practical Semantic Web and Linked Data Applications, Java, Clojure, Scala, and JRuby Edition
High-performance Storage

AllegroGraph is designed for maximum loading speed and query speed. Loading of quads, through its highly optimized RDF/XML and N-Quads parsers, is best-of-breed, particularly with large files. The AllegroGraph product line has always pushed the performance envelope starting with version 1.0 in 2004, which was the first product to claim 1 billion triples loaded and indexed using standard x86 64-bit hardware. AllegroGraph, a purpose built (not a modified RDBMS), NoSQL Graph Database continued to drive innovation in the marketplace with the 2008 SemTech conference example of 10 billion quads loaded on Amazon’s EC2 service. The new version 4 series continues to bring performance to the forefront of Franz’s Semantic Technologies as the industry’s first OLTP semantic web database. AllegroGraph’s ability to automatically manage all available hardware resources to maximize loading, indexing and query capabilities once again raises the bar for RDF storage performance. The following table displays examples of AllegroGraph's performance in loading and indexing. Benchmark Results.

Load Test
# Triples
Load Rate (T/Sec)


1.106 Billion

36min, 49 sec



22.12 Billion

12 hrs, 18m, 16s


AllegroGraph Pre-release**

310.269 Billion

78 hrs, 9m, 23s


AllegroGraph Pre-release***

1.009 Trillion

338 hrs, 5m


*32 core Intel E5520, 2.0 GHz, with 1 TB RAM,  RedHat v6.1.
**64 core Intel x7560, 2.27 GHz, 2TB RAM, 22TB Disk, Redhat v6.1. LUBM-like data.
***240 core Intel x5650, 2.66GHz, 1.28TB RAM, 88TB Disk, Redhat v6.1. LUBM-like data.

AllegroGraph provides a REST protocol architecture, essentially a superset of the Sesame HTTP Client. Franz's staff directly supports adapters for various languages, Sesame Java, Sesame Jena, Python using the Sesame signatures, and Lisp. There are Open Source Adapters through community projects for C#, Ruby, Clojure, Scala, and Perl. Links to download here.

Powerful and Expressive Reasoning and Querying

AllegroGraph provides the broadest array of mechanisms to query and access knowledge in an RDF datastore:

  • RDFS++ Reasoning - Dynamic Materialization

    Description logics or OWL-DL reasoners are good at handling complex ontologies. They tend to be complete (give all the possible answers to a query) but can be totally unpredictable with respect to execution time when the number of triples increases beyond millions. AllegroGraph offers a very fast and practical RDFS++ reasoner.

    We support all the RDF and RDFS predicates and some in full OWL. The supported predicates are RDF:type, RDFS:subClassOf, range, domain, subProperty.

    OWL:sameAs inverseOf, TransitiveProperty, hasValue, someValuesFrom, allValuesFrom, one of, equivalentClass, restriction, onProperty, intersectionOf.

    AllegroGraph's RDFS++ engine dynamically maintains the ontological entailments required for reasoning: it has no explicit materialization phase. Materialization is the pre-computation and storage of inferred triples so that future queries run more efficiently. The central problem with materialization is its maintenance: changes to the triple-store's ontology or facts usually change the set of inferred triples. In static materialization, any change in the store requires complete re-processing before new queries can run. AllegroGraph's Dynamic Materialization simplifies store maintenance and reduces the time required between data changes and querying.

  • OWL2 RL Materialized Reasoner

    AllegroGraph's OWL2 RL materializer uses a set of inference rules to generate new triples and adds them to the database. OWL 2 RL is the subset of OWL 2 that is designed to support rule based reasoners. OWL 2 RL contains a large number of rules for generating triples and some rules for verifying that the triple store is consistent with respect to the OWL 2 RL ontology. The OWL2 RL materializer is best when OWL 2 RL inference is required or the store is relatively static.

  • SPARQL Queries on Named Graphs

    SPARQL, the W3C standard RDF query language, returns RDF, XML and other formats in responses to queries. AllegroGraph's SPARQL, one of the W3C's "interoperable implementations", includes a query optimizer, and has full support for named graphs. It can be used with the RDFS++ reasoning turned on (i.e., query over real and inferred triples). SPARQL can be used with every available AllegroGraph interface mentioned in the previous section.

  • Prolog

    AllegroGraph's RDF Prolog provides concise, powerful, industry-standard, domain-specific reasoning to build high-level concepts (that require complex rules or numerical processing) on top of RDF data. AllegroGraph Prolog is an option because many use cases are difficult (or very cumbersome) to model with only RDF/RDFS and OWL. Prolog can also be used on top of the RDFS++ reasoner as a rule based system.

  • Low-level APIs Allow fast, 'close-to-the-metal' access to triples by subject, predicate, and object.
GeoTemporal Reasoning, Social Network Analysis, and Additional Features

Other essential Triple-Store features:

  • Geospatial and Temporal Reasoning

    AllegroGraph stores geospatial and temporal data types as native data structures. Combined with its indexing and range query mechanisms, AllegroGraph lets you perform geospatial and temporal reasoning efficiently.

  • Social Networking Analysis

    AllegroGraph includes an SNA library that treats a triple-store as a graph of relations, with functions for measuring importance and centrality as well as several families of search functions. Example algorithms are nodal-degree, nodal-neighbors, ego-group, graph-density, actor-degree-centrality, group-degree-centrality, actor-closeness-centrality, group-closeness-centrality, actor betweenness-centrality, group-betweenness-centrality, page-rank-centrality, and cliques. Geospatial and temporal primitives combined with SNA functions form an Activity Recognition framework for flexibly analyzing networks and events in large volumes of structured and unstructured data.

  • Native Data Types and Efficient Range Queries

    AllegroGraph stores a wide range of data types directly in its low level triple representation. This allows for very efficient range queries and significant reduction in triple-store data size. With other triple-stores that only store strings, the only way to do a range query is to go through all the values for a particular predicate. This works well if everything fits in memory; but if the predicate has millions of triples, it will need costly machines with huge amounts of RAM. AllegroGraph supports most XML Schema types (native numeric types, dates, times, longitudes, latitudes, durations and telephone numbers).

  • Free-text Indexing

    AllegroGraph supports free-text indexing on the objects of triples whose predicates have been registered for indexing. Once indexed, triples can be found using a simple but robust query language. Free-text indexing support includes functions to register predicates and see which predicates are registered. Support for Solr was added in AllegroGrpah version 4.5

  • Named Graphs for Weights, Trust Factors, Provenance

    AllegroGraph actually stores quints. A triple in AllegroGraph contains 5 slots, the first three being subject (s), predicate (p), and object (o). The remaining two are a named-graph slot (g) and a unique id assigned by AllegroGraph. The id slot is used for internal administrative purposes, but can also be referred to by other triples directly.

    The W3C proposal is to use the 'named-graph' slot for clustering triples. So for example, you load a file with triples into AllegroGraph and you use the filename as the named-graph. This way, if there are changes to the triple file, you just update those triples in the named graph that came from the original file. However, with AllegroGraph, you can also put other attributes such as weights, trust factors, times, latitudes, longitudes, etc, into the named graph slot.

  • Direct Reification

    AllegroGraph allows triple-ids to be the subject or object of another triple. This is beyond the scope of pure RDF. The advantage of this approach is that you can reduce the total number of triples in the store to a more manageable size, and, even more importantly, dramatically reduce query time because a single query can retrieve more data.

  • Automatic Resource Management

    The AllegroGraph architecture is designed to maximize hardware resources for all data management procedures (Loading, Indexing, Query, etc.). The hardware utilization can be managed through the AllegroGraph configuration file as necessary.

  • Dynamic and Automatic Indexing

    Triple-indices are user configurable, or index management can be taken care of entirely by AllegroGraph. By default, all committed triples are always indexed (default: 7 indices). AllegroGraph now supports any index combination of S, P, O, G. The default indices are:

    • S, P, O, G, I - Subject, Predicate, Object, Named Graph, ID
    • P, O, S, G, I
    • O, S, P, G, I
    • G, S, P, O, I
    • G, P, O, S, I
    • G, O, S, P, I
    • I
  • Federation

    AllegroGraph supports queries with distributed databases. You can group multiple triple-stores, both local and remote into a single virtual store. It allows thread-safe opening of multiple triple-databases from one application (for the read only parts of the database). Queries over multiple databases are easy with direct data access from applications. It also supports physical merging of databases.

  • Warm Standby

    Production AllegroGraph databases can now be paired with transactionally consistent Warm Standby databases, co-located in the same data center or across the globe. Whether for planned maintenance or a hardware failure, your enterprise application never needs to be down.

  • Point in Time Recovery

    Provides a user the option to advance the state of a restored database forward to any later commit that was made to the original (and perhaps still running) database.  This functionality performs as if the user performed a backup after every commit thus providing complete data integrity.

  • Replication

    Allows multiple AllegroGraph databases to be kept synchronized and transactionally consistent in real-time with the master.  These replicates can provide scalability and load balancing for applications by offering numerous clients the ability to read data that reflects content in the master database.  Replication occurs across the network so any set of AllegroGraph databases connected by a network can participate in replication. 

Professional Services

Make the most of your use of semantic technologies by utilizing our consulting services. We provide:

  • Vision Building - How to Apply Semantic Technologies
  • Rapid Prototyping and Proof-of-Concept Development
  • Complete Enterprise Technology Solution Stack
  • Best Practices to Maximize Value from Semantic Technologies
  • New Organizational Skills Required ÷†Custom Training

More Details -

Compatible Semantic Technologies

  • TopBraid Composer

    TopBraid Composer, developed by TopQuadrant, Inc., is an enterprise-class modeling and application development environment It provides comprehensive support for modeling ontologies and data, connecting data sources, designing queries, rules and semantic data processing chains, and developing Semantic Web applications. For details see TopBraid Composer

  • RacerPro

    The Semantic Web reasoning system developed by Racer Systems GmbH, RacerPro, has been integrated with AllegroGraph, exposing RDF data in AllegroGraph to Racer's highly optimized Description Logic (DL) reasoner. It is most suitable for ontology-driven applications or theorem proofing. RacerPro's interfaces also include DIG over HTTP and support for rules (SWRL). For details see RacerPro

  • AGWebview

    AGWebview, developed by Franz, Inc., is an interface for exploring, querying, and managing AllegroGraph triple stores through a web browser. For details see AGWebview

  • Gruff

    Gruff is an RDF browser that displays visual graphs and has an interface to build SPARQL or Prolog queries as visual graphs. Gruff can also display tables of all properties of selected resources or generate tables with SPARQL queries, and resources in the tables can be added to the visual graph. For details see Gruff

  • DATAmaestro

    Data mining has increasingly played a key role in the enterprise decision process because of today's competitive necessity to respond to changing market conditions quickly and correctly, leveraging the enormous operating data now available for such process. DATAmaestro, developed by PEPITe S.A. brings unique capabilities to meet today's data mining needs. For details see DATAmaestro

  • Cogito

    The COGITO platform by Expert System S.p.A., conceived to bring intelligence to the search, extraction and classification of unstructured information for internal management purposes and for monitoring and analyzing external sources, such as the Internet. For details see Cogito

  • Sentient Suite

    The Sentient Suite, developed by IO Informatics Inc., integrates heterogeneous data to solve knowledge and project management problems for the Life Sciences industry. For details see Sentient Suite

  • Talend Open Studio

    Talend Open Studio is an open source, Eclipse-based environment offering the broadest connectivity to all source and target systems to support all types of data integration, data migration and data synchronization operations. For details see Talend

  • Semaphore

    Semaphore is an Enterprise Content Intelligence Platform built from four core and inter-connected modules: an Ontology Manager, Classification and Text Mining, a Semantic Enhancement Server, and a Search Application Framework. Semaphore:

    • Automatically, accurately and consistently applies metadata and classification
    • Improves findability by being ontology-driven
    • Provides a better search and navigation experience
    • Enables effective data disposition, data loss prevention, records retention and eDiscovery
    For more detalis see Semaphore

System Requirements

The AllegroGraph Database Server runs natively on Linux x86-64 bit. To run AllegroGraph on other operating systems (i.e. Windows, Mac) we suggest you set up a Linux Virtual Machine or EC2. We provide a Virtual Machine and EC2 AMIs to help facilitate installation. Clients to an AllegroGraph server may be any OS and either 32-bit or 64-bit.

AllegroGraph Virtual Machine Appliance (Requires 64-bit hardware)
Linux (x86-64), glibc 2.11 and above Apple Mac OSX 10.9 and newer
Amazon EC2 (Linux x86-64) 32 or 64 bit Microsoft Windows

The Virtual Machine Appliance will let you run the AllegroGraph Linux version on a Windows or Mac operating system. Performance will be slower than running natively, so we encourage you to install AllegroGraph natively for performance evaluation.

Installation details for the Virtual Machine Appliance.


For more info, send email to or call (510) 452-2000, Option 3-Sales and Marketing.

Copyright © 2021 Franz Inc., All Rights Reserved | Privacy Statement Twitter