• Gem Version
  • Build Status
  • Code Climate
  • Coverage Status

Welcome to Neography

Neography is a thin Ruby wrapper to the Neo4j Rest API, for more information:

If you want to utilize the full power of Neo4j, you will want to use JRuby and the excellent Neo4j.rb gem at by Andreas Ronge



Add neography to your Gemfile:

ruby gem 'neography'

And run Bundler:

sh $ bundle


Or install neography manually:

sh $ gem install 'neography'

And require the gem in your Ruby code:

ruby require 'rubygems' require 'neography'

Read the wiki for information about dependencies.

Rake tasks are available for downloading, installing and running Neo4j.


Configuration and initialization

Configure Neography as follows:

ruby # these are the default values: Neography.configure do |config| config.protocol = "http" config.server = "localhost" config.port = 7474 = "" # prefix this path with '/' config.cypher_path = "/cypher" config.gremlin_path = "/ext/GremlinPlugin/graphdb/execute_script" config.log_file = "neography.log" config.log_enabled = false config.slow_log_threshold = 0 # time in ms for query logging config.max_threads = 20 config.authentication = nil # 'basic' or 'digest' config.username = nil config.password = nil config.parser = MultiJsonParser config.http_send_timeout = 1200 config.http_receive_timeout = 1200 config.persistent = true end

Then initialize a Rest instance:

ruby @neo = @neo ={:authentication => 'basic', :username => "neo4j", :password => "swordfish"}) @neo ="http://neo4j:swordfish@localhost:7474")

For overriding these default and other initialization methods, see the configuration and initialization page in the Wiki.


Neography supports the creation and retrieval of nodes and relationships through the Neo4j REST interface. It supports indexes, Gremlin scripts, Cypher queries and batch operations.

Some of this functionality is shown here, but all of it is explained in the following Wiki pages:

2.0 Only features:

1.8+ features:

Some example usage:

```ruby # Node creation: node1 = @neo.create_node(“age” => 31, “name” => “Max”) node2 = @neo.create_node(“age” => 33, “name” => “Roel”)

Node properties:

@neo.set_node_properties(node1, => 200)

Relationships between nodes:

@neo.create_relationship(“coding_buddies”, node1, node2)

Get node relationships:

@neo.get_node_relationships(node2, “in”, “coding_buddies”)

Use indexes:

@neo.add_node_to_index(“people”, “name”, “max”, node1) @neo.get_node_index(“people”, “name”, “max”)


@neo.batch [:create_node, => “Max”], [:create_node, => “Marc”]

Cypher queries:

@neo.execute_query(“start n=node(0) return n”)


You can also use the cypher gem instead of writing cypher as text.

node(1).outgoing(rel(:friends).where{|r| r[:since] == 1994})

would become:

START me=node(1) MATCH (me)-[friend_rel:`friends`]->(friends) WHERE (friend_rel.since = 1994) RETURN friends

This is just a small sample of the full API, see the Wiki documentation for the full API.

Neography raises REST API errors as Ruby errors, see the wiki page about errors. (Note: older versions of Neography did not raise any errors!)

Phase 2

Trying to mimic the Neo4j.rb API.

Now we are returning full objects. The properties of the node or relationship can be accessed directly ( The Neo4j ID is available by using node.neo_id.

Some of this functionality is shown here, but all of it is explained in the following Wiki pages:

```ruby # create two nodes: n1 = Neography::Node.create(“age” => 31, “name” => “Max”) n2 = Neography::Node.create(“age” => 33, “name” => “Roel”)

n1.exist? # => true

get and change some properties:

n1[:age] # => 31 # => “Max” n1[:age] = 32 # change property n1.weight = 190 # new property n1.age = nil # remove property

add a relationship between nodes:

new_rel = Neography::Relationship.create(:coding_buddies, n1, n2)

remove a relationship:


add a relationship on nodes:

n1.outgoing(:coding_buddies) « n2

more advanced relationship traversal:

n1.outgoing(:friends) # Get nodes related by outgoing friends relationship n1.outgoing(:friends).depth(2).include_start_node # Get n1 and nodes related by friends and friends of friends

n1.rel?(:outgoing, :friends) # Has outgoing friends relationship n1.rels(:friends,:work).outgoing # Get outgoing friends and work relationships

n1.all_paths_to(n2).incoming(:friends).depth(4) # Gets all paths of a specified type n1.shortest_path_to(n2).incoming(:friends).depth(4).nodes # Gets just nodes in path ```

This is just a small sample of the full API, see the Wiki documentation for the full API.



Some example code.


Some tips about testing.

Complement to Neography are the:

An alternative to Neography is Architect4r by Maximilian Schulz

Neography in the Wild

  • Vouched
  • Neovigator fork it at
  • Neoflix fork it at

Getting started with Neography


Please create a new issue if you run into any bugs.

Contribute patches via pull requests.


If you are just starting out, or need help send me an e-mail at

Check you my blog at where I have more Neography examples.


  • Neography - MIT, see the LICENSE file
  • Lucene - Apache, see
  • Neo4j - Dual free software/commercial license, see