In a previous post on law enforcement and data visualization, we saw how successful law enforcement agencies understand the wealth of data they have at their disposal.

Graphs can reveal trends and give insight into relationships between people, times and locations. Graph visualization is a vital tool for exploring and understanding graph data at scale.

This blog post gives another law enforcement graph visualization use case, and one that I recently presented with our partners at Neo4j. Watch the presentation.

Exploring the data.boston.gov crime data set

One of the many sources of data available to the police is their RMS – or Records Management System. It’s often the core repository, containing details crimes, individuals, officers and vehicles, etc.

In recent years, many agencies have made some of their RMS data available to the public – a great resource for anyone interested in law enforcement activity. Obviously, identifying details are stripped out, but there’s still enough data to build a valuable graph visualization.

One example of this is the data.boston.gov initiative, detailing real-life crime incidents in the city of Boston.

Creating the data model and loading into Neo4j

Once I’d loaded this dataset into the Neo4j graph database, I could use Cypher query language to quickly and easily query the data.

I used the Neo4j Awesome Procedures on Cypher (APOC) capability to call the data.boston.gov API, pulling in a JSON object detailing 1000 records. APOC provides a flexible way to ingest data into Neo4j with a few lines of Cypher. I used Incident Number fields as the core nodes with additional attributes, like offense group, district, date, longitude and latitude.

Finally, I added another set of nodes – crime descriptions – plus a link between the two node types. Here’s our data model:

And here’s the original Cypher:

	CALL apoc.load.json(https://data.cityofboston.gov/resource/29yf-ye7n.json?$limit=1000&$offset=0)
	YIELD value AS crime
	MERGE (c:Crime {incidentnum: crime.incident_num})
	ON CREATE SET	c.offense=crime.offense_code_group,
					c.date=crime.occured_on_date, c.district=crime.district,
					c.latitude=crime.lat, c.longitude=crime.long
	MERGE (desc:Description {name: crime.offense_code_group})
	CREATE (c)-[:HAS_DESCRIPTION]->(desc);

Loading the data into KeyLines

Next, I wanted to translate 1000 lines of data into something more compelling – a KeyLines visualization:

These are Crime Categories (the central nodes) connected to actual crimes (the outer nodes). We can spot some basic patterns at a glance. For example, in our dataset there’s only one located missing person:

This doesn’t suggest that the police have problems locating missing persons; it’s probably due to our limited dataset. With full access to the data, we might use a double-click to expand method to see the full picture.

Looking at Crime Category connections

We can also see some categories are more densely interconnected than others. Filtering out ‘leaf nodes’ (nodes with only a single connection) reveals network of inter-related crime categories:

Inspecting crime by district

There was a District property in our original dataset, so we can incorporate that into our visualization.

KeyLines Combos feature makes it easy to combine nodes based on any feature. Let’s combine by district, to see which geographic areas report the most crimes:

We can also use the latitude and longitude information on the nodes to see the crimes in a geospatial view:

I’ve also added donuts to nodes to show the volumes of different reported crimes. I’ve included two crime categories – Larceny in blue, Motor Vehicle Crime in purple – but we can already see some stark differences in our dataset. South Boston (C6) has a much higher proportion of Larceny than East Boston (A7).

Adding people, phones, vehicles and times

We don’t have access to real-world crime data. To give you some idea of what a police officer might see, I used GraphAware’s excellent GraphGen tool to supplement the data with additional (fake) attributes:

The fake data doesn’t reveal much insight, but it demonstrates the potential value of this approach. An officer can visually explore phones, addresses and individuals connected to incidents to see how they relate to previous incidents.

We can enhance this view with the KeyLines Time Bar, which lets us drill down to specific time periods:

Storing data in a Neo4j graph database means we can run complex graph queries that would otherwise be incredibly time-consuming.

“Return all individuals in district D4 who have previously been associated with a vandalism crime in 2017 who drive a red Ford” becomes a fast and simple Cypher query. KeyLines and Neo4j combine to become an effective and efficient tool to help officers make the best use of their data.

Want to try it for yourself?

This post is just an illustration of how graph visualization techniques can help law enforcement to understand the complex connected data. We’d love to see how this approach works using real-world data. If you’d like to try KeyLines for yourself, just start a trial or contact us.

The post Visualizing crime patterns data as a graph appeared first on Cambridge Intelligence.

Managing restricted substances

Have you ever wondered about the parts that make up your car, and what they’re made of? It’s easy to assume that the ‘OEM’ (that’s the company whose badge is on the front of your car) will know, but remember that modern cars have around 30,000 – 40,000 parts, and most of them were built by a complex chain of thousands of part suppliers, not the OEM itself. Each part is made by combining materials together using one or more processes.

The materials in turn might be made up of dozens of chemical substances. For example, plastics and rubbers are made of a complex and often top-secret formulation. Yet more substances are consumed in the processes (think using a degreaser or adhesive in a manufacturing step). If your car had to carry a printed recipe like the chocolate bar you had at lunchtime, it would not make for light reading.

Legislations on hazardous substances are important in this domain. The EU’s REACH directive is a great example. Among other things, REACH creates legal obligations for companies who produce or supply articles containing so-called Substances of Very High Concern (SVHCs). There were 182 of these substances at the last count, and many are used to give everyday materials the properties that we take for granted: corrosion-resistant chrome coatings, or the pigments and plasticizers used to make flexible, colourful plastics.

The challenge REACH gives engineering organizations seems insurmountable: they must understand their exposure to the legislation and then do something proactive about the risks.

Why is this challenge so difficult? Part of the problem is the scattered nature of the data. The relationship between a chemical substance and the regulations which govern it are published by the relevant authorities but change from year to year. Relationships between part and material might be spread across a nebulous world of Bills of Material (BoMs) and Product Lifecycle Management (PLM) systems. The relationships between materials and substances (the ‘recipes’) are the hardest piece of the puzzle. They usually require frequent pleas for information from raw material suppliers who give away few details to protect the IP of their secretive formulations.

But even when manufacturers get all this information into one single, convenient store, would that be enough for them to achieve compliance enlightenment? What piece of actionable intelligence would they look for first, and what would they do with it?

KeyLines customers have taught us something at Cambridge Intelligence: that the best analysts are not necessarily database experts. Human beings don’t always know what they are looking for until they’ve found it.

The power of visualizing connected data

What would be the effect of a particular chemical substance becoming obsolete on an organization whose products are built from a complex recipe of material and process specifications?

We can describe the problem using a graph structure. Let’s start with a simple model where nodes correspond to legislations, substances, materials, processes and components, and links represent the use of something in the supply chain.

Graph data structures like these are great at providing insight. You can quickly see which nodes are the most ‘influential’, or which specifications are on critical paths and are therefore most vulnerable to obsolescence or undocumented reformulation.

It’s hard to ask a typical database these questions, and harder still to ask multiple databases. But get the visualization right, and it becomes as easy as asking: “what does this picture tell you?”

Analysts empowered with a visualization tool have a number of strategies available to them. They might start with the ‘haystack’ and immediately see the complex clusters that stand out. These clusters could represent major obsolescence risk.

Exploring a network

Alternatively, an analyst might start with the ‘needle’: zoom in on a chemical substance of interest, and try and understand how it affects their business.

In the example above, the analyst begins with Cadmium Chloride, an SVHC on the REACH list, and explores outwards. We’ve used a number of KeyLines features to make the user experience better:

• Progressive ‘expand’ behaviour – the user double-clicks on an item of interest, and the web application calls the backend database to get the neighbours of that item. KeyLines merges the new data into the chart with a smooth animation so the user understands what’s happening.
• Foregrounding – brings newly added nodes and the original ‘seed’ node into focus and fades out everything else.
• Font Icons – clearly shows the difference between a chemical substance, a process specification, a material and a legislation.
• Tooltips – lets users hover over a substance of interest and learn more about it, such as its common names, or its typical uses.
• Glyphs – the green tick could show that a material has had a ‘full material disclosure’ from a supplier in the last six months, so the data can be trusted.
• Color – we’ve kept color to a minimum so that it can be used most effectively to highlight what’s important.

Impact analysis

Now back to the question: “what would happen if this chemical became obsolete?”

Removing a substance from the supply chain – perhaps because of legislation – can have a knock-on effect which can bring a manufacturer’s assembly lines to a standstill with costs running easily into the millions.

In the example below, we’ve encoded this question into a simple workflow using some common KeyLines capabilities. When the user asks for an ‘impact analysis’ for a particular chemical (or list of chemicals), we can:

• Use filtering and the analysis capabilities of our graph engine to hide every node that’s not ‘downstream’ of the originally selected chemicals.
• Use the Hierarchy Layout to rearrange what’s left into a logical sequence, so we can understand how that chemical flows down the supply chain.

With a few simple interactions, the analyst has discovered that two material specifications used in the business use cadmium chloride, a REACH Substance of Very High Concern. One of these materials uses the chemical indirectly. It’s used in a process which itself is used in another process, which is used in the manufacture of the material.

The analyst can now tell the business that particular materials are at risk from the REACH legislation. Even better, they can provide actionable advice to target and replace a particular electroplating process.

Want to try it for yourself?

This post is just an illustration of how graph visualization techniques can help manufacturing companies understand the complex connected data associated with restricted substance compliance. We’d love to see how this approach works using real-world data. If you’d like to try KeyLines for yourself, just start a trial or contact us.

The post Restricted substance compliance – a data visualization challenge? appeared first on Cambridge Intelligence.

We’ve written about fraud as a connected data problem before. We’ve shown how the key to fraud insight lies in relationships between people, accounts, transactions and events.

Fraud analysts present these relationships as network visualizations to help them interpret huge volumes of data much faster. In this way, finding fraud becomes a simpler visual task.

In this blog post I’ll discuss how network visualization fits into two core anti-fraud tasks: fraud investigation and fraud detection.

Known v Unknown fraud

In this webinar, I talked about two types of enterprise fraud: known fraud and unknown fraud. Understanding the difference is key to fraud management.

Known fraud is fraudulent activity we have encountered before. We can define the behavior patterns involved, which means we can use rule scoring and pattern matching to find it. Most of the work is automated and only outliers and edge-cases require further effort. When looking for known fraud, network visualization is used as a investigation tool.

Unknown fraud is the opposite. We have not previously encountered the behavior, so our automated processes will not find it. It requires analysts with experience of fraud management who can understand and spot potential fraud MOs and patterns. Network visualization is a detection tool used by analysts to uncover fraud that would otherwise go unnoticed.

As unknown fraud becomes known fraud, new parameters are added to the automated rule-scoring process. This improves fraud detection and helps analysts keep up with fraudsters’ methods.

Investigating known fraud with KeyLines

There are two priorities when you work with known fraud: 1) speed and 2) accuracy.

Analysts looking for known fraud must process their cases quickly. An analyst receives a case and needs to approve or deny it in minutes, or sometimes seconds. Taking fast decisions with confidence is essential. Network visualization is the ideal tool for this kind of a review. At a glance, a fraud analyst sees the information they need to take a decision, with full context.

For example, here’s an insurance claim one of our customers investigated with their KeyLines component (the data is redacted):

Here the customer uses a red glyph for claims that have already been dismissed as fraudulent. People, vehicles and addresses connected to that claim are highlighted with an orange halo.

We can see the Policyholder on the right-hand side shares an email address and residential address with the known fraudster. Their latest claim should be investigated further before payments are approved.

Here’s another example from the same KeyLines deployment. This time, we’re looking at unusual connections between third parties:

There are two third parties, on the left-hand side of the chart, with two Claim Reference Numbers. These may be legitimate claims, but we should analyze them further. KeyLines has useful features to make this analysis easier and more intuitive:

• Layouts – in both examples we’ve used the standard layout, which spreads out nodes and reduces link overlap. The hierarchy layout is also useful in these cases.
• Combos – allows the user to combine nodes, reducing clutter and making multiple connections more explicit.
• Time Bar – can help the analyst understand the evolution of events, or see peaks or troughs in activity.

Detecting unknown fraud with KeyLines

Analysts need a different set of skills to uncover unknown fraud. They must use domain knowledge and experience to think like a fraudster. They need to anticipate new tactics to commit fraud and conceal it from authorities.

Graph visualization can help with this.

Investigation of known fraud takes a case-centric approach – sometimes called the local approach – starting from a small point and working outwards. Detection of unknown fraud takes a global approach – taking an overview of a large amount of data to find anomalies.

This is another example taken from an insurance fraud use case that shows the insurance claims made in a single day. Just displaying this data as a graph reveals patterns:

The majority of our data shows business as usual. A standard claim has a star shape – with a central case with a small number of policies, individuals and other identifiers.

However, we can also see areas (in the top left) that show unusual connectivity. An analyst would explore this in more detail, using investigative techniques to understand the behaviors involved and whether or not it conceals fraud.

Try it for yourself

These two techniques – investigation and detection – are used in all fraud management functions. In combination with powerful graph visualization tools they help build a robust fraud process.

The examples in this blog post have been simplified and anonymized, but you’re welcome to try KeyLines with your own data. Request a trial account or get in touch for more information.

The post Enterprise Fraud Management: Investigation v Detection appeared first on Cambridge Intelligence.

Another year, another office! We’re pleased to announce that we’ve moved to our own offices. Our new building brings us closer to the center of Cambridge, and will give us lots more space to grow.

As of 26 June 2017, our address is:

Cambridge Intelligence
6-8 Hills Road
Cambridge, CB2 1NH
UK

Our telephone number will stay the same: +44 (0)1223 362000.

For now, any post sent to our old address will be re-directed but please make sure you update any records you have. Note that our registered legal address (115c Milton Road) will stay the same.

We’re just 10 minutes’ walk from Cambridge Central train station, so feel free to stop by if you’re in town.

The post We’ve moved office! appeared first on Cambridge Intelligence.

Are you confused by the complexity of data compliance?

In this week’s webinar we’ll see how privacy data software leaders trust-hub use KeyLines to simplify data complexity and make regulatory compliance simpler. We’ll see how they’ve harnessed graph technologies, including KeyLines and Neo4j, to help organizations map, understand and control the flow of personal data.

• Date: Tuesday 04 July 2017
• Time: 16.30 BST / 08.30 PDT / 11.30 EDT / 17.30 CEST
• Duration: 45 mins

Register for the webinar

Organizations that don’t manage their personal data correctly will soon face huge fines under new EU General Data Protection Regulations. Identifying and managing this kind of data is a complex task. It’s often stored in huge volumes across teams, platforms and processes, and many organizations lack the ability to map the data to see how it’s used.

trust-hub’s graph visualization approach to data governance simplifies complex scenarios and reduces non-compliance risk. During this webinar we’ll see how their Business Lens platform harnesses KeyLines to help users establish controlled, consistent and repeatable procedures for tracking and governing personal data flow.

See you there!

The post Using graph technologies for more robust privacy data governance appeared first on Cambridge Intelligence.

We’re proud to welcome ArangoDB, creators of the highly available multi-model NoSQL database, to the Cambridge Intelligence Technology Alliance.

Our recent tutorial shows how to integrate KeyLines and ArangoDB seamlessly to create powerful and scalable data visualization and exploration tools.

We’ll work closely with the ArangoDB team and provide resources so you can get the best out of your KeyLines-ArangoDB project. Both technologies put you – the developer – in the driving seat, and let you build and deploy data analysis and visualization applications quickly and with confidence.

“ArangoDB and KeyLines make a great combination,” said our commercial director, Corey Lanum. “To truly understand and use their data, people need to see it. KeyLines makes it easy and intuitive to visually explore the big data stored in ArangoDB, helping users throughout the enterprise to uncover its hidden insights and make better decisions.”

Interested in learning more? Get in touch.

About ArangoDB

ArangoDB is the leading native multi-model database offering graphs, key/value pairs and documents in one core and with one query language. Native multi-model enables performance on any shape of data at scale. With traversals, shortest path, pattern matching, Pregel and SmartGraphs ArangoDB offers a complete package to answer graph-related questions. For small and massive datasets ArangoDB provides a solid backbone and KeyLines a seamless integration for gaining insights into your graph data.

The Cambridge Intelligence Technology Alliance is formed of industry-leading organizations whose products and services complement our own offering. Existing members include Microsoft Services, Neo Technologies and DataStax. They share our mission to help people understand complex connected data, and offer high quality tools that can be seamlessly integrated with our own.

For more information, contact Andrew Disney.

The post ArangoDB join our Technology Alliance appeared first on Cambridge Intelligence.

KeyLines 3.5 is live! Customers and evaluators can now enjoy the fastest KeyLines yet, with up to 2x faster rendering and improved performance.

Better, faster visualization performance

Last year we introduced WebGL rendering to KeyLines, supercharging the toolkit’s performance for your biggest datasets.

In this release, we’ve reworked KeyLines’ use of WebGL, giving a 2x better frame-rate when animating densely-connected networks of thousands of nodes. We’ve also improved the performance of our HTML5 Canvas rendering, which is around 20% faster and smoother than previous versions.

To make sure everyone benefits from these improvements, KeyLines Pro Edition will now use the WebGL renderer by default, falling back to HTML5 Canvas in non-WebGL compatible browsers.

Improved Combos (Pro Edition only)

As part of our ongoing work to improve KeyLines unique ‘combos’ feature, we’ve re-engineered it under the hood to make it faster. We’ve also included a new demo to show how to use Combos with Maps, removing clutter from charts automatically as the user zooms out.

Clearer, simpler API Reference

We know your success depends on the quality of our support and guidance. One way we’re making this even better is through documentation improvements.

In this release, we’ve re-designed our API Reference to make it clearer and easier to use. You can now:

• Filter by function to find what you’re looking for more quickly
• See chart, map and time bar options in separate sections
• Pick out key information easier with our clearer layout
• Follow links to relevant demos from any function or event

Integrate with ArangoDB

Our new demo shows how to build high-performance visualization applications for the ArangoDB multi-model database. It’s a great option for developers who want to combine the strengths of the graph model with more traditional database formats.

The demo explains how to harness the Foxx framework to create v8 JavaScript micro services that run directly with the database.

Features leave beta

We’re constantly reviewing and improving our functionality. In this release we’re pleased that the following features have been promoted to established parts of the KeyLines toolkit:

• AngularJS 1.x directive
• Graph Engine (Pro only)
• Clusters (Pro only)
• Self links
• Promises

KeyLines 3.5 also includes a number of bug fixes and minor enhancements. Take a look at the release notes for the full details.

As always, we’d love your feedback. Send us a message with your comments and suggestions about this, and future, releases.

The post KeyLines 3.5: The Fastest KeyLines Yet appeared first on Cambridge Intelligence.

We recently hosted our office warming party, celebrating the team’s latest move across town to our very own building in central Cambridge. Friends of the company joined us for food, drinks and tours of our 5000 sq ft new premises on Hills Road.

Food, provided by Aromi, added a Mediterranean flavor to the evening. We also enjoyed branded cupcakes to help soak up our experimental signature cocktail – the Cambridge Blue Monday.

As our celebratory t-shirts show, this is the fifth move in Cambridge Intelligence history, and we’re hoping it’ll be our home for some time.

Our new place, located between the city and central train station, is the perfect base as we continue our scale-up journey. Spread over four floors, it has spacious open-plan working and breakout areas and room for the team to grow.

Thanks again to everyone who came out to celebrate with us!

P.s. If you want to join us, we’re currently recruiting for engineering, commercial and customer success colleagues – you can find more details on our careers page.

The post We’ve Moved (Again) – Let’s Celebrate! appeared first on Cambridge Intelligence.

TypeScript is an increasingly popular way to write modern Javascript applications. We introduced support for TypeScript in KeyLines 3.4, complete with a full set of definition files.

Whether you’re new to TypeScript or a die-hard convert, this blog post will show you how to use TypeScript with KeyLines to improve your development experience.

What is TypeScript?

TypeScript is a scripting language that compiles into regular JavaScript. Think of it as a way to write cleaner, faster, safer JavaScript code.

JavaScript was designed to be a client-side scripting language for web pages. As JavaScript applications got bigger, it became harder to manage code and scale development. To solve this problem, Microsoft created TypeScript: a strongly typed, open source, superset of JavaScript.

TypeScript works with your existing JavaScript code and runs on any browser, host, or operating system. You can use it with any JavaScript library, and it’s recommended by certain framework vendors, including Angular. It integrates with popular build tools, including Webpack, MSBuild and NuGet, and supports the latest versions of JavaScript (ES6 or ES2015) which use promises instead of callbacks.

Not only does TypeScript plug into your existing JavaScript toolchain, it also comes with its own powerful tools, including:

• Integration with your IDE’s intelligent code completion and documentation services, to help you read and write code faster and more accurately
• A compiler that transforms TypeScript into standards-compliant JavaScript, including ES6 and ES2015
• Inline error detection at development time and detailed error messages at compile time to help you write better quality code
• Extra language features not in ES6, including enums and the ability to initialize member variables in a constructor

Because it’s open source, developer communities are creating new TypeScript tools all the time. For the latest updates, see What’s New in TypeScript.

How does TypeScript work?

TypeScript is based on a simple, lightweight type system that works with interfaces, classes, arrays and functions. You can use simple annotations to specify data types for variables, parameters and functions, as well as defining interfaces which describe different types of objects.

You can add these type annotations to TypeScript (.ts) files. For example:

// Define a ‘Person’ interface
interface Person {
  firstName: string,
  lastName: string
}
// Create an instance of a Person
let user : Person = {
  firstName: “Joe”,
  lastName: “Bloggs”
}
// Declare a function which defines a parameter of type Person
function sayHello(user: Person) {
  console.log(“Hello, “ + user.firstName);
}

When you run the TypeScript compiler, the output is a JavaScript file.

Type annotations are optional. You don’t have to add them everywhere, so if you’re migrating to TypeScript, you can do so one file at a time without having to do one massive rewrite. You’ll need to save the original .js file as a .ts file so you can add annotations before compiling.

The KeyLines TypeScript definition file

Many popular libraries and frameworks provide definition files which declare their interfaces in TypeScript. These definition files can be used by IDEs and the TypeScript compiler to validate that the libraries are being used correctly. See definitelytyped.org.

We’ve created one for KeyLines that contains the types you need to include in your TypeScript project. Here’s an extract:

interface ChartOptions {
   /** Controls the appearance of arrows on links. Possible values are 'normal' and 'small'. Default: 'normal'. */
   arrows?: "normal" | "small",
   /** The rgb colour to use for the background of the chart itself. */
   backColour?: string,

Notice that the definition file includes API Reference documentation, so you can get point-of-need help as you’re referencing the KeyLines library.

KeyLines type definitions have signatures for the promises version of the KeyLines API. Calls to the callback version still work, but they’re not defined in the types file.

How to use TypeScript with KeyLines

If you don’t have TypeScript already, install it as a Node.js package. At the command line, run:

npm install -g typescript

Alternatively, install Visual Studio Code – a free code editor built using TypeScript.

If you’re using KeyLines 3.4 or later, you’ve already downloaded the KeyLines definition file /ts/keylines.d.ts. Use your IDE to move the .ts file to the folder where your TypeScript project will live.

Now let’s create you first TypeScript file. Make a copy of a JavaScript file in your KeyLines project, save it with a .ts extension.

Update the .ts file with a reference to the KeyLines definition file:

// <reference path=”./keylines.d.ts” />

Use a KeyLines static type to declare a constant:

declare const KeyLines: KeyLines.KeyLines;

Let’s add some simple type annotations to the JavaScript in our new .ts file. Create a function to set the color of an item once it’s selected:

setSelectionColour(colour) {
   const options = {
     selectionColour: colour
   }
   this.chart.options(options);
 }

We want the SelectionColour function to be called with a single string parameter and to set chart options:

	setSelectionColour(colour: string) {
   const options: KeyLines.ChartOptions = {
     selectionColour: colour,
   };
   this.chart.options(options);
 }

We’ve increased the amount of code, but it’s made the existing calls reliable and error-proof.

Now let’s run the compiler:

tsc <file name>.ts

The TypeScript compiler checks that types are being used correctly by cross-referencing against the KeyLines definition file. If the file compiles successfully, the output will be.js file that matches the original JavaScript content.

Now we’ve added a type annotation to our file, we can start taking advantage of TypeScript tooling. Let’s look at a couple of the most popular ones: error reporting, and IDE support for TypeScript code completion.

Reporting errors

We’ll add an error to our setSelectionColour function to see what happens. Let’s change the function parameter type from a string to a number:

setSelectionColour(colour: number) {
   let options: KeyLines.ChartOptions = {
     selectionColour: colour,
   };
   this.chart.options(options);
 }

TypeScript throws an error telling us what’s wrong:

If we compile without fixing it, we’ll get the same error message directly from the TypeScript compiler:

'Type '{ selectionColour: number; }' is not assignable to type 'ChartOptions'.
  Types of property 'selectionColour' are incompatible.
    Type 'number' is not assignable to type 'string'.'

Using code completion

Your IDE comes with several features designed to help you write code more quickly and learn more about it. This example shows Microsoft Visual Studio Code’s support, using IntelliSense. It provides context-sensitive information about a function, then prompts you to choose from a list of options:

Want to try it for yourself?

This post gives you a taste of the advantages of using TypeScript with KeyLines. Once you start a trial, you’ll be able to access the source code for the Angular demos we’ve written using TypeScript. KeyLines support for TypeScript 2.0 and later is currently in Alpha development. We’re keen to hear what you think of it, so feel free to contact us.

The post Using TypeScript in KeyLines appeared first on Cambridge Intelligence.

An interview with Luca Olivari of ArangoDB

Earlier this year we welcomed ArangoDB to the Cambridge Intelligence technology alliance. Interest in graph-optimized databases has exploded, as developers look for a better way to work with complex and messy real-world data. Many of our customers rely on graph databases to provide the speedy graph querying needed to power their KeyLines deployments.

Another option is growing in popularity: multi-model databases.

We spoke to Luca Olivari, President of ArangoDB, to find out more about their technology and the multi-model approach in general.

Hi Luca, thanks for joining us! Can we start with an introduction – what is ArangoDB?

Hi Andrew. ArangoDB is a native multi-model database that combines three major NoSQL data models in a single core: key-value, document and graph, with one declarative query language, AQL.

In an enterprise, different applications use different data models. Inside those applications, you’ll find different kinds of data access characteristics. So selecting just one kind of database, optimized for a single model, for all of those tasks, would be painfully limiting and expensive, if you think about the weeks and months developers spend on adapting their data to a relational schema.

One option is to deploy several databases, meaning your DBAs need to learn and maintain multiple technologies, and spend their days trying to get a consistent state of data across them – a kind of mission impossible.

ArangoDB provides a simpler solution. We support three major models in one core, with one query language, including transactional semantics. The database combines a full, scalable document store with transactions and JOIN operations, with fully-fledged graph queries.

Simplifying the complexity of the tech stack in this way gives developers more time to work on their applications, improving their productivity.

What’s the background of the technology?

The main team behind ArangoDB has grown steadily. The first release was back in 2011, but our team’s NoSQL expertise goes back for over a decade. Among us we have multiple PhDs, from St Andrew’s, RWTH and Princeton, and our founders worked with the likes of DHL, NYSE and Deutsche Bank before starting the ArangoDB project.

How is ArangoDB used in production?

The main reason for using ArangoDB is to increase application development agility and reduce costs.

Multiple data models with one technology reduces the complexity of the tech stack.

Accessing your data with a single, feature-rich query language saves on development effort. We also have our Foxx framework for data-centric microservices. As you found with the KeyLines integration, creating apps on top of ArangoDB is simple and fast.

The result is that ArangoDB is being used in a wide range of production scenarios. Some of the more graph-centric use cases include identity and access management, recommendation engines, network analytics, IoT, logistics, etc.

So can ArangoDB be used as a graph store?

Yes, we believe ArangoDB offers the most complete graph experience in the market, especially since version 3.2.

We think it can at least match the performance of the likes of Neo4j or Titan, and comes with graph functionality to rival pure play graph databases. It has fully-fledged graph query capabilities, like traversals, shortest path and pattern matching for real-time graph operations and distributed graph processing via Pregel for a variety of global graph analytics. That means developers can leverage support for distributed graph processing and work with massive amounts of interconnected data.

It also comes with a developer friendly Apache 2 license, and a committed and helpful community.

The flexibility of our approach means developers can start with a single ArangoDB instance and scale vertically and horizontally even with graph data. The experience, which we call Graph460 internally, is rounded off with the KeyLines integration, which powers interactive visualization tools.

What role does KeyLines visualization play in your customer’s applications?

Data visualization, especially graph visualization, are becoming more important.

We offer an integrated graph viewer, but this is really designed for developers to build their data schemas.

The value we’re seeing with KeyLines is putting the visualization into the hands of management and analyst-level staff. It gives them the perfect tool to explore and play around with graphs quickly and intuitively. It lets them find and communicate insights in a way that makes sense to them. KeyLines is a perfect extension for us.

With KeyLines we can offer our customers a modern, beautiful and powerful tool to make sense of huge graphs. It’s a remarkably intuitive tool. Being able to touch the data is really exciting.

Learn more

To find out more about ArangoDB, visit their website. For more information about using KeyLines with ArangoDB, check out this blog post or get in touch to start a trial.

Join the webinar

Want to learn more? Join our next webinar, co-presented with Luca, is about building powerful apps with ArangoDB & KeyLines.

Register for the webinar

The post Powering interactive graph applications with ArangoDB appeared first on Cambridge Intelligence.

Human trafficking is a global issue. An estimated 2.5 million people are currently in forced labor, including sexual exploitation, as a result of trafficking, and the majority of victims are aged between 18 and 24. The International Labor Organization estimates the profits associated with trafficking make it the third-biggest criminal enterprise in the world.

Earlier this year, I gave a presentation on graphs and human trafficking at Graph Day San Francisco. This summary looks at the approach we could use to create an interactive graph visualization tool to understand trafficking patterns.

Tracking victims with online adverts

A key part of human trafficking is the movement of victims, as perpetrators evade detection by continually transporting victims.

In 2014, two information scientists at the University of Hawaii applied network analysis to open internet sources. In their paper, Ibanez & Suthers created a graph dataset using escort adverts, cell phone numbers and advert locations. With this innovative approach, they built a graph model of the most common travel routes of suspected victims of sexual exploitation:

“The advertised phone number is a significant element in observing movement for a number of reasons. The phone number is the link to the provider enabling the John to make contact and schedule services. The area code provides information on the origin of the phone, which may indicate where the provider or trafficker is from. Phone numbers are embedded in the online classifieds as providers are advertised along circuits.”Ibanez & Suthers

This analysis helped build visual models of the movement of victims:

The figures give a great ‘quick visual’ of the trafficking circuits, but they take a long time to create, and you can’t interact with them.

I recreated the analysis using an application built with KeyLines. My goal was to see if an interactive approach could provide an intuitive experience for crime analysts to explore datasets and uncover evidence of victim trafficking.

Creating our graph dataset

Using the same approach as the article authors, I created a dataset of 20,000 classified adverts covering three Canadian provinces/territories – Saskatchewan, Manitoba and Yukon.

I took the raw text from these adverts and used a regular expression to extract phone numbers. The result was two nodes for my graph dataset: post and phone number. I also had a single link type: contains.

Next I chose the Elastic stack (also known as the ‘ELK’ stack – Elasticsearch, Logstash, Kibana) for some quick prototyping. I used LogStash to load the data into Elasticsearch, and Kibana for an initial visual investigation.

KeyLines can work with pretty much any data source. Elasticsearch was the obvious choice, because Elastic’s REST endpoint integrates easily with KeyLines. If I were producing this application for a production environment, and not just for a proof of concept, I might switch my backend to something more graph-friendly, like Neo4j or ArangoDB.

Visualizing the dataset

Here’s what my initial data model looked like in KeyLines:

I use a few bits of KeyLines’ functionality here, including:

• Font icons are a quick and simple way to add images to the nodes.
• Glyphs let me to add simple additional attributes, in this instance the initial of the locations being advertised, without cluttering the chart.

Through simple visual analysis of the glyphs in this small part of the graph, I can already spot a number of different locations being advertised: Regina, Saskatoon and Brandon. I can also see that they’re connected by a common phone number. This provides some evidence of movement in the underlying data source. Of course, further evaluation or statistical inference from the data would be necessary for an investigator to decide whether this indicates human trafficking.

My dataset also includes timestamps of when the adverts were first posted. This is perfect for KeyLines’ time bar.

Here, the time bar histogram shows the total distribution of adverts over time in my dataset. The trendline shows activity related to the selected phone:

Straight away I spot two spikes in activity for this phone number: September and December 2016. Using an information panel in my application I can see these correlate to the two different locations shown in my glyph.

KeyLines’ flexible client-side approach means I can let my users choose between data models on the fly. For example, they could “bypass” nodes that don’t need to be in the chart.

I want to remove the telephone node and instead create direct links between adverts sharing a phone number. I can do this with a few lines of JavaScript:

Each node has the same phone number in common, so I get a densely connected dataset. Now I can use the KeyLines combo feature to turn this model into something more insightful.

Visualizing geospatial trends

The final dimension I want to add to my application is geospatial. Each advert relates to a specific location, so I can combine the nodes and set the link weight to match the volume of movement between the locations:

I can see the most common circuits right away. These roughly correspond to the areas with the most population in my regions, so I could use a normalization function in the future to improve the scales.

Finally, to match my application to the visuals provided in the paper that inspired this work, I geocode the locations in my dataset, supply them as coordinates to KeyLines, and enable Map Mode with a single line of code:

Want to try it for yourself?

This example was created with publicly available data, but it demonstrates, the potential power of interactive data visualization for shedding light on human trafficking. Armed with an intuitive way to explore and understand the data, analysts can make sense of it and uncover trends and insight.

We’d love to apply this technique on real-world data. If you’d like to try KeyLines for yourself, just start a trial or contact us.

The post Investigating human trafficking with graph visualization appeared first on Cambridge Intelligence.

We’re excited to launch the Connected Data Visualization Consortium – or CDVC – a group dedicated to the future of network visualization.

Over the last six years we’ve worked with hundreds of organizations, and thousands of visualization experts all over the world. The CDVC will create a community so members can meet their peers and share their experiences. We’ll explore the challenges that come with designing, building and deploying new tools, and try to understand the future of connected data visualization.

We’ll meet twice a year for member presentations and practical workshops, along with informal discussions and networking. Our first meeting is in London on October 10 2017 for a select group of 25 CDVC members.

We already have key organizations attending, including the UK Home Office, the Financial Conduct Authority, Capita, EclecticIQ and Guardicore.

Want to join us? Learn more about CDVC, and secure your place, at https://connected-data.org.

About the CDVC

The CDVC, co-ordinated by Cambridge Intelligence, is a group of industry-leading organizations that use visualization tools to find unusual behaviors in complex connected data. We create innovative technologies that:

• Investigate criminal activity
• Uncover unusual financial transactions
• Analyze IT or telecommunications network traffic or dependencies
• Track the source and spread of cyber threat

The post Help us shape the future of connected data visualization appeared first on Cambridge Intelligence.

In the first of three blog posts, we explore the real world applications for graph visualization, starting with law enforcement and fraud management.

Use cases for graph visualization

“Data is the new oil”– it may be a cliche, but it’s true. Like oil, data in its raw, unrefined form is pretty worthless. To unlock its value, data needs to be refined, analyzed and understood.

You can say the same about graphs. More and more organizations are seeing potential in their data connections. The question is, how do you get non-experts to analyze graphs at scale and understand potentially complex insight?

Most of the time, the answer is through interactive graph visualization.

Why visualize graphs?

There are four reasons why graph visualization is such a powerful tool:

• It’s intuitive – presenting a graph as a node-link structure instantly makes sense, even to people who’ve never worked with graphs before.
• It’s fast – our brains are great at spotting patterns, but only when data is presented in a tangible format. Armed with visualization, we can spot trends and outliers very effectively.
• It’s flexible – the world is densely connected, so as long as there’s an interesting relationship in your data somewhere, you’ll find value in a graph visualization.
• It’s insightful – exploring graph data interactively allows users to gain deeper knowledge, understand context and ask more questions, compared to static visualization or just looking at raw data.

In a growing number of domains, graph visualization has become a must-have data analysis tool. Let’s take a quick look at the ways graph visualization is being used in real life.

Law enforcement and security

Graph visualization isn’t new. The police have been using it – or link analysis as it’s commonly known – for decades to ‘join the dots’ in investigations. What has changed is the use of technology to make joining the dots a more automated and scalable process.

A failure to analyze the bigger, joined-up picture was cited as a shortcoming of the intelligence services after the 9/11 terror attacks. In the years that followed, law enforcement and security agencies drove graph visualization forward. New approaches and technologies were created specifically for large-scale data analysis of communications records, open source intelligence (OSINT), and police databases.

Lawful interception, the legally mandated interception of personal communications data, provided huge volumes of data on criminal and terrorist activity. Paired with social network analysis, graph visualization techniques allowed non-specialized staff to explore the data and uncover important insight.

Over time, new use cases for graph visualization have emerged. We’ve worked closely with Microsoft Services to build a call-handling interface that helps UK policing teams respond to incidents more effectively.

Our recent webinar with Neo4j showed how visualizing crime records data helps users to understand patterns and allocate resources better. This blog post explains two possible uses for visualization in an event and investigation-led approach.

We’ve also seen how visualizing OSINT (in this case, advertising data) could help uncover human trafficking activity.

This kind of analysis is complex and highly specialized, so many law enforcement agencies choose to build their own visualization solutions instead of relying on off-the-shelf products. The scale of the data being analyzed has also transformed the nature of the visualization: it’s now essential to have effective layouts, filtering and grouping, as well as more powerful rendering.

Fraud detection and management

Another early adopter of graph visualization techniques was the financial services industry.

Fraud detection is about finding unusual connections – between accounts, transactions, insurance policies, devices, etc. There’s great value in visualizing that data as a graph.

As we discussed in this blog post, the nature of the visualization will depend on whether you’re looking for known or unknown fraud.

Known fraud detection is largely automated with rule scoring and pattern matching. Visualization lets you review edge-cases and outliers more quickly. Speed is important, because sometimes analysts only have seconds to approve or deny a transaction.

In those cases, visualizations are simple, small and with limited interaction. To get a clear overview fast, analysts need effective layouts. Other functionality, like expand and filtering helps fraud analysts to see context on demand.

Unknown fraud requires a different process. Here we take a ‘global’ approach – loading a large volume of data and seeking out anomalies. This requires more specialized domain expertise, and a wider range of visual analysis functionality – like grouping, social network analysis and temporal analysis.

These two techniques are widely used in the banking and insurance industries to uncover incidences of fraud. Over time, we’ve seen these approaches used to combat other kinds of fraud, including healthcare fraud, gambling fraud, review fraud and even fake news.

What do these use cases have in common?

Three things are consistent across both graph visualization use cases:

1. They involve highly connected data (obviously)
2. That highly connected data conceals risk insight
3. That insight is needed to power quick and confident decision making

When connected data insight is critical, only interactive and robust visualization tools are up to the task.

Next time, we’ll look at a use case that’s emerged more recently but is increasingly vital: cyber security. In the meantime, don’t forget to start a trial, or get in touch if you’d like to know more about KeyLines.

The post Use cases for graph visualization appeared first on Cambridge Intelligence.

Our last blog post was the first of three exploring real world applications for graph visualization.

In the second in this series, we’ll explore the role of graph visualization for cyber security. It coincides with our involvement in the UK-NL Cyber Security Showcase at the World Trade Center in The Hague. 50 companies from the UK and Netherlands will showcase innovative solutions to tackle the cyber security challenge. There’s still time to register for your free ticket.

Use cases for graph visualization: Cyber Security

Last time we reviewed two of the older commercial uses for graph visualization: law enforcement and fraud detection.

We saw how, as data volumes grew, the connection-led approach evolved from police investigation room walls to the ‘link analysis’ process. The financial services sector adopted this process as an effective way to detect and manage fraud.

In both scenarios, technology has led to bigger datasets. The police now routinely capture and analyze massive volumes of open source intelligence (OSINT), and modern banking involves vast global networks of instant transactions and fast decisions.

You’ll know that cyber security is about understanding network vulnerabilities and protecting them from malicious attacks.

Data is measured in terabytes, and it’s not unusual for enterprises to handle billions of alerts each day. Analysts cannot hope to review every alert, but without the visualization tools to understand the big picture they cannot perform effective triage either. The result: alerts get missed, vulnerabilities are exploited and post-attack forensics are inefficiently managed.

It’s no surprise that cyber security is the fastest-growing use case for graph visualization, which is becoming the go-to tool for cyber analysts. Enhancing their existing SIEM dashboards with a KeyLines-powered component gives them access to the joined-up intelligence they need, in the right place at the right time.

Let’s look at three key aspects of cyber security to see how KeyLines can help.

1. Spotting anomalies

To uncover threats, analysts almost always look for anomalies.

The human brain is good at recognizing patterns. Combined with a machine’s data processing capability, and it’s possible to find anomalies that machines alone would miss. This anomaly detection approach helps prevent data breaches, find malware entry points, predict externals attacks and find vulnerabilities in an organization’s perimeter.

In this webinar with KeyLines customer CyberFlow Analytics (now part of Webroot), their team combined graph visualization and advanced machine learning. The result was an anomaly detection tool capable of scaling to the largest IT networks.

2. Performing forensics

Even if an analyst cannot prevent an attack, graph visualization can still help them understand it and prevent a reoccurrence. Tracking the propagation of malware through a network reveals susceptible and potentially compromised machines.

This KeyLines graph shows the spread of infected traffic in an IT network. The dense cluster of ten machines were infected by two machines hit by a malware attack.

In another example, we explored the VERIS database of data breaches, looking for patterns in how the breaches happen and who is responsible. That chart used the time bar to offer a dynamic view of what happened when:

Complex malware data can be visualized as a graph. KeyLines’ combos and time bar features can reveal network structures that can pinpoint trends and entry points.

3. Sharing intelligence

Graph visualization doesn’t just analyze past events and identify possible future problems: it’s also key to sharing cyber intelligence. KeyLines applications are interactive and intuitive, making them an ideal tool for communicating complex data quickly and simply.

In this interview, with EclecticIQ’s co-founder Raymon van der Velde, we learned how their award-winning cyber threat intelligence platform harnesses graph visualization. Using KeyLines, the EclecticIQ team empower cyber threat analysts with a clear view of STIX/TAXII intelligence, and an easy way to analyze and communicate its insight.

Powering graphs at scale

In all three of these scenarios, performance is crucial.

Analysts rely on graph visualization to provide both a global (overview) and local (zoomed-in) view of their connected data. Performant layouts, filtering and social network analysis is key, but it must be combined with a powerful rendering engine. For a reliable and robust graph visualization at scale, only KeyLines WebGL component is up to the job.

Try it for yourself

If you have a connected data challenge that you think could be solved by visualization, we’re here to help. Start a trial or get in touch to learn more.

The post Graph visualization use cases: cyber security appeared first on Cambridge Intelligence.

We take benefits seriously at Cambridge Intelligence. Competitive salaries, pensions, life insurance, private healthcare, dental plans – they keep our team happy and healthy.

The smaller things matter too. Whether it’s taking a week out for a JavaScript conference in Paris, or buying extra holiday because you forgot about Christmas (again), we’ve thought of many ways to make Cambridge Intelligence a great place to work.

We’re especially proud of our latest perk. It’s a cycle to work plan with a difference: everyone gets a brand new bike. FREE!

We’ve been working on a cycle to work scheme for some time, but didn’t want to burden staff with the tax complications and paperwork of salary sacrifice programs.

Instead, Cambridge Intelligence buys the bikes and loans them to staff for free. As long as commuting is their primary use, we can offer bikes as a tax-free benefit.

Working with local firm Rutland Cycles, Cambridge Intelligence employees can to get a new bike (and any required safety equipment) to the value of £700.

We hope it’ll encourage the team to stay healthy, and help reduce the number of cars on Cambridge’s congested streets. It’s been popular so far, and the first bikes arrived last week.

Fancy a free bike? We’re recruiting now.

The post Fancy a free bike? Come join the team appeared first on Cambridge Intelligence.

Last week, we welcomed some of Europe’s leading graph visualization practitioners to the launch of the Connected Data Visualization Consortium (CDVC), a unique project aimed at driving innovation and sharing knowledge in this exciting area.

It was the first time we’d tried to get so many KeyLines users in one place, so it was fantastic to see everyone there, ready and eager to share their experience and expertise.

The range of organizations represented was impressive, from start-ups to to governments, with use cases as varied as stopping fraudsters, securing data centers and protecting borders.

Despite their different scenarios, it became clear the members faced a common set of challenges and goals – and each their own ingenious solutions. A round-table approach encouraged everyone to speak openly about their own deployments, and share ideas and strategies across the different industries represented.

The agenda balanced member presentations and technical deep-dives. Eight members including Thomson Reuters, BAE Systems, Experian and Accenture, volunteered to lead sessions, inspiring their colleagues with their own visualizations and ideas.

This event is just the beginning of CDVC. As the community grows, it’ll become a hub for inspiration, support and advice, giving members insights into best practice, and helping us to define and build the next generation of connected data visualization tools.

Our next meeting will be in the US in early 2018. To register your interest, visit https://connected-data.org.

The post CDVC gets off to a flying start appeared first on Cambridge Intelligence.

We’re excited to share a preview of KeyLines 4.0: the major new version of the graph visualization toolkit.

The most exciting addition is a game-changing overhaul of the ‘Combos’ node-grouping functionality. The new combos will end chart clutter to give you a faster and more intuitive route to data insight. We think it will change the way you visualize, explore and understand your connected data.

Introducing new combos

As organizations rely more and more on graph insight, the volume of data being collected and analyzed has exploded. The result: overloaded charts and overwhelmed analysts.

We’ve completely redesigned KeyLines’ combos functionality to help you reduce clutter and give analysts a clear view of what’s happening. In KeyLines 4.0, you’ll be able to see inside combos, nest combos and reveal links between combos and nodes. Users can navigate clearer charts, exposing detail on demand at their own pace.

In combination, this capability is a powerful new tool in your graph analysis armoury, transforming cluttered charts into clear insight.

What else is coming?

Combos is the headline feature of KeyLines 4.0 but there’s plenty that’s new since v3.5, including:

• New integrations with JavaScript frameworks and graph databases
• New and enhanced graph layouts
• New demos to kick-start your visualization projects
• Added drawing flexibility

We’ll reveal more soon.

Want to try the new combos?

We’re eager to let you try this new functionality for yourselves. Visitors to GraphConnect NYC can get an early preview of KeyLines 4.0 this week. Stop by our stand in the exhibition hall, or catch us on the Lightning Talks track at 2.25pm.

The post A preview of KeyLines 4.0: less clutter, more insight appeared first on Cambridge Intelligence.

This is our third and final post looking at real-world uses of graph visualization.

First we explored how link analysis evolved from physical ‘investigation boards’ used by law enforcement, helping analysts to link people, locations and events at scale. Then we reviewed how it’s helping to tackle the scale and complexity of cyber security data.

This time, we’re going to review less obvious use cases where graph visualization helps analysts transform complex data into useable insight.

1. Regulatory compliance

It might not be the most exciting topic, but regulatory compliance is critical for all organizations. It often involves grappling with complex scenarios and data to understand non-compliance risk. Graph visualization is the perfect tool for the process. Let’s look at some examples.

AML and KYC

In financial services, due diligence processes like Know Your Customer (KYC) and Anti-Money Laundering (AML) are especially cumbersome. Understanding customer history and behaviors requires a robust data analysis process that relies on some kind of graph visualization (or ‘link analysis’) tool.

In this blog post, our fraud and compliance expert Kaush Kotak explains how some banking organizations are using KeyLines to uncover risks like:

• Politically Exposed Persons (PEPs) – high-profile individuals who require enhanced due diligence
• Beneficial owners – exploring networks of entities to understand the control and ownership structure of a customer
• Correspondent banking relationships – preventing the misuse of international banking relationships

Data protection and GDPR

Data protection regulations are ideal candidates for a graph-led approach.

The forthcoming European GDPR regulation has huge implications for all organizations that hold personal data and operate in the EU. From May 2018, that personal data needs to be catalogued and connected to a genuine business case for keeping it, and all staff need to understand their obligations.

In this webinar graph and GDPR experts, trust-hub, demonstrate the role of visualization in data privacy lifecycle management:

Restricted substances and PLM

Graph visualization can help simplify regulatory compliance processes whenever a person needs to understand the connections inside data. In this blog post KeyLines product manager Dan Williams looks at the role of data visualization for managing restricted substances and complex supply chains.

2. Logistics and operations

Speaking of supply chains, graph visualization is the ideal tool to understand flow.

IoT, telecoms, oil and gas – these industries rely on physical networks of infrastructure to function. A relatively minor failure in those networks can cause critical problems costing millions of dollars.

To counter that risk, companies have invested heavily in network monitoring, collating terabytes of data showing flow and dependencies. Graph analysis techniques, like social network analysis and filtering bring out the most important parts of the network, which can then be further examined with graph visualization.

In this webinar, hosted with multi-model database firm ArangoDB, we walk through the example of IT infrastructure, uncovering the key dependencies in the network to run precise and straightforward impact analysis.

3. Managing knowledge

The final use case we’re going to cover is perhaps the broadest: knowledge graphs.

Take Google. While their early competitors tried to flatten the internet’s densely connected network of information into a huge library catalogue, Google understood the power of the graph and embraced the connected nature of data. They explore the connections between sites, promote those with more authority and generate a more helpful view of the internet.

Now, with the democratization of graph technologies, individual firms can follow suit. Enterprises worldwide are investing in silo-breaking projects to centralize and connect their organization knowledge.

Knowledge graphs come in all shapes and sizes. One bio-science leader uses KeyLines as a visual front-end to their global data discovery platform. Hundreds of thousands of research articles can be explored by type, topic or author using simple navigation techniques – double-click to see all articles by this author, or all reports related to this topic, etc.

Another KeyLines customer is using the toolkit to navigate the complex world of patent information. As we saw in this blog post, understanding IP is a vital part to many business strategies. Graph visualization clarifies the landscape, revealing risks and opportunities.

How can graph visualization help you?

Across all of the examples in the last three blog posts, we’ve seen the huge range of real-world uses for graph visualization. This is just the tip of the iceberg. In any scenarios where you need to understand the nature of a relationship quickly and confidently, graph visualization will help.

If you’d like to try for yourself, you can start a trial here, or just get in touch.

The post Graph visualization use cases: part 3 appeared first on Cambridge Intelligence.

Are your visualizations overwhelming? Are your users submerged in chart clutter?

This webinar is for you.

• Date: Tuesday 14 November
• Time: 8am PST, 11am EST, 4pm GMT, 5pm CET
• Duration: 45 minutes

When it comes to visualizing large graph datasets, a powerful rendering engine alone isn’t enough. You also need the tools to find insight in chart clutter. This webinar is about those tools.

Register for the webinar

Author and graph visualization expert, Corey L Lanum, will share some of ways you can eliminate clutter in your graph visualizations. He’ll explain each of the tools available, and how they can be combined into an effective and intuitive user experience.

This session includes a preview of the forthcoming KeyLines 4.0, which features a new approach to grouping and navigating graphs.

We hope to see you there!

The post Webinar: Managing visualization chart clutter appeared first on Cambridge Intelligence.

A Vue Integration Guide

Vue.js is a popular Javascript framework which is going head-to-head with the likes of Facebook’s React and Google’s Angular. We’ve certainly seen an uptick in requests for Vue integration with KeyLines, and we were delighted to be able to release our Vue component back in September.

Read on to discover how easily KeyLines can integrate with Vue to bring powerful network visualization to your application.

About Vue

Vue is an open source JavaScript framework for building user interfaces. It uses a component based architecture which will be familiar to React and Angular users, but offers a lighter touch.

Vue comes with several powerful features – including a virtual dom, binding framework, templating engine, a router, server-side renderer and more. But it’s also very flexible and can be very lightweight, allowing you only to use the features you need for your application.

Using Vue with KeyLines

One of KeyLines’ strengths is how easily it integrates with other frameworks. Since it’s just a library, it’s simple Javascript API and comprehensive eventing system make it easy to plug in to frameworks and applications. We already support React, AngularJS and Angular. And now it’s easy to bring KeyLines into Vue environments, too.

We’ve published a KeyLines-Vue component, which is really just a wrapper around the KeyLines API. Once this has been loaded into your application, you can work with KeyLines as a regular API or use Vue to bind chart data directly to forms.

Step 1: Load Data

It all starts with some data. KeyLines is agnostic as to what backend data comes from – maybe from a graph database or some pre-formatted JSON. In our demo, we’re going to use data from the Enron emails network.

Whatever the source, KeyLines expects data in the following format:

{
  type: "LinkChart",
  items: [{
      // Definition of a node
      id: "tamara_black",
      type: "node",
      t: "Tamara Black", // The node’s text
      c: "#B2356D"       // The node’s colour
      d: { email: "tamara.black@enron.com" } // custom node data
    }, {
      // Definition of a link
      id: "l1",
      id1: "tamara_black",
      id2: "maria_valdes"
  ]
}

We need to assemble and download this data outside of Vue: for now, we’ll just assume it’s available in a variable called chartData.

Step 2. Create Component

KeyLines provides a Component to simplify integration with Vue, making it easy to load the chart a with declarative rendering.

Once we’ve added Vue, Keylines and the Vue-KeyLines component into the page, here’s all we need to do to create our chart, bind it to the data, and hook up to a couple of key events:

const Demo = Vue.component('demo', {
  template: ` <kl-chart
    id="kl"
    :data="chartData"
    @kl-ready="onReady"
         @kl-selectionchange="onSelectionChange"
  / >`,
  components: {
     Chart
  },
  state: {
    selectedEmail: ""
  },
  data() {
    return {
      chartData: data
    }
  },
  methods: {
    onReady(chart) {
      this.chart = chart;
    },
    onSelectionChange() {
      // We’ll add selection logic here later
    }
  },

});

This code is written in ES6 using features widely supported by modern browsers: but the equivalent code will work in ES5, too. Or you can use a transpiler process like Babel to convert it into native ES5.

This renders and lays out our JSON data as a beautiful network of nodes and links.

3. Add KeyLines Magic

KeyLines provides a wide of range of visualization techniques, layouts and features for de-cluttering the chart. They’re all available to your Vue application through a Javascript API.

I won’t go into detail here on building you KeyLines UI, but you’ll find inspiration and full demo source code on the KeyLines SDK site.

Populating Forms

A common use-case when viewing the chart is to display data related to each node, often by showing a form next to the graph and updating it when the user selects a node. We can implement this very easily using Vue by binding data on the node directly to the UI.

First, we can add a special selection color to make the selected node stand out. We can do this by writing to an options object in our demo component’s data function:

const Demo = Vue.component('demo', {
  template: ...
  components: { ...},
  state: { … },
  data() {
    return {
      chartData: data,
    options: {
      selectedNode: {
        c: '#26BFF0'
      }
    }
  }
});

Secondly, we bind to KeyLines’ selection change event and add logic to update the form. All we need to do is look at what’s been selected and write its properties to the Vue application’s state object:

const Demo = Vue.component('demo', {
  /* … */
  onSelectionChange() {
     var selectedId = this.chart.selection()[0];

     if (!selectedId) {
       this.state.selectedEmail = '';
     } else {
       const selectedItem = this.chart.getItem(selectedId);
       if (selectedItem && selectedItem.d) {
         this.state.selectedEmail = selectedItem.d.email;
       }
     }
   }
});

Finally, we can bind that state to a form using a declarative Vue template:

<h2>Chart Info</h2>
<p>Details about the selected node:</p>
<label>Email </label>
<input
   type='text'
   :value="state.selectedEmail"
/>

This gives us an application which looks something like this:

Reducing Clutter

We can also use built-in features of KeyLines to reduce the amount of data visible on-screen. For example, we can use the combo API to merge or group nodes with common properties. In the enron data set, for example, we can combine people based on their team (or department).

The powerful KeyLines combo API makes this easy. We’ve added a method called combine() to our Vue component. This iterates over the graph, identifies all of the team leaders in the data (every employee has a “reports” property, listing the name of their team leader), and constructs a combo object listing all the nodes which should be part of that group. Here’s the code:

const Demo = Vue.component('demo', {
  /* … */
    combine() {
      var groups = {};
      var comboData = [];
      this.chart.each({ type: 'node' }, (item) => {
        var group = item.d.reports;
        if (group) {
          if (!groups[group]) {
            groups[group] = {
              ids: [],
              label: group + 's Team',
              glyph: { p: 'ne', c: '#26BFF0' }
            };
            comboData.push(groups[group]);
          }

          groups[group].ids.push(item.id);
        }
      });
      this.chart.combo().combine(comboData, { select: false }).then(this.layout);
    }
}

All we now have to do is hook this up to to the UI. This template binds the combine methods to the click event of a HTML button:

<button
      type='button'
      class='btn btn-kl'
      @click="combine">

And we can radically clean up our chart at the click of a button.

Sign up for a trial to browse our API documentation and get a full sense of what KeyLines can do for your data.

Try it yourself

This post shows how easy it is to integrate KeyLines with a Vue application. KeyLines also integrates with any backend – all you need to do is convert your source data into JSON and pipe it into KeyLines.

Start a trial today to access the source code for our existing Vue demos and use them as a starting point. You’ll have access to the Vue component, as well as KeyLines itself.

The JavaScript ecosystem is always evolving and we’re keen to integrate KeyLines with the most popular frameworks available. Which KeyLines integrations would you like to see next? Contact us to let us know!

The post Enjoy the Vue with KeyLines appeared first on Cambridge Intelligence.