Real-time Graph ETL

Quine, voted Best Open Source Project of 2022, is a  streaming graph that connects to your existing data streams and builds high-volume data into a stateful graph.

Quine efficiently analyzes that graph for the “standing queries” you specify and streams results out immediately.
DEMO VIDEO DOCS
The inner workings of Quine -- data flows in and completes a pattern that is already partially identified, triggering the next action in a workflow.
Thank you to our community! Quine wins Noonie Award for Best Open Source Project of 2022

Streaming Graph Solves Complex Event Processing Challenges

Easily Combine Data Sources

Join streaming and batch data with out-of-order data

Standing Queries

Massively parallel efficient graph computation, run at the perfect moment, every time.

Multi-Way Joins at Scale

Match Nth-degree deep relationships in real-time.

Complete Data Version History

Track every change, and easily query any historical data.

Categorical Data

Ingestion of complex events, and pattern recognition for numeric and non-numeric data types.

Swappable Data Storage

Integrate with persistent data store of your choice.

No Time Windows

Join new events with months-old data immediately with a fast stateful graph.

Graph Data Model

Understand data semantic relationships as high-level attributes.

Out Of Order Data

Automatically resolve out-of-order data from multiple or heterogeneous data sources.

Fast Reads & Writes

Durable storage + in-memory processing breaks traditional limitations.
READ THE DOCS

Integrations

kafka logoamazon kinesis logocassandra logorocksdb logohidrolix logo
A photograph of contributor, Matt Splett.
Matt Splett
Principle Engineer, Tripwire

"Using Quine, I replaced pages of complex custom logic and SQL queries with simple queries for the stream computed rollup value that updates at each underlying event change."

A photograph of contributor, Jim Plush
Jim Plush
Distinguished Engineer, CrowdStrike

“Quine represents a paradigm shift in online graph processing capabilities. By allowing data to react to itself as well as its relationships in real time, it gives you the capability to augment your graph on the fly and free up downstream consumers to react to changes without having to keep asking the same questions. This allows building more performant services with fewer resources.”

A photograph of contributor, Kevin Baker
Kevin Baker
Principle Architect, Analog Devices

"Being a Kubernetes architecture we needed to investigate the relationship between multiple related Kafka event streams to identify optimization of our compute nodes and Kubernetes autoscaling configuration. Unlike traditional and expensive reference lookups in relational databases, Quine enables us to correlate our graph-like streaming data in real-time. This has really reduced the overhead for querying our data to determine critical optimization opportunities for our platform."

As Easy As

Recipes make it easy to try Quine yourself.

VIEW RECIPES

See For Yourself

Launch the Quine app

Download the executable, build from source code on Github, or run a Quine Recipe to run a pre-configured workflow to deliver real-time answers for a specific use case.

1

java -jar quine.jar
Graph is ready!
Quine web server available at http://0.0.0.0:8080

Ingest Data, Build Your Graph

An API call sets the ingest source, format, and mapping of data elements to the streaming graph. The graph data model mitigates out-of-order data delivery issues.

2

curl 'http://localhost:8080/api/v1/ingest/data-source' \
-H 'accept: */*' \
-H 'Content-Type: application/json' \
-d '{
"type": "FileIngest",
"path": "/directory/data_source",
"format": {
  "type": "CypherLine",
  "query": “CREATE ($that)”
}
}'

Define Standing Queries

A second API call sets the standing query to monitor for complex patterns and trigger actions for each match. Standing queries are distributed across the streaming graph and continuously [rp[agate as new data in ingested. Partial matches are stored in the graph, enabling high-throughput and real-time results.

curl 'http://localhost:8080/api/v1/query/standing/data-output \
-H 'accept: */*' \
-H 'Content-Type: application/json' \
-d '{
"pattern": {
  "query": "MATCH (n) RETURN id(n)",
  "type": "Cypher"
},
"outputs": {
  "output-1": {
    "type": "File",
    "path": "/directory/data_result"
  }
}
}'

3

Explore Your Data

Directing a browser to localhost port 8080 brings you to the Data Exploration UI, where you can explore the graph, interact with the REST API or view operational metrics.

4

A screenshot of the Exploration UI showing a complex graph.

Many types of applications - demos to try yourself

A graph made up of grey nodes except where a pattern of fraud is detected, denoted by red nodes.

Real-Time Tag Propagation

Ingest the Ethereum blockchain and propagate "dirty money" tags in real-time to trace money laundering.

VIEW THE RECIPE
A graph made up of grey nodes except where a pattern of fraud is detected, denoted by red nodes.

CDN Cache Efficiency By Segment

Ingest CDN Logs and calculate cache hit rate in real-time by segments: country, state, PoP, ASN to generate alerts or dashboards.

VIEW THE RECIPE
A graph made up of grey nodes except where a pattern of fraud is detected, denoted by red nodes.

Apache Log Observability

Ingest Apache web server logs and observe interactions between services.

VIEW THE RECIPE

Here’s what it is like to integrate

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aliquam aliquam amet, sociis eu lorem sed rutrum. Condimentum augue erat iaculis magna morbi cum ac gravida.

Action 1
Action 2
action 3
Feature 1
Feature 2
Feature 3
Feature 4
Feature 5
Feature 1
Feature 2
Feature 3
Feature 4
Feature 5
Feature 1
Feature 2
Feature 3
Feature 4
Feature 5

We use cookies to ensure you get the best experience on our website. Learn More

GOT IT
SlackTwitterGitHubLinkedInFacebook
© 2023 thatDot, Inc.
The Quine logo - a Q with an arrow, like a graph edge, as the stroke in the Q. White version.
Code of Conduct