To be honest, we were blown away.

Education

1. Organization Learning by @luannem – covering your path through courses and certifications in a learning management system.
2. Degrees offered by the University of Oviedo by @leyvanegri – solving use-cases for students at a university.
3. Interpreting Citation Patterns in Academic Publications: A research aid by Jonatan Jäderberg – an advanced use of graphs to connect scientific papers.

Finance

1. Graphing our way through the ICIJ offshore jurisdiction data by @hermansm – an impressive investigative tracking of leaked data sets about (legal) company activities.
2. Finance and Asset Management by @rushugroup is an interesting set of financial portfolio analytics use-cases.
3. Options Trading As A Graph by @lyonwj looks at how to model the tricky business of option trading in a graphy way.

Life Science

1. Medicine & drugs classification for the Central Hospital of Asturias by @Roqueeeeee and @luigi9215 is an impressive representation of drug-related use-cases for a hospital.
2. Competitive Intelligence in Cancer Drug Discovery by @livedataconcept cleanly models and queries available cancer drugs.
3. DoctorFinder! by @fbiville & the VIDAL team is a real life application on how to find the drugs and doctors for your symptoms.

Manufacturing

1. Project Management by @_nicolemargaret shows how graphs are perfect for dependency management in an incremental fashion.
2. Car Manufacturers 2013 by @fernanvic1 explores the intricate network of car manufacturers, their brands, investments and models.
3. Device manufacture trends by @shantaramw let’s you glimpse on how graphs can also exploited for business intelligence use-cases.

Sports

1. Alpine Skiing seasons by @pac_19 uses an intricate model to map the real FIS data into the graph to find some really cool insights.
2. F1 2012/2013 Season by @el_astur answers many different questions by looking at Formula one racing data.
3. League of Legends eSports – LCS by @SurrealAnalysis looks at different analytical statistics of the League Championship Series.

Resources

1. EPublishing: A graphical approach to digital publications by @deepeshk79 impressively covering a lot of different use-cases in the publication domain and workflow.
2. Piping Water by @shaundaley1 looks at London’s pipe system and how that natural graph could be managed by using a graph database.
3. QLAMRE: Quick Look at Mainstream Renewables Energies by @Sergio_Gijon is a quick look at categorizations of renewable energies.

Retail

1. Food Recommendation by @gromajus uses a graph model of food, ingredients and recipes to compute recommendations, taking preferences and allergies into account.
2. Single Malt Scotch Whisky by @patbaumgartner is my personal favorite, you certainly know why Ardbeg 17 is the best.
3. Phone store by @xun91 uses phone models, attributes, manufacturers and stock information to make recommendations for customers.

Telecommunication

1. Amazon Web Services Global Infrastructure Graph by @AIDANJCASEY represents all regions, zone, services and instance types as a graph awesome for just browsing or finding the best or cheapest offering.
2. Geoptima Event Log Collection Data Management by @craigtaverner is a really involved but real world model of mobile network event and device data tracking.
3. Mobile Operators in India by @rushugroup is a basic graph gist exploring the Indian phone network by device technology and operators.

Transport

1. Roads, Nodes and Automobiles by @tekiegirl shows how user provided road maps could be represented in a graph and what can you do with it. There are great example queries for the M3 and M25 motorways in the UK.
2. Bombay Railway Routes by @luannem shows advanced routing queries for the infamous railway network.
3. Trekking and Mountaineering routing by @shantaramw Himalayan routes in a graph are not just for hard-core trekkers and bikers, with useful answers.

Advanced Graph Gists

1. Movie Recommendations with k-NN and Cosine Similarity by @_nicolemargaret Nicole really shows off, computing, storing and using similarities between people for movie rating.
2. Skip Lists in Cypher by @wefreema – a graph is a universal data structure, why not use it for other data structures too. Wes shows how with a full blown skip list implementation with Cypher.
3. Small Social Networking Website by @RaulEstrada this is not over the top like others but a really good and comprehensive example on what graphs are good for.

Other

1. Embedded Metamodel Subgraphs in the FactMiners Social-Game Ecosystem Part 2 by @Jim_Salmons explores the possibilities of using data and meta-data in the same graph structure and which additional information you can infer about your data.
2. Legislative System Graph by @yaravind is an impressive collection of use cases on top of electorate data.
3. User, Functions, Applications, or “Slicing onion with an axe” by @karol_brejna covers resource and permission management of an IT infrastructure.

• interesting/insightful domain
• a good number of realistic use-cases with sensible result output
• description, model picture should be easy to understand
• sensible dataset size (at most 150 nodes 300 rels)
• good use of the GraphGist tools (table, graph, hide-setup etc)
• we had an epiphany while looking at the gist

The post Graph Gist Winter Challenge Winners appeared first on Neo4j Graph Database.

ARTICLES:

Neo4j + Spring Data – a natural fit for my data by Josh Long, Michael Hunger and Matti Tahvonen

Implementing Word Ladder game using Neo4j by Nikhil Kuriakose

Docker Neo4j by Jun Matsushita

Introducing GraphAware Neo4j Framework by Michal Bachman

Network management and impact analysis with Neo4j

Cool Data Viz: Tom Sawyer Software

Neo4j 2.0 and Keylines: Making the most of labels

How facebooks gatekeeper works. Maybe… by Jay Conway

Pathfinding Demystified (Part 1): Introduction by Gabriel Gambetta

Going places faster with a graph database by Rik Van Bruggen on bdaily.co.uk

Data Modeling in Graph Databases: Interview with Jim Webber and Ian Robinson on InfoQ

A CRM with Neo4j and REST by Dan Schaefer

About the Robustness of Neo4j by Axel Morgner

Time-Based Versioned Graphs by Ian Robinson

Fraud: spot the pattern by Philip Rathle and Gorka Sadowski

Neo4j, RDF and Kevin Bacon by Tom Morris

PrimeFaces + Spring Data + Neo4j Integration by Amr Mohammed

Visualizing an xml as a graph – Neo4j 101 by Nikhil Kuriakose

A week of IT and graph of the week by Mike Holdsworth

Can graphs help fight gangs? and Analysing the Offshore Leaks with graphs by Jean Villedieu

GRAPHGISTS:

Network versioning using relationnodes by Tom Zeppenfeldt

SLIDES:

Spreadsheets are graphs too: Using Neo4J as backend to store spreadsheet information by Felienne Hermans

Exploring Election Results with Neo4j by David Simons

Domain vs Data Centric Graphs by Tareq Abedrabbo

TRAININGS:

Up and Running with Neo4j by Duane Nickull

VIDEOS:

Data-Driven Applications with Spring and Neo4j with Michael Hunger and Josh Long

Dem-O Bones by Rik Van Bruggen

Running Neo4j in Production: Tips, Tricks and Optimizations with David Fox from Snap Interactive at NYC Neo4j Meetup

The post From the Neo4j Community: Best of May 2014 appeared first on Neo4j Graph Database.

Celebrate American independence and freedom from table structures with these four blog posts.

Happy Fourth of July and happy graphDB reading from the Neo4j team!

Blog: Hierarchical Pattern Recognition by Kenny Bastani

Blog: Neo4j: Set Based Operations with the experimental Cypher optimiser by Mark Needham

Blog: Scaling Concurrent Writes in Neo4j by Max De Marzi

Blog: Using LoadCSV to Import Data from Google Spreadsheet by Rik Van Bruggen

[BONUS] GraphGist: Recruitment Graph Model by GraphAware

[BONUS] Video: Visualization of a Deep Learning Algorithm for Mining Patterns in Data by Kenny Bastani

The post Let Graph-dom Ring! Four GraphDB Reads for the Fourth of July appeared first on Neo4j Graph Database.

How Businesses Can Adopt a Google-style Approach to Understand Big Data by Emil Eifrem

How the Graph is Driving Tech City Start-ups by Jim Webber

Aggregate by different functions and join results into one data frame by Mark Needham

Creating a Graph with Cypher by mteasdal

Experimenting with Explaining Neo4j on a Whiteboard by Rik Van Bruggen

Experiments with NEO4J: Using a graph database as a SQL Server metadata hub by David Poole

Extracting Your LinkedIn Connections Into Neo4j Graph Database by Greg Dziemidowicz

Find JPA Entities without Field Access by Aparna Chaudhary

Graph Databases Find Answers for the Sick and their Healers by Joab Jackson

A Graph Database Should Be On Your Technology Radar for the Next Application You Build by Amir Khawaja

Hierarchical Pattern Recognition by Kenny Bastani

Importing CSV Data into Neo4j to Make a Graph by Samantha Zeitlin

Modelling the TOUR DE FRANCE 2014 in a Neo4j Graph Database by Lorenzo Speranzoni

Neo4j Unit Testing with Graph Unit by Aldrin Misquitta and Luanne Misquitta

Neo4j’s Cypher Vs. Clojure — Group By and Sorting by Mark Needham

Rendering a Neo4j Database in UbiGraph by DZone

Scaling Concurrent Writes in Neo4j by Max De Marzi

Set Based Operations with the experimental Cypher optimiser by Mark Needham

Smooth Cypher with eXtended Objects: Neo4j and Cypher-DSL by Lars Martin

Using AsciiArt to Analyse your SourceCode with Neo4j by Michael Hunger

Device Troubleshooting using a Graph Database by Ravi Pappu

Elite: Dangerous Trading by Rickard Oberg

A GraphGist of GraphGists by May Lim

The Recruitment Graph Model by GraphAware

The Feed is King (or Queen) by Aran Mulholland

Getting Started with Neo4j, Ruby 2.1.2, and Rails 4.1.1 by Ben Morgan

Visualization of a Deep Learning Algorithm for Mining Patterns in Data by Kenny Bastani

Building Neo4j Backed Web Applications by Axel Morgner

The post From the Neo4j Community: Best of June 2014 appeared first on Neo4j Graph Database.

OSCON Twitter Graph

UNWIND {tweets} AS t
MERGE (tweet:Tweet {id:t.id})
SET tweet.text = t.text,
tweet.created_at = t.created_at,
tweet.favorites = t.favorite_count
MERGE (user:User {screen_name:t.user.screen_name})
SET user.profile_image_url = t.user.profile_image_url
MERGE (user)-[:POSTS]->(tweet)
FOREACH (h IN t.entities.hashtags |
    MERGE (tag:Hashtag {name:LOWER(h.text)})
    MERGE (tag)-[:TAGS]->(tweet)
)
… source, mentions, links, retweets, ...

MATCH (t:Tweet)-[:USING]->(s:Source)
RETURN s.name as Source, count(t) as Count
ORDER BY Count DESC
LIMIT 5

MATCH (:Hashtag {name:'python'})-[:TAGS]->(:Tweet)<-[:TAGS]-(h:Hashtag)
WHERE h.name <> 'oscon'
RETURN h.name AS Hashtag, COUNT(*) AS Count
ORDER BY Count DESC
LIMIT 5

MATCH (u:User {screen_name:"mojavelinux"})-[:POSTS]->(tweet)
    <-[:TAGS]-(tag1:Hashtag)-[:TAGS]->(tweet2)<-[:TAGS]-(tag2:Hashtag)
WHERE tag1.name <> 'oscon' AND tag2.name <> 'oscon'
AND NOT (u)-[:POSTS]->()<-[:TAGS]-(tag2)
RETURN tag2.name as Topics, count(*) as Count
ORDER BY count(*) DESC LIMIT 5

MATCH (:Tweet)-[:RETWEETS]->(t:Tweet)
WITH t, COUNT(*) AS Retweets
ORDER BY Retweets DESC
LIMIT 1
MATCH (u:User)-[:POSTS]->(t)
RETURN u.screen_name AS User, t.text AS Tweet, Retweets

Wise words #oscon pic.twitter.com/f4Jr9hnMcV — Andy Piper (@andypiper) July 20, 2014

Graph Visualization

MATCH (t:Tweet)
WITH t ORDER BY t.id DESC LIMIT 2000
MATCH (user:User)-[:POSTS]->(t)<-[:TAGS]-(tag:Hashtag)
MATCH (t)-[:MENTIONS]->(user2:User)  
UNWIND [tag,user2] as other WITH distinct user,other
WHERE lower(other.name) <> 'oscon'  
RETURN { from: {id:id(user),label: head(labels(user)), data: user},
    rel: 'CONNECTS',
    to: {id: id(other), label: head(labels(other)), data: other}} as tuple
LIMIT 1000

The post OSCON Twitter Graph appeared first on Neo4j Graph Database.

Neo4j Co-Founder and GraphConnect speaker discusses the role of Graph databases in the future of finance

Applying Dating Insights to the Financial Sector

The ‘Social Network’ Analysis

GraphConnect 2014

The post What Can Banks Learn from Online Dating appeared first on Neo4j Graph Database.

MATCH (me:User)-[:LIKED]->(post:Post)<-[:TAGGED]-(tag:Tag)
WHERE me.username = 'nicole'
RETURN tag.name, COUNT(*) AS count
ORDER BY count DESC

MATCH (me:User)-[:PUBLISHED]->(:Post)<-[:TAGGED]-(tag:Tag), 
(other:User)-[:PUBLISHED]->(:Post)<-[:TAGGED]-(tag)
WHERE me.username = 'nicole' AND me <> other
WITH other,

COLLECT(DISTINCT tag.name) AS tags,

COUNT(DISTINCT tag) AS len

• Tutorial
• GitHub

Watch the Webinar:

The post Building a Python Web Application Using Flask and Neo4j appeared first on Neo4j Graph Database.

March GRAPHness

It’s All Relative

STEP 1: Idea —> Graph Model

STEP 2: Time

STEP 3: my.csv —> graph.db

STEP 4: History, Victory and a Little Math

STEP 5: The Big Payout

The post (March Madness) <-[:MADE_SANE_WITH]- (Neo4j) appeared first on Neo4j Graph Database.

[As community content, this post reflects the views and opinions of the particular author and does not necessarily reflect the official stance of Neo4j.]

Introducing JCypher

Business Domains

Domain Queries

Generic Graph Model

Native Java Domain-Specific Language

The post JCypher: Focus on Your Domain Model, Not How to Map It to the Database [Community Post] appeared first on Neo4j Graph Database.

[This article is excerpted from a white paper by EMA and is used with permission.]

Can you tell me a little bit more about you and your organization?

Can you share more specifically how you view those advantages?

Can you tell me a little more about the requirements of the deployment you did for a large telecommunications provider?

How did you get involved?

How many people were there on the Proof of Concept Team? And how did the deployment evolve?

What were some of the other benefits that the Neo4j deployment achieved there?

The post Interview: Monitor Network Interdependencies with Neo4j appeared first on Neo4j Graph Database.

The Irony of Relational Databases

An example relational database where some queries are inefficient-yet-doable (e.g., “What items did a customer buy?”) and other queries are prohibitively slow (e.g., “Which customers bought this product?”).

Why NoSQL Databases Don’t Fix the Problem Either

Graphs Put Data Relationships at the Center

A performance experiment run between relational databases (RDBMS) and Neo4j shows that graph databases handle data relationships extremely efficiently.

The post Graph Databases for Beginners: Why Data Relationships Matter appeared first on Neo4j Graph Database.

Example Data Model: Fraud Detection in Email Communications

Our first data model attempting to map Bob’s suspicious email activity with Alice as a known alias. However, this data model isn’t robust enough to detect wrongful behavior.

The Fix: A Stronger Fraud Detection Data Model

Our second attempt at a fraud detection data model. This iteration allows us to more easily trace the relationships of who is sending and receiving each email message.

A data model showing many emails over time and their various relationships, including the sender and the direct, CC and BCC receivers.

The Next Step: Tracking Email Replies

Our updated data model with FORWARDED and REPLIED_TO relationships in addition to the original TO relationship.

Homework: Data Modeling for Email Forwards

The post Graph Databases for Beginners: Data Modeling Pitfalls to Avoid appeared first on Neo4j Graph Database.

Even in Neo4j with its high performance graph traversals, there are always queries that could and should be run faster – especially if your data is highly connected and if global pattern matches make even a single query account for many millions or billions of paths.

For this article, we’re using the larger movie dataset, which is also listed on the example datasets page.

The domain model that interests us here, is pretty straightforward:

(:Person {name}) -[:ACTS_IN|:DIRECTED]-> (:Movie {title})
(:Movie {title}) -[:GENRE]-> (:Genre {name})

HARDWARE

I presume you use a sensible machine, with a SSD (or enough IOPS) and decent amount of RAM. For a highly concurrent load, there should be also enough CPU cores to handle it.

Other questions to consider: Did you monitor io-waits, top, for CPU and memory usage? Any bottlenecks that turn up?

If so, you should address those issues first.

On Linux, configure your disk scheduler to noop or deadline and mount the database volume with noatime. See this blog post for more information.

CONFIG

For best results, use the latest stable version of Neo4j (i.e., Neo4j Enterprise 2.2.5). There is always an Enterprise trial version available to give you a high-watermark baseline, so compare it to Neo4j Community on your machine as needed.

Set dbms.pagecache.memory=4G in conf/neo4j.properties or the size of the store-files (nodes, relationships, properties, string-properties) combined.

ls -lt data/graph.db/neostore.*.db
3802094 16 Jul 14:31 data/graph.db/neostore.propertystore.db
 456960 16 Jul 14:31 data/graph.db/neostore.relationshipstore.db
 442260 16 Jul 14:31 data/graph.db/neostore.nodestore.db
   8192 16 Jul 14:31 data/graph.db/neostore.schemastore.db
   8190 16 Jul 14:31 data/graph.db/neostore.labeltokenstore.db
   8190 16 Jul 14:31 data/graph.db/neostore.relationshiptypestore.db
   8175 16 Jul 14:31 data/graph.db/neostore.relationshipgroupstore.db

Set heap from 8 to 16G, depending on the RAM size of the machine. Also configure the young generation in conf/neo4j-wrapper.conf.

wrapper.java.initmemory=8000
wrapper.java.maxmemory=8000
wrapper.java.additional=-Xmn2G

That’s mostly it, config-wise. If you are concurrency heavy, you could also set the webserver threads in conf/neo4j-server.properties.

# cpu * 2
org.neo4j.server.webserver.maxthreads=24

QUERY TUNING

If these previous factors are taken care of, it’s now time to dig into query tuning. A lot of query tuning is simply prefixing your statements with EXPLAIN to see what Cypher would do and using PROFILE to retrieve the real execution data as well:

For example, let’s look at this query, which has the PROFILE prefix:

PROFILE
MATCH(g:Genre {name:"Action"})<-[:GENRE]-(m:Movie)<-[:ACTS_IN]-(a)
WHERE a.name =~ "A.*"
RETURN distinct a.name;

The result of this query is shown below in the visual query plan tool available in the Neo4j browser.

While the visual query plan is nice in the Neo4j browser, the one in Neo4j-shell is easier to compare and it also has more raw numbers.

Query Tuning Tip #1: Use Indexes and Constraints for Nodes You Look Up by Properties

Check – with either schema or :schema – that there is an index in place for non-unique values and a constraint for unique values, and make sure – with EXPLAIN – that the index is used in your query.

CREATE INDEX ON :Movie(title);
CREATE INDEX ON :Person(name);
CREATE CONSTRAINT ON (g:Genre) ASSERT g.name IS UNIQUE;

Even for range queries (pre-Neo4j 2.3), it might be better to turn them into an IN query to leverage an index.

// if :Movie(released) is indexed, this query for the nineties will *not use* an index:
MATCH (m:Movie) WHERE m.released >= 1990 and m.released < 2000
RETURN count(*);

CREATE INDEX ON :Movie(released);

// but this will
MATCH (m:Movie) WHERE m.released IN range(1990,1999)  RETURN count(*);

// same for OR queries
MATCH (m:Movie) WHERE m.released = 1990 OR m.released = 1991 OR ...

Query Tuning Tip #2: Patterns with Bound Nodes are Optimized

If you have a pattern (node)-[:REL]→(node) where both nodes on either side are already bound, Cypher will optimize the match by taking the node-degree (number of relationships) into account when checking for the connection, starting on the smaller side and also caching internally.

So, for example, (actor)-[:ACTS_IN]->(movie) – if both actor and movie are known – turns into that described Expand(Into) operation.

If one side is not known, then it is a normal Expand(All) operation.

Query Tuning Tip #3: Enforce Index Lookups for Both Sides of a Path

Make sure that if nodes on both sides of a longer path can be found in an index, and are only a few hits of a larger total count, to add USING INDEX for both sides. In many cases, that makes a big difference. It doesn't help if the path explodes in the middle and a simple left-to-right traversal with property checks would touch fewer paths.

PROFILE
MATCH (a:Person {name:"Tom Hanks"})-[:ACTS_IN]->()<-[:ACTS_IN]-(b:Person {name:"Meg Ryan"})
RETURN count(*);

If we add the second index-hint, we get 10x fewer database hits.

PROFILE
MATCH (a:Person {name:"Tom Hanks"})-[:ACTS_IN]->()<-[:ACTS_IN]-(b:Person {name:"Meg Ryan"})
USING INDEX a:Person(name) USING INDEX b:Person(name)
RETURN count(*);

Query Tuning Tip #4: Defer Property Access

Make sure to access properties only as the last operation – if possible – and on the smallest set of nodes and relationships. Massive property loading is more expensive than following relationships.

For example, this query:

PROFILE
MATCH (p:Person)-[:ACTS_IN]->(m:Movie)
RETURN p.name, count(*) as c
ORDER BY c DESC limit 10;

This query shown above accesses p.name for all people, totaling 400,000 database hits. Instead, you should aggregate on the node first, then order and paginate, and only in the very end should you access and return the property.

PROFILE
MATCH (p:Person)-[:ACTS_IN]->(m:Movie)
WITH p, count(*) as c
ORDER BY c DESC LIMIT 10
RETURN p.name, c;

This second query above only accesses p.name for the top ten actors, and before that, it groups them directly by the nodes, saving us about 200,000 database hits.

But that query could even be optimized more, with....​

Query Tuning Tip #5: Fast Relationship Counting

There is an optimal implementation for single path-expressions, by directly reading the degree of a node. Personally, I always prefer this method over optional matches, exists or general where conditions: size((s)-[:REL]->()) ← uses get-degree which is a constant time operation (similarly without rel-type or direction).

PROFILE
MATCH (n:Person) WHERE EXISTS((n)-[:DIRECTED]->())
RETURN count(*);

Here the plan doesn’t count the nested db-hits in the expression, which it should. That’s why I included the runtime:

1 row 197 ms

versus

PROFILE
MATCH (n:Person) WHERE size((n)-[:DIRECTED]->()) <> 0
RETURN count(*);

1 row 90 ms

You can also use that technique nicely for overview pages or inline aggregations:

PROFILE
MATCH (m:Movie)
RETURN m.title, size((m)<-[:ACTS_IN]-()) as actors, size((m)<-[:DIRECTED]-()) as directors
LIMIT 10;

+-------------------------------------------------------------+
| m.title                                | actors | directors |
+-------------------------------------------------------------+
| "Indiana Jones and the Temple of Doom" | 13     | 1         |
| "King Kong"                            | 1      | 1         |
| "Stolen Kisses"                        | 21     | 1         |
| "One Flew Over The Cuckoo's Nest"      | 24     | 1         |
| "Ziemia obiecana"                      | 17     | 1         |
| "Scoop"                                | 21     | 1         |
| "Fire"                                 | 0      | 1         |
| "Dial M For Murder"                    | 5      | 1         |
| "Ed Wood"                              | 21     | 1         |
| "Requiem"                              | 11     | 1         |
+-------------------------------------------------------------+
10 rows
13 ms

Our query from the previous section would look like this:

PROFILE
MATCH (p:Person)
WITH p, sum(size((p)-[:ACTS_IN]->())) as c
ORDER BY c DESC LIMIT 10
RETURN p.name, c;

This query shaves off another 50,000 database hits. Not bad.

Note to self: Optimized Cypher looks more like Lisp.

Bonus Query Tuning Tip: Reduce Cardinality of Work in Progress

When following longer paths, you’ll encounter duplicates. If you’re not interested in all the possible paths – but just distinct information from stages of the path – make sure that you eagerly eliminate duplicates, so that later matches don’t have to be executed many multiple times.

This reduction of the cardinality can be done using either WITH DISTINCT or WITH aggregation (which automatically de-duplicates).

So, for instance, for this query of "Movies that Tom Hanks' colleagues acted in":

PROFILE
MATCH (p:Person {name:"Tom Hanks"})-[:ACTS_IN]->(m1)<-[:ACTS_IN]-(coActor)-[:ACTS_IN]->(m2)
RETURN distinct m2.title;

This query has 10,272 db-hits and touches 3,020 total paths.

The first-degree neighborhood is unique, since in this dataset there is only at most one :ACTS_IN relationship between an actor and a movie. So, the first duplicated nodes appear at the second degree, which we can eliminate like this:

PROFILE
MATCH (p:Person {name:"Tom Hanks"})-[:ACTS_IN]->(m1)<-[:ACTS_IN]-(coActor)
WITH distinct coActor
MATCH (coActor)-[:ACTS_IN]->(m2)
RETURN distinct m2.title;

This query tuning technique reduces the number of paths to match for the last step to 2,906. In other use cases with more duplicates, the impact is much bigger.

Of course we would apply our Minimize Property Access tip here too:

PROFILE
MATCH (p:Person {name:"Tom Hanks"})-[:ACTS_IN]->(m1)<-[:ACTS_IN]-(coActor)
WITH distinct coActor
MATCH (coActor)-[:ACTS_IN]->(m2)
WITH distinct m2
RETURN m2.title;

We still need the distinct m2 at the end, as the co-actors can have played in the same movies, and we don’t want duplicate results.

This query has 7,791 db-hits and touches 2,906 paths in total.

If you are also interested in the frequency (e.g., for scoring), you can compute them along with an aggregation instead of distinctly. In the end, You just multiply the path count per co-actor with the number of occurrences per movie.

MATCH (p:Person {name:"Tom Hanks"})-[:ACTS_IN]->(m1)<-[:ACTS_IN]-(coActor)
WITH coActor, count(*) as freq
MATCH (coActor)-[:ACTS_IN]->(m2)
RETURN m2.title, freq * count(*) as occurrence;

Conclusion

The best way to start with query tuning is to take the slowest queries, PROFILE them and optimize them using these tips.

If you need help, you can always reach out to us on Stack Overflow, our Google Group or our public Slack channel.

If you are part of a project that is adopting Neo4j or putting it into production, make sure to get some expert help to ensure you’re successful. Note: If you do ask for help, please provide enough information for others to be able to help you. Explain your graph model, share your queries, their profile output and – best of all – a dataset to run them on.


Need more tips on how to effectively use Neo4j? Register for our online training class, Neo4j in Production, and learn how to master the world’s leading graph database.

The post 5 Secrets to More Effective Neo4j 2.2 Query Tuning appeared first on Neo4j Graph Database.

The Key Challenges in Graph-Based Search:

• The size and connectedness of asset metadata
The usefulness of a digital asset increases with the associated rich metadata describing the asset and its connections. However, adding more metadata increases the complexity of managing and searching for an asset.


• Real-time query performance
The power of a graph-based search application lies in its ability to search and retrieve data in real time. Yet, traversing such complex and highly interconnected data in real time is a significant challenge.


• Growing number of data nodes
With the rapid growth in the size of assets and their associated metadata, your application needs to be able to accommodate both the current and future requirements.

Why Use a Graph Database for Graph-Based Search?

• Enterprises can structure their data exactly as it occurs and carry out searches based on their own inherent structure. Graph databases provide the model and query language to support the natural structure of data.
• Users receive fast, accurate search results in real time. With a graph database, a variety of rich metadata is assigned to all content for rapid search and discovery.
• Data architects and developers can easily change their data and its structure as well as add a wide variety of new data. The built-in flexibility of a graph database model allows for agile changes to search capabilities.

Example: Google and Facebook

Conclusion

The post Graph Databases in the Enterprise: Graph-Based Search appeared first on Neo4j Graph Database.

[As community content, this post reflects the views and opinions of the particular author and does not necessarily reflect the official stance of Neo4j.]

The News Graph

MATCH (:ACTOR {name: "John Kerry"})-[:IN_EVENT]-(e:EVENT) RETURN e ORDER BY e.date DESC LIMIT 10

MATCH (:ACTOR {name: "Islamism"})-[w:WITH]-(:ACTOR {name: "Paris"}) RETURN w.date ORDER BY w.date DESC LIMIT 1

MATCH (:ACTOR {name: "France"})-[:IN_EVENT]-(e:EVENT) WHERE e.date > 1447215879786 RETURN count(e) AS event_count

Neo4j For The Win

There Are Ample Neo4j Clients across Languages

The Neo4j Browser Is a Crucial Experimentation Tool

Graph Flexibility Is Underrated

1. Ability to latently add indexes
The Backstory model has evolved substantially over time. New node and relationship types come and go, and properties are added that need to be queried. Neo4j’s support for adding indexes to an existing graph have allowed us to keep queries performant as things change.

2. Using Neo4j as an article queue
When Backstory collects news articles from the Internet, it has to queue them for textual analysis and event clustering. Instead of using a traditional persistent queue, we realized that Neo4j would support this requirement with minimal additional effort on our part. We already had Article nodes; so it was a matter of adding an “Unprocessed” label to new ones, and processing them in insertion order.

3. Using the graph to cluster articles
Our solution for grouping similar articles together into news events is based in part on the similarity of Article/Actor subgraphs. There is a strong signal in the fact that two articles within a small time span refer to the same actors. Some state-of-the-art clustering algorithms are graph-based, and Neo4j allowed us to quickly approach an excellent clustering solution.

4. Using Neo4j for Named Entity recognition
A central challenge for Backstory is recognizing actors in news article text. Until now, we have used a blend of open-source natural language processing tools and human intervention. But we’ve begun to experiment with using graphs to identify actors, and the results are a marked improvement and extremely promising.

Conclusion

The post How Backstory.io Uses Neo4j to Graph the News [Community Post] appeared first on Neo4j Graph Database.

[As community content, this post reflects the views and opinions of the particular author and does not necessarily reflect the official stance of Neo4j.]

The Problem of Discovery

lim heng swee, ilovedoodle, cats, lol, funny, humor, food, foodies, food with faces, pets, meow, ice cream, desserts,awww, puns, punny, wordplay, v-necks, vnecks, tanks, tank tops, crew sweatshirts, Cute

jimena salas, jimenasalas, funded, birds, animals, geometric shapes, abstract, Patterns

ConceptNet5

{
     edges: 
     [
          {
               context: "/ctx/all",
               dataset: "/d/globalmind",
               end: "/c/en/bread",
               features: 
               [
                    "/c/en/toast /r/IsA -",
                    "/c/en/toast - /c/en/bread",
                    "- /r/IsA /c/en/bread"
               ],
               id: "/e/ff9b268e050d62255f236f35ba104300551b8a3b",
               license: "/l/CC/By-SA",
               rel: "/r/IsA",
               source_uri:                                              
               "/or/[/and/[/s/activity/globalmind/assert/,/s/
               contributor/omcs/bugmenot/]/,/s/umbel/2013/]",
               sources: 
               [
                    "/s/activity/globalmind/assert",
                    "/s/contributor/omcs/bugmenot",
                    "/s/umbel/2013"
               ],
               start: "/c/en/toast",
               surfaceText: "Kinds of [[bread]] : [[toast]]",
               uri: "/a/[/r/IsA/,/c/en/toast/,/c/en/bread/]",
               weight: 3
          },
}

Modeling the Database

• concept
• language
• partOfSpeech
• sense

• type
• weight
• surfaceText

Loading the Data into the Database

import requests
import json
from py2neo import authenticate, Graph
 
USERNAME = "neo4j" #use your actual username
PASSWORD = "12345678" #use your actual password
authenticate("localhost:7474", USERNAME, PASSWORD)  
graph = Graph()

#sample_tags = ['fruit','orange','bikes','cream','nature', 'toast','electronic', 'techno', 'house', 'dubstep', 'drum_and_bass', 'space_rock', 'psychedelic_rock', 'psytrance', 'garage', 'progressive','Cologne', 'North_Rhine-Westphalia', 'gothic_rock', 'darkwave' 'goth', 'geometric', 'nature', 'skylines', 'landscapes', 'mountains', 'trees', 'silhouettes', 'back_in_stock', 'Patterns', 'raglans','giraffes', 'animals', 'nature', 'tangled', 'funny', 'cute', krautrock]

# Build query.
query = """
WITH {json} AS document
UNWIND document.edges AS edges
WITH 
SPLIT(edges.start,"/")[3] AS startConcept,
SPLIT(edges.start,"/")[2] AS startLanguage,
CASE WHEN SPLIT(edges.start,"/")[4] <> "" THEN SPLIT(edges.start,"/")[4] ELSE "" END AS startPartOfSpeech,
CASE WHEN SPLIT(edges.start,"/")[5] <> "" THEN SPLIT(edges.start,"/")[5] ELSE "" END AS startSense,
SPLIT(edges.rel,"/")[2] AS relType,
CASE WHEN edges.surfaceText <> "" THEN edges.surfaceText ELSE "" END AS surfaceText,
edges.weight AS weight,
SPLIT(edges.end,"/")[3] AS endConcept,
SPLIT(edges.end,"/")[2] AS endLanguage,
CASE WHEN SPLIT(edges.end,"/")[4] <> "" THEN SPLIT(edges.end,"/")[4] ELSE "" END AS endPartOfSpeech,
CASE WHEN SPLIT(edges.end,"/")[5] <> "" THEN SPLIT(edges.end,"/")[5] ELSE "" END AS endSense
MERGE (start:Term {concept:startConcept, language:startLanguage, partOfSpeech:startPartOfSpeech, sense:startSense})
MERGE (end:Term  {concept:endConcept, language:endLanguage, partOfSpeech:endPartOfSpeech, sense:endSense})
MERGE (start)-[r:ASSERTION {type:relType, weight:weight, surfaceText:surfaceText}]-(end)
"""

# Using the Search endpoint to load data into the graph
for tag in sample_tags:
	searchURL = "http://conceptnet5.media.mit.edu/data/5.4/c/en/" + tag + "?limit=500"
	searchJSON = requests.get(searchURL, headers = 
	{"accept":"application/json"}).json()
	graph.cypher.execute(query, json=searchJSON)

Exploring the Data

MATCH (n:Term {language:'en'})-[r:ASSERTION]->(m:Term {language:'en'})
WHERE 
NOT r.type = 'dbpedia' AND
NOT r.surfaceText = '' AND
NOT n.partOfSpeech = '' AND
NOT n.sense = ''
RETURN n.concept AS `Start Concept`, n.sense AS `in the sense of`, r.type, m.concept AS `End Concept`, m.sense AS `End Sense`
ORDER BY r.weight DESC, n.sense ASC
LIMIT 10

    | Start Concept | in the sense of                                         | r.type     | End Concept     | End Sense
----+---------------+---------------------------------------------------------+------------+-----------------+-----------
  1 | orange        | colour                                                  | IsA        | color           |
  2 | orange        | film                                                    | InstanceOf | film            |
  3 | dynamic       | a_characteristic_or_manner_of_an_interaction_a_behavior | Synonym    | nature          |
  4 | garage        | a_petrol_filling_station                                | Synonym    | petrol_station  |
  5 | garage        | a_petrol_filling_station                                | Synonym    | fill_station    |
  6 | garage        | a_petrol_filling_station                                | Synonym    | gas_station     |
  7 | progressive   | advancing_in_severity                                   | Antonym    | non_progressive |
  8 | shop          | automobile_mechanic's_workplace                         | Synonym    | garage          |
  9 | electronic    | band                                                    | IsA        | band            |
 10 | cream         | band                                                    | IsA        | band            |

Use Cases and Future Directions

References

Loading JSON into a Neo4j Database

• Cypher: LOAD JSON from URL AS Data
• Neo4j: Loading JSON documents with Cypher
• http://py2neo.org/2.0/

Dealing with Empty Columns

• Importing CSV Data into Neo4j (see Tips section)
• Neo4j: LOAD CSV – Handling Empty Columns

Data

• ConceptNet5 (thanks to Marvin Minsky, Luminoso, Push Singh and the MIT Media Lab)
• WordNet

The post Non-Text Discovery with ConceptNet as a Neo4j Database [Community Post] appeared first on Neo4j Graph Database.

Three Database Deployment Strategies for Graphs and RDBMS

The three most common database deployment strategies for relational and graph databases.

Extracting Your Data from an RDBMS

Importing Data via LOAD CSV

• Ingest data, accessing columns by header name or offset
• Convert values from strings to different formats and structures (toFloat, split, …​)
• Skip rows to be ignored
• MATCH existing nodes based on attribute lookups
• CREATE or MERGE nodes and relationships with labels and attributes from the row data
• SET new labels and properties or REMOVE outdated ones

A LOAD CSV Example

Example file: persons.csv

name;email;dept

"Lars Higgs";"lars@higgs.com";"IT-Department"

"Maura Wilson";"maura@wilson.com";"Procurement"

Cypher statement:

LOAD CSV FROM 'file:///data/persons.csv' WITH HEADERS AS line

FIELDTERMINATOR ";"

MERGE (person:Person {email: line.email}) ON CREATE SET p.name = line.name

MATCH (dep:Department {name:line.dept})

CREATE (person)-[:EMPLOYEE]->(dept)

The Command-Line Bulk Loader

Loading Data Using Cypher

Other RDBMS-to-Graph Import Resources:

• Guide: Data Import
• Manual: LOAD CSV
• Webinar: Data Import
• Guide: CSV Import
• Tool: Direct RDBMS Import
• Tool: SQL to Neo4j Import
• Blog: Importing AdventureWorks Data into Neo4j
• Web-based CSV import app
• Neo4j for Relational MetaData (SQLServer)

The post 3 RDBMS & Graph Database Deployment Strategies (Polyglot & More) appeared first on Neo4j Graph Database.

The Steps Involved in the Document Analysis

1. Acquire documents
2. Classify documents
1. Scan / OCR
2. Extract document metadata
3. Whiteboard domain
1. Determine entities and their relationships
2. Determine potential entity and relationship properties
3. Determine sources for those entities and their properties
4. Work out analyzers, rules, parsers and named entity recognition for documents
5. Parse and store document metadata and document and entity relationships
1. Parse by author, named entities, dates, sources and classification
6. Infer entity relationships
7. Compute similarities, transitive cover and triangles
8. Analyze data using graph queries and visualizations

From Documents to Graph

• Clients
• Companies
• Addresses
• Officers (both natural people and companies)

• (:Officer)-[:is officer of]->(:Company)
• With these classifications:
• protector
• beneficiary, shareholder, director
• beneficiary
• shareholder
• (:Officier)-[:registered address]->(:Address)
• (:Client)-[:registered]->(:Company)
• (:Officer)-[:has similar name and address]->(:Address)

(:Officer)-[:IS_OFFICER_OF]->(:Company)

(:Client)-[:IS_CLIENT_OF]->(:Company)

• Direct metadata -> entities -> relationships to documents
• author, receivers, account-holder, attached to, mentioned, co-located
• Turn plain entities / names into full records using registries and profile documents
• Inferred metadata and information from other sources -> Relationships between entities
• Related to people or organizations from the direct metadata
• Same addresses / organizations
• Find peer groups / rings within fraudulent activities
• Family ties, business relationships
• Part of the communication chain

The graph data model used by the ICIJ

Issues with the ICIJ Data Model

How Could You Extend the Basic Graph Model Used by the ICIJ?

• New Entities:
• Documents: E-Mail, PDF, Contract, DB-Record, …
• Money Flow: Accounts / Banks / Intermediaries
• New Relationships
• Family / business ties
• Conversations
• Peer Groups / Rings
• Similar Roles
• Mentions / Topic-Of
• Money Flow

Let’s Look at a Concrete Example

The family of Azerbaijan President Ilham Aliyev leads a charmed, glamorous life, thanks in part to financial interests in almost every sector of the economy. His wife, Mehriban, comes from the privileged and powerful Pashayev family that owns banks, insurance and construction companies, a television station and a line of cosmetics. She has led the Heydar Aliyev Foundation, Azerbaijan’s pre-eminent charity behind the construction of schools, hospitals and the country’s major sports complex. Their eldest daughter, Leyla, editor of Baku magazine, and her sister, Arzu, have financial stakes in a firm that won rights to mine for gold in the western village of Chovdar and Azerfon, the country’s largest mobile phone business. Arzu is also a significant shareholder in SW Holding, which controls nearly every operation related to Azerbaijan Airlines (“Azal”), from meals to airport taxis. Both sisters and brother Heydar own property in Dubai valued at roughly $75 million in 2010; Heydar is the legal owner of nine luxury mansions in Dubai purchased for some $44 million.

Cypher Statement to Set Up the Visualized Entities and Relationships

CREATE
(leyla: Officer {name:"Leyla Aliyeva"})-[:IOO_BSD]->(ufu:Company {name:"UF Universe Foundation"}),
(mehriban: Officer {name:"Mehriban Aliyeva"})-[:IOO_PROTECTOR]->(ufu),
(arzu: Officer {name:"Arzu Aliyeva"})-[:IOO_BSD]->(ufu),
(mossack_uk: Client {name:"Mossack Fonseca & Co (UK)"})-[:REGISTERED]->(ufu),
(mossack_uk)-[:REGISTERED]->(fm_mgmt: Company {name:"FM Management Holding Group S.A."}),

(leyla)-[:IOO_BSD]->(kingsview:Company {name:"Kingsview Developents Limited"}),
(leyla2: Officer {name:"Leyla Ilham Qizi Aliyeva"}),
(leyla3: Officer {name:"LEYLA ILHAM QIZI ALIYEVA"})-[:HAS_SIMILIAR_NAME]->(leyla),
(leyla2)-[:HAS_SIMILIAR_NAME]->(leyla3),
(leyla2)-[:IOO_BENEFICIARY]->(exaltation:Company {name:"Exaltation Limited"}),
(leyla3)-[:IOO_SHAREHOLDER]->(exaltation),
(arzu2:Officer {name:"Arzu Ilham Qizi Aliyeva"})-[:IOO_BENEFICIARY]->(exaltation),
(arzu2)-[:HAS_SIMILIAR_NAME]->(arzu),
(arzu2)-[:HAS_SIMILIAR_NAME]->(arzu3:Officer {name:"ARZU ILHAM QIZI ALIYEVA"}),
(arzu3)-[:IOO_SHAREHOLDER]->(exaltation),
(arzu)-[:IOO_BSD]->(exaltation),
(leyla)-[:IOO_BSD]->(exaltation),
(arzu)-[:IOO_BSD]->(kingsview),

(redgold:Company {name:"Redgold Estates Ltd"}),
(:Officer {name:"WILLY & MEYRS S.A."})-[:IOO_SHAREHOLDER]->(redgold),
(:Officer {name:"LONDEX RESOURCES S.A."})-[:IOO_SHAREHOLDER]->(redgold),
(:Officer {name:"FAGATE MINING CORPORATION"})-[:IOO_SHAREHOLDER]->(redgold),
(:Officer {name:"GLOBEX INTERNATIONAL LLP"})-[:IOO_SHAREHOLDER]->(redgold),
(:Client {name:"Associated Trustees"})-[:REGISTERED]->(redgold)

Interesting Queries

MATCH (o:Officer) 
WHERE toLower(o.name) CONTAINS "aliyev"
RETURN o

MATCH (o:Officer) WHERE toLower(o.name) CONTAINS "aliyev"
MATCH (o)-[r]-(c:Company)
RETURN o,r,c

	MATCH (c:Company)-[r]-(o:Officer) WHERE c.name = "Exaltation Limited"
RETURN *

MATCH (o1:Officer)-[r1]->(c:Company)<-[r2]-(o2:Officer)
WITH o1.name AS first, o2.name AS second, count(*) AS c, 
     collect({ name: c.name, kind1: type(r1), kind2:type(r2)}) AS involvements
WHERE c > 1 AND first < second
RETURN first, second, involvements, c

MATCH (o:Officer) 
RETURN toLower(split(o.name," ")[0]), collect(o.name) as names, count(*) as count

MATCH (o:Officer)
WITH split(toLower(o.name), " ") AS name_parts, o
WITH name_parts[0] + " " + name_parts[-1] as name,  collect(o.name) AS names, count(*) AS count
WHERE count > 1
RETURN name, names, count
ORDER BY count DESC

MATCH path=(:Client {name: "Mossack Fonseca & Co (UK)"})-[*]-(o:Officer)
WHERE none(r in rels WHERE type(r) = "HAS_SIMILIAR_NAME")
RETURN [n in nodes(path) | n.name] as hops, length(path)

MATCH (a:Officer {name: "Mehriban Aliyeva"})
MATCH (b:Officer {name: "Arzu Aliyeva"}) 
MATCH p=shortestPath((a)-[*]-(b))
RETURN p

Further Work – Extension of the Model

MATCH (o:Officer)
WITH split(toLower(o.name), " ") AS name_parts, o
WITH name_parts[0]+ " " + name_parts[-1] AS name, collect(o) AS officers


// originally natural people have a “citizenship” property
WHERE name CONTAINS "aliyev"

CREATE (p:Person { name:name })
FOREACH (o IN officers | CREATE (o)-[:IDENTITY]->(p))

CREATE (ilham:Person {name:"ilham aliyev"})
CREATE (heydar:Person {name:"heydar aliyev"})
WITH ilham, heydar
MATCH (mehriban:Person {name:"mehriban aliyeva"})

MATCH (leyla:Person {name:"leyla aliyeva"})
MATCH (arzu:Person {name:"arzu aliyeva"})

FOREACH (child in [leyla,arzu,heydar] | CREATE (ilham)-[:CHILD_OF]->(child) CREATE (mehriban)-[:CHILD_OF]->(child))
CREATE (leyla)-[:SIBLING_OF]->(arzu)
CREATE (leyla)-[:SIBLING_OF]->(heydar)
CREATE (arzu)-[:SIBLING_OF]->(heydar)
CREATE (ilham)-[:MARRIED_TO]->(mehriban)

MATCH (p:Person) RETURN p

MATCH (p:Person) WHERE p.name CONTAINS "aliyev"
OPTIONAL MATCH (c:Company)<--(o:Officer)-[:IDENTITY]-(p) 
RETURN c,o,p

GraphGist

Related Information

• http://neo4j.com/news/neo4j-powers-panama-papers-investigation/
• http://panamapapers.icij.org
• https://panamapapers.icij.org/the_power_players/
• Stairway to Tax Haven Game: https://panamapapers.icij.org/stairway_tax_heaven_game/
• https://linkurio.us/panama-papers-how-linkurious-enables-icij-to-investigate-the-massive-mossack-fonseca-leaks/



• E-Mail Analysis
• Gmail E-mail Analysis with Neo4j
• Your Inbox and Graphs
• Investigative Journalism
• https://www.icij.org/offshore/offshore-companies-provide-link-between-corporate-mogul-and-azerbaijans-president
• http://blog.bruggen.com/2015/03/what-do-linkurious-icij-and-swissleaks.html
• Existing GraphGists
• Middle East Connections
• ICIJ Offshore Jurisdictions
• Detailed Analysis of the Azerbaijani President's Involvement

The post Analyzing the Panama Papers with Neo4j: Data Models, Queries & More appeared first on Neo4j Graph Database.

Tell us a bit about yourself and about how you use Neo4j.

Can you share a bit more technical details about how that product works?

What made Neo4j stand out when you were exploring different technology solutions?

What have been some of the most surprising or interesting results you’ve seen using Neo4j?

If you could take everything you know about Neo4j now and go back to the beginning, is there anything you would do differently?

Anything else you’d like to add? Any closing thoughts?

The post The 5-Minute Interview: Tom Zeppenfeldt, Founder of Graphileon appeared first on Neo4j Graph Database.

How Is Fake News a Graph Problem?

Building Our Graph Data Model

• Accounts (or Pages)
Age, history, connections to other accounts, pages and groups
• Posts
Device fingerprint / IP address, timestamp, number of shares, comments, reactions and ‘Reported’ flags
• Articles
Host URL, WHOIS data, title, content and author

Our fake news detection graph model

Detection vs. Investigation

A simplified model showing fake news detection powered by Neo4j and KeyLines

• Automated detection
This uses a Neo4j graph database as the engine for an automated, rule-based detection process. It isolates posts and accounts that match patterns of behavior previously associated with fake news (‘known fraud’).
• Manual investigation
At the same time, a manual investigation process, powered by a KeyLines graph visualization tool, helps uncover new behaviors (‘unknown fraud’).

Detecting Fake News with Neo4j

• Returns all accounts:
• that have fewer than 20 friend connections
• that shared a link to www.example.com
• between 12.07pm – 12.37pm on 13 February 2017

MATCH (account:Account)--(ip:IP)--(post:Post)--(article:Article)
      WHERE account.friends < 20 AND article.url = 'www.example.com'
            AND post.timestamp > 1486987620000
            AND post.timestamp < 1486989420000
RETURN account

Investigating Fake News with KeyLines

Visual investigation tools provide an intuitive way to uncover unusual connections that could indicate fake content

Building a Visual Graph Model

• New accounts
• Posts that have been reported by users
• URLs that have previously been associated with fake content

Loading the Data

Loading the metadata of 100 Facebook posts into KeyLines to identify anomalous patterns

Normal user sharing behavior, visualized as a graph

1. Monitoring New Users

A non-suspicious post being shared by a new user

This structure is much more suspicious, with a new user sharing flagged posts to articles on known fake news domains

2. Identifying Unusual Sharing Behavior

An anomalous structure for investigation

3. Finding New Fake News Domains

Using combos to see patterns in article domains

Try It for Yourself

References

• BS Detector
• BuzzFeed Facebook fact check

The post Detecting Fake News with Neo4j & KeyLines appeared first on Neo4j Graph Database.