Archive for the ‘Blueprints’ Category

Multiobjective Search

Monday, August 11th, 2014

Multiobjective Search with Hipster and TinkerPop Blueprints

From the webpage:

This advanced example explains how to perform a general multiobjective search with Hipster over a property graph using the TinkerPop Blueprints API. In a multiobjective problem, instead of optimizing just a single objective function, there are many objective functions that can conflict each other. The goal then is to find all possible solutions that are nondominated, i.e., there is no other feasible solution better than the current one in some objective function without worsening some of the other objective functions.

If you don’t know Hipster:

The aim of Hipster is to provide an easy to use yet powerful and flexible type-safe Java library for heuristic search. Hipster relies on a flexible model with generic operators that allow you to reuse and change the behavior of the algorithms very easily. Algorithms are also implemented in an iterative way, avoiding recursion. This has many benefits: full control over the search, access to the internals at runtime or a better and clear scale-out for large search spaces using the heap memory.

You can use Hipster to solve from simple graph search problems to more advanced state-space search problems where the state space is complex and weights are not just double values but custom defined costs.

I can’t help but hear “multiobjective search” in the the context of a document search where documents may or may not match multiple terms in a search request.

But that hearing is wrong because a graph can be more granular than a document and possess multiple ways to satisfy a particular objective. My intuition is that documents satisfy search requests only in a binary sense, yes or not. Yes?

Good way to get involved with Tinkerpop Blueprints.


Thursday, June 12th, 2014


From the webpage:

SecureGraph is an API to manipulate graphs, similar to Blueprints. Unlike Blueprints, every Secure graph method requires authorizations and visibilities. SecureGraph also supports multivalued properties as well as property metadata.

The SecureGraph API was designed to be generic, allowing for multiple implementations. The only implementation provided currently is built on top of Apache Accumulo for data storage and Elasticsearch for indexing.

According to the readme file, definitely “beta” software but interesting software none the less.

Are you using insecure graph software?

Might be time to find out!

I first saw this in a tweet by Marko A. Rodriguez

Bigdata and Blueprints

Tuesday, May 27th, 2014

Bigdata and Blueprints

From the webpage:

Blueprints is an open-source property graph model interface useful for writing applications on top of a graph database. Gremlin is a domain specific language for traversing property graphs that comes with an excellent REPL useful for interacting with a Blueprints database. Rexster exposes a Blueprints database as a web service and comes with a web-based workbench application called DogHouse.

To get started with bigdata via Blueprints, Gremlin, and Rexster, start by getting your bigdata server running per the instructions here.

Then, go and download some sample GraphML data. The Tinkerpop Property Graph is a good starting point.

Just in case you aren’t familiar with bigdata(R):

bigdata(R) is a scale-out storage and computing fabric supporting optional transactions, very high concurrency, and very high aggregate IO rates. The bigdata RDF/graph database can load 1B edges in under one hour on a 15 node cluster. Bigdata operates in both a single machine mode (Journal), highly available replication cluster mode (HAJournalServer), and a horizontally sharded cluster mode (BigdataFederation). The Journal provides fast scalable ACID indexed storage for very large data sets, up to 50 billion edges. The HAJournalServer adds replication, online backup, horizontal scaling of query, and high availability. The federation provides fast scalable shard-wise parallel indexed storage using dynamic sharding and shard-wise ACID updates and incremental cluster size growth. Both platforms support fully concurrent readers with snapshot isolation. (

So, this is a major event for Blueprints.

I first saw this in a tweet by Marko A. Rodriguez.

Bitsy 1.5

Friday, October 11th, 2013

Bitsy 1.5

Version 1.5 of Bitsy is out!

Bitsy is a small, fast, embeddable, durable in-memory graph database that implements the Blueprints API.

Slides: Improvements in Bitsy 1.5 by Sridhar Ramachandran.

The current production version is Bitsy 1.2 and Bitsy 1.5 is for research, evaluation and development. Webpage reports that Bitsy 1.5 should be available for production by the end of 2013.


TinkerPop 2.4.0 Released (Gremlin Without a Cause)

Friday, August 9th, 2013

TinkerPop 2.4.0 Released (Gremlin Without a Cause) by Marko A. Rodriguez.

From the post:

TinkerPop 2.4.0 has been released under the name “Gremlin without a Cause” (see attached logo). The last release was back in March of 2013, so there are lots of new features/bugfixes/optimizations in the latest 2.4.0 release. Here is the best-of-the-best of each project along with the full release notes.

NOTE: 2.4.0 jars have been deployed to Apache Central Repo and ready for inclusion.

Another offering for your summer holiday enjoyment!

TinkerPop 2.3.0 has been unleashed

Thursday, March 21st, 2013

TinkerPop 2.3.0 has been unleashed by Marko A. Rodriguez.

Release notes for:







Gephi Blueprints plugin

Wednesday, November 7th, 2012

Gephi Blueprints plugin by David Suvee.

From the homepage:

The Gephi Blueprints plugin allows a user to import graph-data from any graph database that implements the Tinkerpop Blueprints generic graph API. Out of the box, the plugin provides support for TinkerGraph, Neo4j, OrientDB, Dex and RexterGraph. Additionally, it also provides support for the FluxGraph temporal graph database.


Not to mention having a short list of interesting graph software to boot!

TinkerPop2 Release

Thursday, May 24th, 2012

A message from Marko Rodriguez announced the release of TinkerPop2 with notes on the major features of each:

– Massive changes to blueprints-core API
– TreePipe added for exposing the spanning tree of a traversal
– Automatic path and query optimizations (download)
– FramedGraph is simply a wrapper graph in the Blueprints sense
– Synchronicity with the Blueprints API (download)

BTW, Marko says:

As you may know, there are big changes to the API: package renaming, new core API method names, etc. While this may be shocking, it is all worth it. In 2 weeks, there is going to be a release of something very big for which TinkerPop2 will be a central piece of the puzzle. Stay tuned and get ready for a summer of insane, crazy graph madness.

So, something to look forward to!

A TinkerPop Story

Wednesday, December 14th, 2011

A TinkerPop Story

From the post:

In a time long, long right now and a place far, far within, there exists a little green gremlin named…well, Gremlin. Gremlin lives in a place known as TinkerPop. For those who think of a “place” as some terrestrial surface coating a sphere that is circling one of the many massive fiery nuclear reactors in the known universe, TinkerPop is that, yet at the same time, a wholly different type of place indeed.

In a day of obscure (are there any other kind?) errors and annoyances, this is an absolute delight!

Highly recommended!

TinkerPop 2011 Winter release!

Friday, December 9th, 2011

TinkerPop 2011 Winter release!

Which includes:

New homepage design:

Blueprints 1.1 (Blueberry):

Frames 0.6 (Truss):

Gremlin 1.4 (Ain’t No Thing But a Chicken Wing):

Pipes 0.9 (Sink):

Rexster 0.7 (Brian)

Rexster-Kibbles 0.7

You didn’t really want to spend all weekend holiday shopping and hanging out with relatives did you? ūüėČ

An Introduction to Tinkerpop

Saturday, October 8th, 2011

An Introduction to Tinkerpop by Takahiro Inoue.

Excellent introduction to the Tinkerpop stack.

Furnace — A Property Graph Algorithms Package

Sunday, September 25th, 2011

Furnace — A Property Graph Algorithms Package

Marko Rodriguez posted the following note to the Grelim-users mailing list today:


For many months, the TinkerPop community has been trying to realize the best way to go about providing a graph analysis package to the TinkerPop stack ( ). With the increased flexibility and power of Pipes and the partitioning of Gremlin into multiple JVM languages, we feel that the stack is organized correctly now to support Furnace — A Property Graph Algorithms Package.
( if the domain hasn’t propagated to your DNS yet )

The project is currently just stubbed, but overtime you can expect the ability to evaluate standard (and non-standard) graph analysis algorithms over Blueprints-enabled graphs in a way that respects explicit and implicit associations in the graph. In short, it will implement the ideas articulated in:

This will be possible due to Pipes and the ability to represent abstract relationships using Pipes, Gremlin_groovy (and the upcoming Gremlin_scala). Moreover, while more thought is needed, there will be a way to talk at the Frames-levels ( and thus, calculate graph algorithms according to one’s domain model. Ultimately, in time, as Furnace develops, we will see a Rexster-Kibble that supports the evaluation of algorithms via Rexster.

While the project is still developing, please feel free to contribute ideas and/or participate in the development process. To conclude, we hope people are excited about the promises that Furnace will bring by raising the processing abstraction level above the imperative representations of Pipes/Gremlin.

Thank you,

You have been waiting for the opportunity to contribute to the Tinkerpop stack, particularly on graph analysis, so here is your chance! Seriously, you need to forward this to every graph person, graph project and graduate student taking graph theory.

We can use simple graphs and hope (pray?) the world is a simple place. Or use more complex graphs to model the world. Do you feel lucky? Do you?

Tinkerpop Stack Releases

Sunday, September 18th, 2011

Marko Rodriguez announced a new round of Tinkerpop Stack Releases today:

The TinkerPop stack went through another round of releases this morning.

  • Blueprints 1.0 (Blueprints): =
  • Pipes 0.8 (Cleaner): =
  • Frames 0.5 (Beams): =
  • Gremlin 1.3 (On the Case): =
  • Rexster 0.6 (Dalmatian): =
    • Rexster-Kibbles 0.6 =

For those using Gremlin, Pipes, and Rexster, be sure to look through the release notes as APIs have changed slightly. Here are the main points of this release:

  • Blueprints now has transaction buffers and Neo4jBatchGraph for bulk loading a Neo4j graph.
  • Pipes makes use of FluentPipeline and PipeFunction which yields great expressivity and further opens up the framework to other JVM languages.
  • Gremlin is ~2.5x faster in many situations and has relegated most of its functionality to Pipes and native Java.
  • Rexster supports Neo4j High Availability and more updates to its REST API.

TinkerPop – New Releases

Monday, August 1st, 2011

Good news from Marko Rodriguez:

TinkerPop just released a new round of stable releases.

Blueprints 0.9 (Mavin) –

Pipes 0.7 (PVC) –

Frames 0.4 (Studs) –

Gremlin 1.2 (New Sheriff in Town) –

Rexster 0.5 (Dog Star) –

Here is the main points with each release:

  • Blueprints:
    • Vertex API changed so now you have Vertex.getInEdges(String‚Ķ labels) and Vertex.getOutEdges(String‚Ķ labels)
    • Heavy development on GraphSail which turns any IndexableGraph into Sail RDF store
  • Pipes:
    • Introduced PipeClosure pattern which allows for closure-based pipes in native Java
    • Migrated all “Gremlin-specific pipes” (closure-based) to Pipes
    • Opening up the stage for data flow traversal languages for any JVM language
  • Frames:
    • Added helper interfaces VertexFrame and EdgeFrame
  • Gremlin:
    • Support the easy definition of new steps with
    • Mass migration of all “Gremlin-specific pipes” to Pipes
    • Support for processing closures in aggregate, groupCount, and paths
  • Rexster:
    • Added RexPro (the future foundation for the Rexster’s multi-protocol infrastructure).
    • Added (RexsterConsole) to allow remote “mysql>”-style interactions via any JSR 223-based JVM language
    • JSON serialization inherited from Blueprints (consistent throughout TinkerPop stack)


Saturday, July 16th, 2011

bulbflow: a Python framework for the graph era

From the Overview:

Bulbs is an open-source Python persistence framework for graph databases and the first piece of a larger Web-development toolkit that will be released in the upcoming weeks.

It’s like an ORM for graphs, but instead of SQL, you use the graph-traveral language Gremlin to query the database.

You can use it to connect to any Blueprints-enabled
database, including TinkeGraph, Neo4j, OrientDB, Dex, and OpenRDF (and there is an InfiniteGraph implementation in development).

This means your code is portable because you can to plug into different graph database backends without worrying about vendor lock in.

Bulbs was developed in the process of building Whybase, a startup that will open for preview this fall. Whybase needed a persistence layer to model its complex relationships, and Bulbs is an open-source version of that framework.

You can use Bulbs from within any Python Web-development framework, including Flask, Pyramid, and Django.

Will be watching for future developments!

OrientDB 1.0rc3 – Graph(Ed)

Friday, July 15th, 2011

OrientDB 1.0rc3 – Graph(Ed)

From the webpage:

This is a special edition of OrientDB with these TinkerPop technologies in bundle:

  • Blueprints provides a collection of interfaces and implementations to common, complex data structures. In short, Blueprints provides a one stop shop for implemented interfaces to help developers create software without being tied to particular underlying data management systems.
  • Gremlin is a Turing-complete, graph-based programming language designed for key/value-pair multi-relational graphs. Gremlin makes use of an XPath-like syntax to support complex graph traversals. This language has application in the areas of graph query, analysis, and manipulation.
  • Pipes is a graph-based data flow framework for Java 1.6+. A process graph is composed of a set of process vertices connected to one another by a set of communication edges. Pipes supports the splitting, merging, and transformation of data from input to output.

The graph community just keeps getting stronger.

Cloning Tinkerpop Repositories

Friday, July 1st, 2011

Instructions on creating a local copy of the Gremlin wiki (posted to the mailing list by Pierre De Wilde).

The instructions (with minor formatting changes) from his post:

For those who want a local copy of Gremlin wiki:

cd gremlin
git clone
cd doc/wiki

Open your browser at http://localhost:4567 and ta-da…

Moreover, the wiki is searchable and (unlike the github version) it’s printer-fiendly.

Gollum is a simple wiki system built on top of Git that powers GitHub Wikis.

To install Gollum, use RubyGems (

[sudo] gem install gollumcd cd

Of course, the same procedure may be applied for other Tinkerpop repositories (blueprints, pipes, frames, rexster, rexster-kibbles).

Unfortunately, gollum cannot access multiple repositories at once, so you will need to launch several versions with a different port (gollum -port xxxx)

Thanks Pierre!

pyblueprints 0.1

Thursday, June 30th, 2011

pyblueprints 0.1

From the webpage:

Following the set of interfaces provided by tinkerpop for Blueprints, this proyect aims to give Python developers a similar functionality. A set of abstract classes are defined in order to guide the design of implementations for the different graph database engines.

If you are not already familiar with BluePrints, a common API for graph databases, you might want to start at TinkerPop. Or you can jump directly to BluePrints if you are checking a detail or what to help with the code.

From the Blueprints webpage:

Blueprints is a property graph model interface. It provides implementations, test suites, and supporting extensions. Graph databases and frameworks that implement the Blueprints interfaces automatically support Blueprints-enabled applications. Likewise, Blueprints-enabled applications can plug-and-play different Blueprints-enabled graph backends.

TinkerPop Releases – Gremlin 1.0/Rexster 0.3

Monday, May 9th, 2011

Marko Rodriguez announced the release of Gremlin 1.0 and Rexster 0.3 (graph server) along with other releases:

Blueprints 0.7 (Patrick):
A property graph interface.

Frames 0.2 (Huff and Puff):
An object to graph framework.

Gremlin 1.0 (Gremlin):
A graph traversal language.

Pipes 0.5 (Drain):
A data flow framework using process graphs.

Rexster 0.3 (Dog Eat Dog):
A RESTful graph shell.

The Path-o-Logical Gremlin

Saturday, April 16th, 2011

The Path-o-Logical Gremlin

Slides from Marko Rodriguez presented at: The 2nd International Workshop on Graph Data Management (GDM’11) Hannover, Germany April 16, 2011.

State of Gremlin 0.9.

Very good introduction to Gremlin.

Collaborative Graph Editing with GitGraph

Thursday, April 14th, 2011

Collaborative Graph Editing with GitGraph

Anyone interested in graph editing really needs to watch this series of posts on the gremlin-users list.

Joshua Shinavier started the thread with a post that read in part:

I would like to draw attention to a new utility for Blueprints which was motivated as follows. Lately, I have been faced with the problem of trying to synchronize graph-y data between a mobile phone and a desktop application. This is hard not only because the data model I had in mind, RDF, is complicated, but also by some basic requirements (on top of just getting the data to look the same on both devices):

1) it should be possible to load only a portion of the data on the phone, and to push and pull changes to that portion without corrupting the overall graph
2) it should be easy to revert changes, and it would be nice to be able to branch
3) collaborators should be able to contribute changes to the graph, as well

This morning, it occurred to me that we could have these features in Blueprints if we just serialize graphs in a way which plays well with Git. I then spent all day coding, and the result is GitGraph, a persistent Graph implementation (currently layered on top of TinkerGraph) which stores its data in a hierarchy of canonically
ordered, diff-friendly plain text files. You can check a GitGraph directory into GitHub, fork, edit and merge it just as you would a piece of software. Also cool:

1) you can load subdirectories of a GitGraph as standalone graphs, and edit them independently of the rest of the graph
2) placing two or more GitGraphs in the same directory creates a super-GitGraph which you can load as one graph. You can then create edges which span the two graphs and create new top-level vertices. You can go back to a view of the individual graphs at any time.
3) no additional API, apart from the GitGraph constructor

Not hard to see why that provoked a wave of enthusiastic posts.


Saturday, April 9th, 2011


Claudio Martella walks through loading DBpedia into a graphDB.

DISCLAIMER: this is a bit of a hack, but it should get you started. I managed to get the core dataset of DBpedia into Neo4J, but this procedure should actually be working for any Blueprints-ready vendor, like OrientDB.

Ok, a little background first: we want to store DBpedia inside of a GraphDB, instead of the typical TripleStore, and run SPARQL queries over it. DBpedia is a project aiming to extract structured content from Wikipedia, information such as the one you can find in the infoboxes, the links, the categorization infos, geo-coordinates etc. This information is extracted and exported as triples to form a graph, a network of properties and relationships between Wikipedia resources.

Noting that graph queries are more efficient than when against a triple store.

Tinkerpop – New Releases

Monday, April 4th, 2011

Tinkerpop – New Releases

From the release notes:

Blueprints 0.6 Oscar:
Pipes 0.4 Spigot:
Frames 0.1 Brick-by-Brick:
Gremlin 0.9 Gremlin the Grouch:

TinkerPop Updates

Thursday, March 3rd, 2011

From the update announcement on 1 March 2011.

Today we bring you a new round of releases. TinkerPop is pleased to announce:

Blueprints 0.5 (Scooby) –
Pipes 0.3.1 (Mario) –
Gremlin 0.8 (Grem Stefani) –
Rexster 0.2 (Dog House) –

The graph database work and associated materials is looking more and more attractive.

Look for something specific about applying them to topic maps in the near term.