Planet Neo4j

by Anders Nawroth (noreply@blogger.com) at August 17, 2010 01:54 PM · Image shamelessly stolen from Chris Messina who wrote an excellent post on the Open Graph Protocol, image based on original work by martiniko.

bzr checkout lp:~bujacik/gephi/support-for-neo4j
for ( Path position : Traversal.description()
       .depthFirst()
       .relationships( KNOWS )
       .relationships( LIKES, Direction.INCOMING )
       .prune( Traversal.pruneAfterDepth( 5 ) )
       .traverse( myStartNode ) )
{
   System.out.println( "Path from start node to current position is " + position );
}

static final TraversalDescription FRIENDS_TRAVERSAL = Traversal.description()
   .relationships( KNOWS )
   .depthFirst()
   .uniqueness( Uniqueness.RELATIONSHIP_GLOBAL );
// ...
// Don't go further than depth 3
for ( Path position : FRIENDS_TRAVERSAL
       .prune( Traversal.pruneAfterDepth( 3 ) )
       .traverse( myNode ) ) {}
// Don't go further than depth 4
for ( Path position : FRIENDS_TRAVERSAL
       .prune( Traversal.pruneAfterDepth( 4 ) )
       .traverse( myNode ) ) {}

EmbeddedGraphDatabase graphDb = getTheGraphDbFromApp();
String location = "/var/backup/neo4j-db";
// this will include the integrated lucene indexes as well
Backup backup = Neo4jBackup.allDataSources( graphDb, location );
backup.doBackup();

FB.api('/me/friends', function(response) {
   friends = response.data;
   // Load friends into UI
   friend_list.empty();
   for ( var i = 0; i < friends.length; i ++ ) {
      add_friend( friends[i] ); // write to UI
   }
});
FB.api("/" + friend.id + "/movies", function(result)
{
 /* handle the response here */ 
}
FB.init({
   appId  : '', // NOTE: create an appid and add it here
   status : true, cookie : true, xfbml  : true,
   // time to add our IMDB backend to the mix
   external_domains : {
      imdb : 'http://localhost:4567/'
   }
});
FB.api("imdb:/path/to/data/in/graph", function(data) {
  // data is available here :)
});
{
  "name": "Bacon, Kevin",
  "id": 56
}
{
  "name": "Bacon, Kevin",
  "id": 56,
  "metadata": {
    "connections": "http://localhost:4567/56/acted_in"
  },
  "type": "actor"
}
{
  "data": [
  {
    "id": 57,
    "title": "Woodsman, The (2004)"
  },
  {
    "id": 59,
    "title": "Wild Things (1998)"
  }
  // tons of movies here ...
 ]
}
{
  "title": "Wild Things (1998)",
  "year": "1998",
  "id": 59
}
{
  "title": "Wild Things (1998)",
  "year": "1998",
  "id": 59,
  "metadata": {
    "connections": "http://localhost:4567/59/actors"
  },
  "type": "movie"
}
{
  "data": [
  {
    "id": 56,
    "name": "Bacon, Kevin"
  },
  {
    "id": 528,
    "name": "Dillon, Matt (I)"
  }
  // loads of actors here ...
 ]
}
[
  {
    "name": "Bacon, Kevin",
    "id": 56
  },
  {
    "name": "Bacon, Travis",
    "id": 14242
  }
  // more bacons here ...
]
[
  {
    "title": "Wild Things (1998)",
    "year": "1998",
    "id": 59
  },
  {
    "title": "River Wild, The (1994)",
    "year": "1994",
    "id": 74
  }
  // more wild movies here ...
]
self.movie_info = function( movie_name, callback ) {
    // The search API uses commas for AND-type searches, spaces become OR, so for
    // the movie names, we switch spaces out for commas.
    movie_name = movie_name.replace(/ /g, ",");
    FB.api("imdb:/search", {type:'movie', q:movie_name }, callback );
};
FB.api("imdb:/" + actor.id + "/acted_in", function( result ) {
  for (var i = 0; i < result.data.length; i++)
  {
      movie = result.data[i];
      // do something with the movie here!
  }
});
FB.api("imdb:/" + movie.id + "/actors", function(result) {
  for (var i = 0; i < result.data.length; i++)
  {
      actor = result.data[i];
      // do something with the actor here!
  }
});
class Movie; end

class Role
 include Neo4j::RelationshipMixin
 property :title, :character
end

class Actor
 include Neo4j::NodeMixin
 property :name
 has_n(:acted_in).to(Movie).relationship(Role)
 index :name, :tokenized => true
end

class Movie
 include Neo4j::NodeMixin
 property :title
 property :year
 index :title, :tokenized => true

 # defines a method for traversing incoming acted_in relationships from Actor
 has_n(:actors).from(Actor, :acted_in)
end
get '/:id' do # show a node
 content_type 'text/javascript'
 node = node_by_id(params[:id])
 props = external_props_for(node)
 props.merge! metadata_for(node) if params[:metadata] == "1"
 json = JSON.pretty_generate(props)
 json = callback_wrapper(json, params[:callback])
 json
end
def node_by_id(id)
 node = Neo4j.load_node(id) if id =~ /^(\d+)$/
 halt 404 if node.nil?
 node
end
def external_props_for(node)
 ext_props = node.props.delete_if{|key, value| key =~ /^_/}
 ext_props[:id] = node.neo_id
 ext_props
end
def metadata_for(node)
 if node.kind_of? Actor
   connections = url_for(node, "acted_in")
 elsif node.kind_of? Movie
   connections = url_for(node, "actors")
 end
 metadata = { :metadata => { :connections => connections }, :type => node.class.name.downcase }
end
get '/:id/:relation' do # show a relationship
 content_type 'text/javascript'
 node = node_by_id(params[:id])
 data = []
 [ :acted_in, :actors ].each do |relationship|
   if params[:relation] == relationship.to_s and node.respond_to? relationship
     data = node.send(relationship)
   end
 end
 data = data.map{|node| node_data(node)}
 json = JSON.pretty_generate({:data => data})
 json = callback_wrapper(json, params[:callback])
 json
end
def node_data(node)
 data = { :id => node.neo_id }
 [ :name, :title ].each do |property|
   data.merge!({ property => node[property] }) unless node[property].nil?
 end
 data
end
get '/search' do
 content_type 'text/javascript'
 q = params[:q]
 type = params[:type]
 halt 400 unless q && type
 result = case type
   when 'actor'
     Actor.find(to_lucene(:name, q))
   when 'movie'
     Movie.find(to_lucene(:title, q))
   else
     []
 end
 json = JSON.pretty_generate(result.map{|node| external_props_for(node)})
 json = callback_wrapper(json, params[:callback])
 json
end
INeo4jStorageClient neo4JStorageClient =
Neo4jStorageFactory.GetNodeStorageClient(neo4jServerUri);

neo = new Person("Thomas Anderson");
neo4JStorageClient.StoreNode(neo);
public void StoreNode(Person person)
{
    var name = person.Name;

    string jsonString = @"{""Name"":""" + name + @"""}";

    var nodeProtocol = new NodeProtocol(uri);

    var nodeId = nodeProtocol.PostNode(jsonString);
    person.Id = nodeId;
}
public int PostNode(string nodeData)
{
    var uri = HttpHelper.ConcatUri(baseUri, "node");

    HttpWebRequest request =
        Request.CreateWebRequest(HttpWebRequestMethod.POST, uri);

    HttpHelper.AddBody(request, nodeData);

    var response = requestMaker.MakeRequest(request);

    return HttpHelper.FindNodeId(response.Item3);
}

POST http://try.neo4j.org:9999/node HTTP/1.1
Content-Type: application/json
Host: try.neo4j.org:9999
Content-Length: 26
Expect: 100-continue
Connection: Keep-Alive

{"Name":"Thomas Anderson"}

HTTP/1.1 201 Created
server: grizzly/1.8.1
Content-Encoding: UTF-8
Location: http://try.neo4j.org:9999/node/1

Content-Type: application/json
Content-Length: 860
Date: Fri, 16 Apr 2010 08:36:45 GMT

{"incoming typed relationships":

http://try.neo4j.org:9999/node/1/relationships/in/{-list|&|types},

"incoming relationships":http://try.neo4j.org:9999/node/1/relationships/in,

"all relationships":http://try.neo4j.org:9999/node/1/relationships/all,

"create relationship":http://try.neo4j.org:9999/node/1/relationships,

"data":{"Name":"Thomas Anderson"},

"traverse":http://try.neo4j.org:9999/node/1/traverse/{returnType},

"property":http://try.neo4j.org:9999/node/1/properties/{key},

"self":http://try.neo4j.org:9999/node/1,

"properties":http://try.neo4j.org:9999/node/1/properties,

"all typed relationships":

http://try.neo4j.org:9999/node/1/relationships/all/{-list|&|types},

"outgoing typed relationships":

http://try.neo4j.org:9999/node/1/relationships/out/{-list|&|types},

"outgoing relationships":http://try.neo4j.org:9999/node/1/relationships/out}

POST http://try.neo4j.org:9999/node/1/relationships HTTP/1.1
Content-Type: application/json
Host: try.neo4j.org:9999
Content-Length: 56
Expect: 100-continue

{"type":"Knows","to":http://try.neo4j.org:9999/node/2}

POST http://try.neo4j.org:9999/node/1/traverse/node HTTP/1.1
Accept: application/json
Content-Type: application/json
Host: try.neo4j.org:9999
Content-Length: 57
Expect: 100-continue
Connection: Keep-Alive

{ "relationships": { "type": "Knows" }, "max depth": 10 }

$ ./bin/neo4j-rest start
peterneubauer$ curl -H Accept:application/json -H Content-Type:application/json -v http://localhost:9999
* About to connect() to localhost port 9999 (#0)
*   Trying 127.0.0.1... connected
* Connected to localhost (127.0.0.1) port 9999 (#0)
> GET / HTTP/1.1
> User-Agent: curl/7.19.7 (i386-apple-darwin10.2.0) libcurl/7.19.7 zlib/1.2.3
> Host: localhost:9999
> Accept:application/json
> Content-Type:application/json

* Connection #0 to host localhost left intact 
* Closing connection #0 
{ 
  "index":"http://localhost:9999/index",
  "node":"http://localhost:9999/node",
  "reference node":"http://localhost:9999/node/0" 
}

peterneubauer$ curl -H Accept:application/json -H Content-Type:application/json -v http://localhost:9999/node/0
* About to connect() to localhost port 9999 (#0)
*   Trying 127.0.0.1... connected
* Connected to localhost (127.0.0.1) port 9999 (#0)
> GET /node/0 HTTP/1.1
> User-Agent: curl/7.19.7 (i386-apple-darwin10.2.0) libcurl/7.19.7 zlib/1.2.3
> Host: localhost:9999
> Accept:application/json
> Content-Type:application/json
>
{
"incoming typed relationships":"http://localhost:9999/node/0/relationships/in/{-list|&|types}",
"incoming relationships":"http://localhost:9999/node/0/relationships/in",
"all relationships":"http://localhost:9999/node/0/relationships/all",
"create relationship":"http://localhost:9999/node/0/relationships",
"data":{},
"traverse":"http://localhost:9999/node/0/traverse/{returnType}",
"property":"http://localhost:9999/node/0/properties/{key}",
"self":"http://localhost:9999/node/0",
"properties":"http://localhost:9999/node/0/properties",
"all typed relationships":"http://localhost:9999/node/0/relationships/all/{-list|&|types}",
"outgoing typed relationships":"http://localhost:9999/node/0/relationships/out/{-list|&|types}",
"outgoing relationships":"http://localhost:9999/node/0/relationships/out"
}

peterneubauer$ curl -X POST -H Accept:application/json -v localhost:9999/node
* About to connect() to localhost port 9999 (#0)
*   Trying 127.0.0.1... connected
* Connected to localhost (127.0.0.1) port 9999 (#0)
> POST /node HTTP/1.1
> User-Agent: curl/7.19.7 (i386-apple-darwin10.2.0) libcurl/7.19.7 zlib/1.2.3
> Host: localhost:9999
> Accept:application/json
>
{
...
"self":"http://localhost:9999/node/1",
"data":{},
...
}

curl -X DELETE  -v localhost:9999/node/1

curl -X POST -H Accept:application/json -H Content-Type:application/json -d '{"name":"Mr. Andersson"}' -v localhost:9999/node
curl -X POST -H Accept:application/json -H Content-Type:application/json -d '{"name":"Morpheus"}' -v localhost:9999/node
curl -X POST -H Accept:application/json -H Content-Type:application/json -d '{"name":"Trinity"}' -v localhost:9999/node
curl -X POST -H Accept:application/json -H Content-Type:application/json -d '{"name":"Cypher"}' -v localhost:9999/node
curl -X POST -H Accept:application/json -H Content-Type:application/json -d '{"name":"Agent Smith"}' -v localhost:9999/node
curl -X POST -H Accept:application/json -H Content-Type:application/json -d '{"name":"The Architect"}' -v localhost:9999/node
curl -X POST -H Accept:application/json -H Content-Type:application/json -d '{"to":"http://localhost:9999/node/1","type":"ROOT"}' -v http://localhost:9999/node/0/relationships
curl -X POST -H Accept:application/json -H Content-Type:application/json -d '{"to":"http://localhost:9999/node/2","type":"KNOWS"}' -v http://localhost:9999/node/1/relationships
curl -X POST -H Accept:application/json -H Content-Type:application/json -d '{"to":"http://localhost:9999/node/3","type":"KNOWS"}' -v http://localhost:9999/node/2/relationships
curl -X POST -H Accept:application/json -H Content-Type:application/json -d '{"to":"http://localhost:9999/node/4","type":"KNOWS"}' -v http://localhost:9999/node/2/relationships
curl -X POST -H Accept:application/json -H Content-Type:application/json -d '{"to":"http://localhost:9999/node/5","type":"KNOWS"}' -v http://localhost:9999/node/4/relationships
curl -X POST -H Accept:application/json -H Content-Type:application/json -d '{"to":"http://localhost:9999/node/6","type":"CODED BY"}' -v http://localhost:9999/node/5/relationships
curl -X POST -H Accept:application/json -H Content-Type:application/json -d '{"to":"http://localhost:9999/node/1","type":"LOVES"}' -v http://localhost:9999/node/3/relationships
{
"order": "depth first",
"uniqueness": "node path",
"relationships": [
{ "type": "KNOWS", "direction": "out" },
{ "type": "LOVES" }
],
"prune evaluator": {
"language", "javascript",
"body", "position.node().getProperty('date')>1234567;"
},
"return filter": {
"language": "builtin",
"name", "all"
},
"max depth": 2
}
curl -X POST -H Accept:application/json -H Content-Type:application/json -d '{"order":"breadth first"}' -v http://localhost:9999/node/3/traverse/node
[TestMethod]
public void StreamWriter_with_encoding_writes_ByteOrderMark()
{
    string str = "foo";

    var memStream = new MemoryStream();

    // Test
    var writer = new StreamWriter(memStream, Encoding.UTF8);
    writer.Write(str);
    writer.Flush();

    Assert.AreEqual(6, memStream.Length);

    var buffer = new byte[3];

    memStream.Position = 0;
    memStream.Read(buffer, 0, 3);
    string result = Encoding.UTF8.GetString(buffer);

    var preamble = Encoding.UTF8.GetPreamble();
    var byteOrderMarkUtf8 = Encoding.UTF8.GetString(preamble);

    Assert.AreEqual(byteOrderMarkUtf8, result);

    memStream.Position = 3;
    memStream.Read(buffer, 0, 3);
    result = Encoding.UTF8.GetString(buffer);

    Assert.AreEqual(str, result);

    // Alternative: Write the bytes yourself to skip the BOM

    memStream = new MemoryStream();

    foreach (var @byte in Encoding.UTF8.GetBytes(str))
    {
        memStream.WriteByte(@byte);
    }

    Assert.AreEqual(3, memStream.Length);
}
#implements a Java Interface
class GeoCostEvaluator
  include EstimateEvaluator
  def getCost(node, goal)
    distance(node.getProperty("lat"), node.getProperty("lon"), goal.getProperty("lat"),goal.getProperty("lon"))
  end
end

#calculates a geodetic distance between two spatial points
def distance(start_lat, start_lon, other_lat, other_lon)
  latitude1 = start_lat.to_f * Math::PI/180 #in radian
  longitude1 = start_lon.to_f * Math::PI/180 #in radian
  latitude2 = other_lat.to_f * Math::PI/180 #in radian
  longitude2 = other_lon.to_f * Math::PI/180 #in radian
  cLa1 = Math.cos( latitude1 );
  x_A = RADIUS_EARTH * cLa1 * Math.cos( longitude1 )
  y_A = RADIUS_EARTH * cLa1 * Math.sin( longitude1 )
  z_A = RADIUS_EARTH * Math.sin( latitude1 );

  cLa2 = Math.cos( latitude2 );
  x_B = RADIUS_EARTH * cLa2 * Math.cos( longitude2 )
  y_B = RADIUS_EARTH * cLa2 * Math.sin( longitude2 )
  z_B = RADIUS_EARTH * Math.sin( latitude2 )

  #in meters
  distance = Math.sqrt( ( x_A - x_B ) * ( x_A - x_B ) + ( y_A - y_B ) * ( y_A - y_B ) + ( z_A - z_B ) * ( z_A - z_B ) )
end

#domain model
class Road
  include Neo4j::RelationshipMixin

  property :cost
end

class Waypoint
  include Neo4j::NodeMixin

  # neo4j node properties
  property :lat, :lon, :name

  # lucene indexed node properties
  index :name

  # relationships to other waypoints
  has_n(:road).to(Waypoint).relationship(Road)

  # for this example just calculate the straight distance between points as cost
  def connect(other)
    self.road.new(other).update(:cost => distance(self.lat, self.lon, other.lat, other.lon))
  end
  def to_s
    "Waypoint, #{name}, lon=#{lon}, lat=#{lat}"
  end
end

# create point, and look up the location via Yahoo! MapsService
def create_waypoint(city, state)
  url = "http://local.yahooapis.com/MapsService/V1/geocode?appid=#{APP_ID}"
  res = Net::HTTP.get(URI.parse( URI.escape(url + "&state=#{state}&city=#{city}") ))

  lat = res.slice(/Latitude\>(.*)\\/Latitude/,1)
  lon = res.slice(/Longitude\>(.*)\\/Longitude/,1)
  point = Waypoint.new :name=>city, :lon=>lon, :lat=>lat
  puts point
  point
end

# populating the routing test
Neo4j::Transaction.run do
  NYC = create_waypoint('New York', 'New York')
  KAN = create_waypoint('Kansas City', 'Kansas')
  SFE = create_waypoint('Santa Fe', 'New Mexico')
  SEA = create_waypoint('Seattle', 'Washington')
  SF = create_waypoint('San Francisco', 'CA')
  NYC.connect(KAN)
  NYC.connect(SEA)
  SEA.connect(SF)
  KAN.connect(SFE)
  SFE.connect(SF)
end

# Finding the route
sp = AStar.new( Neo4j::instance, RelationshipExpander.forTypes( DynamicRelationshipType.withName('Waypoint#road'), Direction::BOTH),
				        DoubleEvaluator.new("cost") , GeoCostEvaluator.new)
path = sp.findSinglePath(NYC._java_node, SF._java_node)
nodes = path.getNodes.iterator
until !nodes.hasNext() do 
  puts nodes.next.getProperty('name')
end

Waypoint, New York, lon=-74.007124, lat=40.714550
Waypoint, Kansas City, lon=-94.626824, lat=39.113380
Waypoint, Santa Fe, lon=-105.937406, lat=35.691543
Waypoint, Seattle, lon=-122.329439, lat=47.603560
Waypoint, San Francisco, lon=-122.420139, lat=37.779600
New York
Kansas City
Santa Fe
San Francisco

import neo4j
from neo4j.util import Subreference
attribute_subref_node = Subreference.Node.ATTRIBUTE_ROOT(graphdb)
attribute_subref_node.ATTRIBUTE_TYPE(new_attribute_type_node)
category_subref_node = Subreference.Node.CATEGORY_ROOT(graphdb, Name="Products")
computers_node = graphdb.node(Name="Computers")
electronics_node.SUBCATEGORY(computers_node)
for rel in category_node.SUBCATEGORY.outgoing:
  print rel.end['Name']
class SubCategoryProducts(neo4j.Traversal):
  types = [neo4j.Outgoing.SUBCATEGORY, neo4j.Outgoing.PRODUCT]
  def isReturnable(self, pos):
      if pos.is_start: return False
      return pos.last_relationship.type == 'PRODUCT'
for prod in SubCategoryProducts(category_node):
  print prod['Name']
def attributes(product_node):
  """Usage:
  for attr in attributes(product):
      print attr['Name'], " of type ", attr.end['Name']
  """
  for category in categories(product_node):
      for attr in category.ATTRIBUTE:
          yield attr

class categories(neo4j.Traversal):
  types = [neo4j.Incoming.PRODUCT, neo4j.Incoming.SUBCATEGORY]
  def isReturnable(self, pos):
      return not pos.is_start
sudo apt-get install jruby
sudo jruby -S gem install neo4j
require 'rubygems'
require 'neo4j'
require 'neo4j/extensions/find_path'
def get_or_create_sub_ref( name )
  result = Neo4j.ref_node.rels.outgoing( name ).nodes.first
  if ( result.nil? )
    result = Neo4j::Node.new :name => name.to_s.capitalize.gsub("_", " ")
    Neo4j.ref_node.rels.outgoing( name )  result
  end
  return result
end
def new_principal( name, member_of_groups = [] )
  principal = Neo4j::Node.new
  principal[ :name ] = name
  if member_of_groups.empty?
    get_or_create_sub_ref( :PRINCIPALS ).rels.outgoing( :PRINCIPAL )  principal
  else
    for group in member_of_groups
      principal.rels.outgoing( :IS_MEMBER_OF_GROUP )  group
    end
  end
  return principal
end
Neo4j::Transaction.run do
  all_principals = new_principal( "All principals" )
  root = new_principal( "root", [ all_principals ] )
  regular_users = new_principal( "Regular users", [ all_principals ] )
  user1 = new_principal( "user1", [ regular_users ] )
  user2 = new_principal( "user2", [ regular_users ] )
end
def new_content( name, parent = nil )
  content = Neo4j::Node.new
  content[ :name ] = name
  if ( parent.nil? )
    get_or_create_sub_ref( :CONTENT_ROOTS ).rels.outgoing( :CONTENT_ROOT )  content
  else
    parent.rels.outgoing( :HAS_CHILD_CONTENT )  content
  end
  return content
end
Neo4j::Transaction.run do
  root_folder = new_content( "Root folder" )
  temp_folder = new_content( "Temp", root_folder )
  home_folder = new_content( "Home", root_folder )
  user1_home_folder = new_content( "user1 home", home_folder )
  user2_home_folder = new_content( "user2 home", home_folder )
  a_file = new_content( "MyFile.pdf", user1_home_folder )
end
def apply_security( content, principal, map_with_flags )
  security_relationship = Neo4j::Relationship.new( :SECURITY, principal, content )
  map_with_flags.each_pair {|key, value| security_relationship[ key ] = value}
end
Neo4j::Transaction.run do
  apply_security( root_folder, root, { "w" => true } )
  apply_security( root_folder, all_principals, { "r" => true } )
  apply_security( temp_folder, all_principals, { "w" => true } )
  apply_security( user1_home_folder, regular_users, { "r" => false, "w" => false } )
  apply_security( user1_home_folder, user1, { "r" => true, "w" => true } )
  apply_security( user2_home_folder, user2, { "r" => true, "w" => true } )
end
def has_access( content, principal, flag )
  for current_content in content.incoming( :HAS_CHILD_CONTENT ).depth( :all )
    lowest_score = nil
    lowest_modifier = nil
    for rel in current_content.rels.incoming( :SECURITY )
      rel_principal = rel.start_node
      if !rel[ flag ].nil?
        score = depth_of_principal( rel_principal, principal )
        if !score.nil?
          modifier = rel[ flag ]
          if lowest_score.nil? || score  lowest_score ||
            ( score == lowest_score && modifier )
            lowest_score = score
            lowest_modifier = modifier
          end
        end
      end
    end
    if !lowest_modifier.nil?
      return lowest_modifier
    end
  end
  return false
end
def depth_of_principal( principal, reference_principal )
  result = reference_principal.outgoing( :IS_MEMBER_OF_GROUP ).depth( :all ).path_to( principal )
  return result.nil? ? nil : result.size
end

def print_has_access( content, principal, flag )
  print principal[ :name ] + " +" + flag.upcase + " access to " + content[ :name ] + "? " +
    has_access( content, principal, flag ).to_s + "\n"
end
Neo4j::Transaction.run do
  print_has_access( home_folder, root, "w" )
  print_has_access( home_folder, user1, "w" )
  print_has_access( a_file, root, "r" )
  print_has_access( a_file, user2, "r" )
  print_has_access( a_file, user1, "w" )
end

Get Actor (or Movie) by Id
Request	Response
`/56`	{ "name": "Bacon, Kevin", "id": 56 }
Extended information about Actor(/Movie)
Request	Response
`/56?metadata=1`	{ "name": "Bacon, Kevin", "id": 56, "metadata": { "connections": "http://localhost:4567/56/acted_in" }, "type": "actor" }
All the Movies an Actor had a Role in
Request	Response
`/56/acted_in`	{ "data": [ { "id": 57, "title": "Woodsman, The (2004)" }, { "id": 59, "title": "Wild Things (1998)" } // tons of movies here ... ] }
Get (Actor or) Movie by Id
Request	Response
`/59`	{ "title": "Wild Things (1998)", "year": "1998", "id": 59 }
Extended information about (Actor/)Movie
Request	Response
`/59?metadata=1`	{ "title": "Wild Things (1998)", "year": "1998", "id": 59, "metadata": { "connections": "http://localhost:4567/59/actors" }, "type": "movie" }
All the Actors that have a Role in this Movie
Request	Response
`/59/actors`	{ "data": [ { "id": 56, "name": "Bacon, Kevin" }, { "id": 528, "name": "Dillon, Matt (I)" } // loads of actors here ... ] }
Search for Actors with "bacon" in their name
Request	Response
`/search?q=bacon&type=actor`	[ { "name": "Bacon, Kevin", "id": 56 }, { "name": "Bacon, Travis", "id": 14242 } // more bacons here ... ]
Search for Movies with "wild things" in their title
Request	Response
`/search?q=wild%20things&type=movie`	[ { "title": "Wild Things (1998)", "year": "1998", "id": 59 }, { "title": "River Wild, The (1994)", "year": "1994", "id": 74 } // more wild movies here ... ]

ER-model	Neo4j
Entity	Node
Relationship	Relationship
Attribute	Property

Planet Neo4j

1. Graph algorithms

2. Event framework

3. Traversal framework

4. Monitoring

5. Kernel

6. Index

7. Online backup

Conclusion

Videos

Screenshots

Event feed and other feeds

The new traversal framework

The new event framework

REST API news

Monitoring: JMX support

Graph algorithms

Indexing

Configurable block size

It's movie time!

Under the Hood

Facebook data

Neo4j data

How to create a Graph API service on top of Neo4j

Wrap up

Example source code

Credits

Ait, let's get started: what is this Open Graph anyway?

Ok, so what is the Facebook Graph API?

Fair enough, then finally what is the Open Graph Protocol?

Ok, so what's the bigger story here?

How do graph databases and Neo4j relate to all this?

Conclusion

Intro

Architecture

What did we do with the Architecture in our POC?

Our POC sample

Difficulties

What have we learned from this?

Introduction

Installation

Insert some data

The Matrix

Our first traversal

Summary

Context

What’s up with the BOM? What is it’s purpose?

How can you then – finally – handle these three bytes?

Introduction

Neo4j and routing

Summary

Introduction

Data model

Node space

Getting to the details

Wrap up

Preparation

Heading for the node space

Basic structure

At the core

Next steps

Subscriptions