[NODES 2020]

Stopping Money Laundering with Graph Analytics

Why is graph technology a perfect match to defeat the criminals responsible for money laundering? In this session, you will discover how Neo4j and Linkurious can help detect complex schemes such as round-trip flows, smurfing or synthetic identities to enhance financial institutions’ compliance.

Bespoke Visualization Tools for Complex Data

In this session, Sebastian shows how the Covidgraph.org project was able to help researchers across the globe to intuitively navigate the contents of a large Neo4j database. Using a custom made visualization app proved to result in a much improved user experienced and helped researchers to quickly gain insights into the data. You will learn about the tools and frameworks being used by the Covidgraph.org project and how you can reuse that knowledge in your own projects.

Building a WebGL Graph Visualization with PIXI.js

Choosing a graph visualization library for a web app is usually thought to be a choice between existing open-source and commercial libraries. There is another option though: Build your own custom graph visualization!

Scrape from Multiple Sources Easily for Better Visualizations

Data that requires you to scrape from multiple URLs requires more attention in terms of validation. We will show a process to scrape from multiple URLs and to create cypher queries directly using Beautiful Soup, resulting in better visualization without any performance issues. We will demo the visualization below. https://community.neo4j.com/t/visualizing-covid19-spread-index-cases-across-continents-with-neo4j/18039

Automating the Neo4j Pipeline for Data Shaping and Visualization with Power BI

According to the AI firm Appen, data scientists spend 80% of their time shaping data; yet data shaping is one of the least impactful aspects of the data-to-decision process. Conversely, both data visualization, which enables decision makers to aggregate and categorize complex information, and analytics, which provides a contextual framework for decision-making, only receive about 20% of the analysis effort. This mismatch in effort is not only unfortunate, it shortchanges the most crucial aspects of the data story-telling intent by limiting the time analysts and decision makers require to identify relevant insights, to establish the evidence necessary to support important enterprise objectives, and to hone the underlying narrative of the data to enable better decision-making.

10+ Entity States in Graph Visualisation And How To Make The Best Of Them

Entities in graph visualisations change appearance based on data and user interaction. We will explore 10 of the most useful entity states, including selected, highlighted, located, hidden, and grouped. We will use Cypher to enrich entities with contextual information enabling powerful interactions.

Visualising All Drupal.org Data in Neo4j

Drupal.org, the main platform for the Drupal Community, stores large amount of data related to users, companies, modules and themes, apart of forums, issues and other information related to projects. Recently we consumed all this data using their public API (https://www.drupal.org/drupalorg/docs/apis/rest-and-other-apis) and represented it in Neo4j for a proper analysis and visualisation. In this session we will explain how we did it and what results we obtained from the experiment. Expect some cool code snippets and API integration best practices, apart of sharing our experience during the data analysis and visual representation challenges we faced.

Getting Graph Questions Answered through Neo4j Bloom

When working with graphs, many graph questions require visual and interactive methods to explore connections in order to discover answers in the graph. Neo4j Bloom helps developers, data scientists and analysts search their graph and explore results visually without having to write Cypher queries.

This session will introduce the latest improvements in Bloom while also covering frequent how-tos and subtle tips/tricks for getting the most out of the Bloom experience.

Anomalies, Inconsistencies and Fraudulent Behaviour – Data Mining with Neo4j and GRANDstack

Join Christian’s deep dive into building a graph visualization application with GRANDstack. With interactive examples, he’ll detect and visualize Wikipedia article fraud, using Neo4j to model real-world examples. He’ll also demonstrate techniques for uncovering hidden insight that you can apply to many other use cases.

The Neo4j ecosystem made graph data mainstream. Developers and business users alike can now easily structure their data in a way that matches the real-world.

This real-world view is especially useful for detecting fraud: who is involved, where and when does it take place, what assets do they hold, and - most importantly - how are each of these details connected.

Wikipedia’s community-based approach to editing makes it prone to many types of fraud, including artificial bot activities, brigading, digital vandalism and collusive behaviors. By examining controversial and topical Wikipedia articles together with their rich edit history, Christian demonstrates how using GRANDstack tooling the smart way helps spot suspect patterns of behavior.

GRANDstack gives developers the premium tools they need to build consistent, extensible applications for trend and pattern analysis. Christian guides you through the steps needed to implement an end-to-end anomaly detection platform, explaining why each technology in the modern GRANDstack approach is the right choice. He’ll include:

• streaming techniques for ingesting large volume data
• core graph modeling in Neo4j
• GraphQL querying to reveal complex interaction behaviors
• visualizing suspicious networks in a React front-end

Christian has extensive Neo4j Graph platform experience. He’s worked at Fortune 500 companies building graph analytics applications and bringing them to production successfully.

Network Like an Egghead: Analytics and Visualization on LinkedIn

LinkedIn offers a great tool to grow and study your professional network. It even offers ways to directly download your data. This talk demonstrates advanced ways to visualize and analyze your network, given your own network data. This session will cover:

• How to collect the needed data in safe ways
• Data pipelines
• Visualization tools and configurations
• Analytical methods which deliver actionable insights

Not All Visualizations are Created Equal

Studies at MIT show that the human brain can process images that the eye sees for as little as 13 milliseconds. Not only does the brain need a very short time to take in an image, but half of the human brain is devoted directly or indirectly to vision. This means that visual representation of data can be a very powerful tool. However, this can only be realized if users can make sense of the visualization. This talk covers how to tailor the visualization to the use case, how to make wise data choices, how to incorporate an iterative process that integrates user feedback, and what kind of in-tool functionality to focus on.

Graph Provisioning and Data Enrichment on Election 2020 Twitter Data

Follow along as Alex walks through an end-to-end workflow to gather, enrich, and analyze tweets on the upcoming 2020 election. In a comprehensive demo, she will illustrate how data collection can be automated leveraging serverless cloud services for automated ETL, and using Graph/Neo4j for gluing different data sources. Enabled by GraphXR's visualization platform, she will guide step-by-step the process of enriching data with named entity extraction and intent classification for complex visual analysis and reporting.

Knowledge Graphs Powered by NLP and Network Science

How do you turn textual data (such as Covid-19 medical research) into a structured knowledge graph? This session covers the path from a corpus of research papers through Natural Language Processing, entity (relation) extraction and graph algorithms from Neo4j's Graph Data Science Library to highly informative connected insights organized in a knowledge graph.

Build a Knowledge Graph Using NLP and Ontologies

In this session, Mark and Jesús will show how to build a Knowledge Graph based on public resources, using techniques like:

• Entity extraction from unstructured data (articles) using NLP
• Knowledge representation using Ontologies

Once built, they will show how to run different types of analysis and inferencing on the Knowledge Graph for various uses.

QKnows Knowledge Graph

This session explores Knowledge Graphs at Scale, using the world's patent and journal data, 5 bio nodes, 50 bio relationships and counting, and fast global and local traversals with Java-embedded Neo4j enterprise.

Representing and Managing Consent for Data Sharing with Knowledge Graphs

The expansion of the Internet of Things has allowed connecting everyday devices to a network that could be accessed at any time and has defined data as a new currency. Data sharing has been a research topic for many years but a unified solution that could be used as a standard has not been presented yet. Further, ways to enable data sharing and make the process fully transparent, from receiving consent until it is revoked, to the end user are yet to be discovered.

My research focuses on sensor data and will solve the issue of data sharing between multiple entities based on informed user consent, and will be implemented with knowledge graphs. This study will raise awareness regarding semantics, data sharing, user consent and the implications of its issuing and withdrawal.

A Survey as a Graph

Hundreds of surveys and censuses are conducted worldwide every year on a CAPI (Computer Assisted Personal Interview) platform using tablets for data collection. At the end you have the data in dozens of cryptic files cross-referencing each other. Making sense of these data is anything but trivial.

The population underlying a survey usually consists of a network connecting places, households, people, assets and agricultural areas. I used Neo4j to map census data for a Health and Demographic Surveillance System (HDSS) as a graph. Some special challenges of survey data and their graph solutions are presented.

Carefully mapping the data under program control onto a graph saves countless months of data cleaning and preparation for the researchers analyzing them later. Hundreds of similar surveys could benefit from such an approach.

Extending a Knowledge Graph from Wikidata

Starting from a business oriented knowledge graph, we will see how to build SPARQL queries to query Wikidata and enrich our knowledge. From this enriched graph, we will build Cypher queries to enhance graph-based search.

Using Software Agents for Querying Knowledge Graphs

In this talk, I'll introduce question-answering chatbots over the command line to query. Querying will be rule-based as proof of concept. Neo4j will be used for dealing with knowledge graphs.

Project Domino: Fighting COVID Misinformation at Scale with Citizen Data Science

With most adults getting news from social media or from colleagues who do, misinformation has grown into an infodemic. Project Domino is an open data science effort to tackle COVID public health awareness by detecting social media manipulation and powering data-driven interventions. This talk shares how graph analytics has been core to how we’ve reported on COVID topics from donation scams to mass political manipulation. We focus on three areas: Project Domino, handling large-scale streaming connected social media data, and facilitating open collaboration over best-of-breed graph data tools. A recurring theme will be how we use Neo4j as the common knowledge graph layer for working with technologies like GPU analytics (Graphistry, Nvidia RAPIDS), deep learning (BERT), automation (Prefect), and more.

NLP and Graphs Go Hand in Hand

How can we leverage the power of Knowledge Graphs in NLP? This session shows how to give structure to unstructured data.

Developing a Knowledge Graph of Your Knowledge, Skills, Abilities, Tasks and Training (KSATT)

Understanding occupation elements and employee skillsets is essential to properly align your workforce, identify skill gaps, emerging skills and career/training paths. In this presentation we will develop an occupation knowledge graph from open data, augment with inferred employee attributes and use graph data science procedures to explore the dataset.

Mastering Enterprise Metadata with Neo4j

Modern enterprises not only have a myriad of data sources, from real-time events, transactional, Big Data, and many other systems, but they also boast a rich ecosystem of thousands of APIs & treasure of deep technical metadata. How do you organize and gain insights from all of this? In addition, there is a trove of data coming from other sources such as millions of datasets, SQL queries, slack chats, thousands user hierarchies, orgs & locations, access controls, Wiki pages, JIRA tickets and more. Normally, these sources are all disconnected from each other, and valuable insights are missed.

At PayPal, we are implementing GEM: the Graph of Enterprise Metadata, a system that connects and puts all the critical metadata under one umbrella. GEM is built on top of Neo4j and Apache Spark and sports a range of metadata ingestion components. GEM manages a rich graph of entities and connections, it applies graph algorithms for analysis and recommendations. And in the future - GEM would apply ML model to derive insights. These help answer critical questions around data catalog, security, and governance initiatives for systems supporting financial transactions for our 346 millions of users. In addition, we envision this graph of enterprise metadata to empower PayPal at scale & accelerate the journey of reaching 1 Billion Customers.

Malt Aware: Discovering What to Drink with Neo4j

The ability to build simple but effective recommendations is underrated. This talk focuses on how to produce good starting-point recommendations for whisky using Cypher that are of higher quality than those we see at our favourite online stores.

Low Latency Kafka to Neo4j Data Streaming on Google Cloud

This will demo a project Hop pipeline streaming data from Kafka into Neo4j on Google Cloud DataFlow (using Apache Beam). We'll show the running pipeline and explain what's going on.

Halal Detection Using Graph Algorithms

Halal food is the main concern for a Moslem in daily life. The number of halal-certified products is small. Therefore, We will present how to detect the halal status of a product based on its similarity ingredients. We will exploit the Neo4j similarity algorithms to compare between halal-certified product and halal-uncertified products. The dataset is available at http://halal.addi.is.its.ac.id/.

Artificial Intelligence: To Trust or Not To Trust?

When we use AI to predict the risk of an investment, take lending decisions or provide explanations for high-scoring cases of suspected fraudulent activities, black-boxed AI is not suited: human experts must be able to validate the truth of AI produced results and gain new insights and graph technologies add the required context for this level of explainability.

In this session, Lorenzo and Surya will introduce "Galileo XAI", the brand new LARUS graph-based platform for explainable AI powered by Fujitsu Deep Tensor®.

Molecules are Graphs! Graph Data Science for Drug Discovery

Matthew Sellwood, currently a Product Manager for IQVIA, will share an open source project that makes use of the graph data science library for lead optimisation of molecules in drug discovery. The project makes use of open source databases alongside the graph data science library to find new insights that could help chemists decide what molecule to make next in the process of designing a potential new drug.

Graph Database as Catalyzer from Machine Learning in Pharma

Graph databases are a great catalyzer for development applications and models based on machine learning. This session is about how can we take advantage of graphs and use them for apply in the pharma sector. Today, in light of COVID-19, the capacity on well-modeling data is very important. In this sense, graphs have many capabilities to collect and get data.

Beyond the (Wine) Blend: Using Graph Structures to Fill the Blanks

In this session, Lju will show an approach she used to do just that, based on a wine data set she's been working on from Kaggle. Her approach is based on generating reference data based on existing information, and then using that to cross-reference and infer what the blanks should contain.

Write Your Own Algorithms Using the Pregel API

Ever wanted an algorithm that wasn’t available in the GDS library? Now we make it super easy for you to write your own algorithms to leverage our super efficient analytics infrastructure, without needing to learn our low level, internal APIs. We’ll cover the basics of pregel, a parallel graph processing framework, and demonstrate how you can quickly use our Pregel API to implement an algorithm and expose it via Cypher.

Graph Native Learning: Introducing GraphSAGE and Model Catalogs in Neo4j

We’ll present on how to build an end to end machine learning pipeline using graph embeddings from Neo4j’s graph data science library to build predictive models. We’ll cover everything from loading your data, calculating your embeddings, extracting data into Python and training a classifier model.

Leveraging Dimensionality for Graph-Based Recommendations with Sparse Data

Similarity metrics between products or customers forms the foundation of many recommendation engines, by compressing data onto a low-dimensional space by comparing vector similarity using Cosine or Jaccard distances to find similar products or customers. However, most of our data sets tend to be sparse and high dimensional, where we have limited information about many different aspects of a customer or product, so compressing our data loses valuable information. In this talk we show how data sparseness and high dimensionality can be solved using Cypher built on a property graph model of beer data. This talk will present the entire end-to-end process of generating recommendations, covering: 1) schema design; 2) data ingestion; 3) Cypher development; and 4) finding similarity for recommendations. By leveraging the new Neo4j GDS, getting to cosine distances from user reviews will be covered. A graph-based solution to overcome the cold-start problem for beers without user reviews will also be presented. As an outcome, attendees of this presentation will be able to use Neo4j to generate recommendations using sparse data without the need for feature engineering and large-scale machine learning algorithms.

Doom, Kafka, and Neo4j - Building a (Near) Real-time Telemetry Graph

Video games like Doom, in addition to being nostalgic fun, let us experiment with ways to tackle real world challenges faced by developers trying to harness the power of connected data including common challenges encountered by developers of IoT systems.

Using a Doom fork designed to emit telemetry as the user plays, we'll explore three methods of wrangling telemetry streams into a graph:

• a simple Java Reactor-Netty UDP stream processor,
• a more robust Kafka approach
• and a cloud-native approach in Google Cloud Platform

All code will be provided, so you'll be able to build, run, and experiment with your own graph building while replaying the classic 90's hit PC game.

From Local Strategies to Global Patterns

Interesting global patterns like scale-free networks, small world phenomena, and viral transmission of innovations turn up in graphs all the time. How do they get there? Independent, rational actions of network members at local scale can lead to these global patterns. Game theory and graph theory explain how. Neo4j gives us tools to make the theories understandable and practical.

Project Hades | Event Management to the Masses

Project Hades, built by Developer Student Clubs VIT is a free and open source software aimed at bringing on site event management to the masses. This is about how we used Neo4j and graph technologies to build and scale and application for the smooth operation of our events.

We used Neo4j to power a Women Empowerment Hackathon with over 300 participants on-site as well as multiple events with an aggregated dataset of over 20000+ points.

Transforming a REST Service to a Graph Service

Discover how you can transform a REST API to a graph API with Neo4j and GraphQL.

From (:RDBMS)-[:TO]->(:Neo4j) Tips and Tricks

All journeys start somewhere! When getting acquainted with Neo4j one of the very first tasks is to migrate your existing data from a traditional relational DBs such as Postgres or MySQL to Neo4j. Very few companies start out on Neo4j from day one, and we were no exception! This talk will cover some tips and tricks we learned the hard way as we began our own journey with Neo4j.

Post-Union Processing with Cypher

Continuing the processing of a Cypher query on the results of a UNION was a heavily requested feature. This session shows how it's used.

IOT Data Compression in Neo4j

Imagine you have a week to put together a POC, or perhaps a weekend hack-a-thon. Your project requires that you capture streaming IOT data from multiple devices. The streams must be combined meaningfully real-time before being stored. Of course the event data is arriving out of sync at volumes so high that you should compress the data upon arrival. You don't want a lot of moving parts in your solution: Kafka, Spark, InfluxDB, lots of glue scripts... No, let's keep it simple. Let Neo4j do it all! The bonus, we won't need to do any further ETL work before we analyse the data in Neo4j, it's already there!

This presentation will show how Neo4j can be coerced into being 'reactive' to incoming IOT data stream event patterns, to intelligently coordinate the inflow of data. It's half inspired by a community post by David Allen: https://tinyurl.com/dallen-iot.; The remaining inspiration comes from Apache Flink's powerful 'Stateful Stream Processing' concept. We will combine these ideas and apply a time-series compression algorithm via an APOC stored procedure written entirely in CYPHER.

Which Comes First - The Data Model or the Algorithm?

Cybersecurity may be the ideal domain for graph analysis as the relationships between technical attributes are often more critical than the discrete values. For example, an attribute’s maliciousness often depends on the surrounding context. This can include the presence or absence of other attributes, the behaviors that those attributes exhibited, and the similarity of that behavior with other attack vectors. Graphs and contextual link analysis are very effective mechanisms for identifying potentially malicious activity.

However, before performing any type of analysis, you need to create the data model! While many graph data model examples are reasonably straightforward, the modeling of cybersecurity data can become quite complex. You would ideally model the attributes of any real world artifact (e.g., an email or file), the occasions in which those attributes were seen together, the behavior that those attributes exhibited when they were observed, and the source of your knowledge about those relationships. But how much knowledge do you really need to encode in the graph? When should you rely on path traversals rather than leveraging more advanced graph algorithms? Do you need to create a hyper graph in order to capture the source of relationships? What are the performance implications? How do you expire data from the graph? And finally, how do you make some decisions and actually build something?

Low-Code Development with Graphs - Taking Application Development to a New Level

To define the components of a software application, we use graphs as abstract models for the data scheme, program and process flows, web component trees, HTML and CSS, as well as file system and organization hierarchies. Why not put them into a graph database and create dynamic web applications directly from these definitions?

That's the idea behind Structr, the unique low code platform that uses the capabilities of Neo4j to take application development to a whole new level.

In his presentation, Axel Morgner, co-founder and CEO of Structr, will explain and demonstrate why building software applications is much more efficient by simplifying and accelerating the development and operation on many levels by skillfully taking advantage of the benefits of graph technology.

Quarkus on Neo4J: Real-World Experiences & Live-Coding

If you're in the enterprise Java world, you've probably heard “supersonic subatomic Java” with Quarkus, a new runtime for modern Java applications. With Quarkus, cloud-native Java has arrived in year 2020, with excellent support for containerized environments, and a highly-effective developer experience.

In this session, I'll live code a modern, cloud-native application that is powered by Quarkus and that uses Neo4j at the core of its business domain. We'll see how to map the graph domain model into our Java code, and what to take into account when using Neo4j on enterprise Java. We’ll further see how to run our applications and graph databases in managed Kubernetes environments and what to consider for production workloads. The examples are based on real-world experience of running Quarkus with Neo4j.

Lightning Fast Zero to Production with Spring, Neo4j and jHipster

JHipster is a development platform to generate and deploy Spring Boot applications with different modules and configurations. Neo4j support has been recently added to the JHipster ecosystem and in this talk we'll introduce you to this amazing platform and its tools. We will also do a live coding session to help us understand how fast it is to get production ready code with JHipster and Neo4j.

Developing Applications with Neo4j AuraDB on Google Cloud

Developers and Data Engineers are turning to the power, agility, reliability, and security of Google Cloud to build applications that meet the challenges faced by today’s businesses. In this session, Google Cloud Developer Advocate Robert Kubis, will demonstrate the many ways Google Cloud supports developers and data engineers in building and enriching their applications while keeping productivity, and application + data security at top of mind. David Allen, Technology Partner Architect for Neo4j will then give you a live demo putting these fundamentals into practice, and show how to easily and quickly build and connect compelling Cloud applications with AuraDB, the only fully managed graph database-as-a-service on Google Cloud.

Enterprise 360 - Graphs at the Center of the Data Fabric

Providing multi-dimensional views across the enterprise requires weaving a complex network of connected data and metadata together to deliver context, insight and strategic focus. Industry analysts are increasingly finding that graph databases are a key enabling technology in supporting Data Fabric architectures, where detailed data catalogs and semantic definitions are deployed on top of graph data models to provide true self-service and democratization of data, contextualizing information across domains. Join Precisely as we illustrate how we help our customers use graph to implement Data Fabric patterns in support of their key strategic objectives.

A Humane Presentation about Graph Database Internals

Databases are everywhere, but did you ever wonder what goes on inside the box? In this talk we’ll dive into the internals of Neo4j - a popular graph database - and see how its designers deal with common functional and non-functional requirements. In particular we’ll see how data is stored safely and queried performantly by understanding the way Neo4j makes use of the network and file system. So if you’re a curious person looking for a humane and light-hearted introduction to database internals and distributed systems, this talk is for you!

Site Reliability Engineering at Neo4j AuraDB

The Neo4j-as-a-service offering AuraDB makes it very easy for customers to get access to a production grade Neo4j database without worrying about all the operational bits and pieces.

However, we really care about those things and want to take you on a journey what it means to keep the lights on.

Cypher Deep Dive: From Query String to Result

This session aims to provide a general overview of the internal workings of Neo4j Cypher. We will go into detail about the different processing steps, starting from a string representation of a query and ending up at the iterators, that can be used to fetch the results from.

Tips and Tricks for Running Neo4j Clusters with Large Stores

Operating distributed systems with large amounts of data can often be challenging; especially if you care about performance and stability.

Neo4j Causal Clusters are no exception. Historically, once a user's store gets above a certain size, careful tuning and management are required to maintain a good experience.

Worse, given the many configuration options Neo4j has to offer, and the wide variety of deployment hardware, some solutions you try might not work, or have unintended consequences.

In this session a member of Neo4j's clustering team and another from field engineering would like to set the record straight.

We throw a lot of data at Neo4j, then show which changes to config or environment *work* to preserve performance and stability, along with those which ... don't.

Building Spatial Search Algorithms for Neo4j

Graphs and Geospatial are natural partners. And yet, Neo4j has native support for only the simplest spatial type, the Point. Is this a problem? What if you want to perform more complex spatial searches, spatial modelling or spatial algorithms using complex types like polygons and multi-polygons? At graphconnect 2018 we showed you how to write a web app that demonstrated route finding using A-Star and spatial search using a point-in-polygon algorithm. This talk will take that further, showing you how to write your own spatial algorithms for more complex analyses and how to integrate them into a web-app through user-defined functions accessible with Cypher queries. To demonstrate this we will use a new library we've been working on to prototype complex spatial algorithms within Neo4j.

Low Code GraphQL APIs With Neo4j

Learn how to build efficient GraphQL APIs without writing boilerplate code and duplicating schemas in your API and database.

Create a Graph Data Pipeline with Apache Spark and Neo4j

Regardless of the fact you're a Data Scientist or a Data Engineer, at 99%, you have met in some way with Apache Spark. In this session, we’ll show you the capabilities we’ve been working on discovering how you can combine Spark and Neo4j for reading and ingesting data from/to Neo4j leveraging several Programming Languages (such as Scala and Python) via Notebooks; showing some simple use case that will allow you building a Graph Data Pipeline from scratch.

Relate Framework - How Neo4j Builds Neo4j Developer Tools

Neo4j Desktop is written in TypeScript and built on Nest.js. That's the foundation of our Relate Framework for building a growing collection of Developer Tools. And you can use it, too.

Sharding Graphs with Neo4j

Graphs and sharding, do they really work together? In this talk, we will present the latest additions to Cypher and how we can execute queries spanning in parallel on multiple graphs, in a sharding and federation scenario. We will also look at modelling techniques that we can use to split graphs, improve scalability and speed up queries.

Cypher Workbench: Development Tool Suite for Cypher

The path from inception to deployment of your Neo4j solution involves many steps: documenting key questions, modeling your data, importing data, building queries, and verifying the data works for your needs. Additionally, running systems have a different set of needs: understanding query execution, troubleshooting, and analyzing the health of your database. Cypher Workbench is a collection of visual tools that can assist in the development of new Neo4j solutions as well as help maintain existing deployments. This talk will showcase several tools within Cypher Workbench that may help you with your Neo4j solution.

Parallel Data Import Into a Running Database

Importing relationships into a running graph database using multiple threads running concurrently is a difficult task, as multiple threads cannot write information to the same node at the same time. Here we present an algorithm in which relationships are sorted into bins, then imported such that no two threads ever access the same node concurrently. When this algorithm was implemented as a procedure to run on the Neo4j graph database, it reduced the time to import relationships by up to 69% when 32 threads were used.