* Still time to register! *

Imagine competing in a high-stakes hackathon where the most cutting edge of AI - Agentic Applications, GraphRAG on ArangoDB, and NVIDIA GPU-accelerated graph analytics - converge to redefine the future of GenAI-powered business solutions.

With GraphRAG emerging as the most advanced Retrieval-Augmented Generation (RAG) approach, this competition challenges you to develop an intelligent agent that can query and reason over graph data with precision and efficiency.

Why GraphRAG?

Traditional RAG systems rely solely on vector-based retrieval, which can lead to hallucinations, context fragmentation, and a lack of structured reasoning. GraphRAG addresses these shortcomings by integrating graph-based retrieval, preserving contextual relationships between entities and enabling more accurate, structured, and interpretable AI-generated responses.

By leveraging GraphRAG, participants can minimize hallucinations, improve knowledge retrieval, and enhance AI-generated insights - a fundamental breakthrough for enterprises using generative AI in business-critical applications.

Microsoft itself has been a thought leader in acknowledging GraphRAG as the next evolution of natural language GenAI approaches, as explained here and in even more detail here.

Your Mission

Build an Agentic Application that integrates GraphRAG and GPU-accelerated graph analytics to solve a real-world problem.

At the highest level, the Hackathon involves the following steps/deliverables:

Choose a dataset that is relevant to something of interest to you or your organization. ArangoDB recommends a few public datasets if you don’t have your own.
Convert/load the dataset into NetworkX.
Persist the NetworkX data to a graph within ArangoDB.
Build an Agentic App on top of the graph that processes natural language queries.

The bulk of the creative effort in the Hackathon will relate to Step 4 - Building the Agentic App. The previous 3 steps are simply a lead up to that effort.

Participants have two dataset options:

Bring Your Own Data (BYOD) – Use open-source datasets relevant to specific industries or a use case of interest to you or your team (e.g., social networks, cybersecurity, supply chain, healthcare, transportation, etc.). This dataset should be compatible with a graph structure (either already in a graph or convertible to a graph). This data will be loaded into NetworkX (and then persisted to ArangoDB) as one of the steps in the Hackathon. For instance, if you want to explore some publicly-available datasets, consider the following sites:

Use one of ArangoDB’s Provided Datasets – These are pre-configured graph datasets provided by ArangoDB. Note that these datasets can be loaded directly into ArangoDB, thereby allowing you to skip the “Data Preparation into NetworkX” stage:

To streamline development, ArangoDB is providing a sample Jupyter Notebook Template with pre-built placeholders to help structure each and every step of the process.

Requirements

Your Step-by-Step Hackathon Guide

Step 0: Select Your Dataset

Select a dataset relevant to your problem statement, either provided by you or by ArangoDB (see above). If you choose one of the ArangoDB graph datasets, you will be able to load it directly into ArangoDB, bypassing Steps 1 and 2 below.

NOTE: Instructions on how to directly load one of the ArangoDB-provided datasets into ArangoDB are available when clicking on one of the datasets above.

Step 1: Prepare Your Dataset

NOTE: If the dataset is already structured as a graph, proceed to Step 2.

If not yet in graph format, transform it into a node-edge structure by defining entities (nodes) and relationships (edges).

Example: Convert customer transactions, social networks, or supply chains into a graph.

The Jupyter Notebook Template provided as part of this Hackathon provides links to in-depth guidance for data transformation, including placeholders for loading CSV/JSON files, defining graph schemas, and preparing data for ingestion.

Step 2: Load Graph Data into NetworkX

NOTE: If you are using an ArangoDB-provided dataset, and you have loaded it into ArangoDB (see instructions with each dataset), proceed to Step 3.

Format the dataset as a graph structure before ingestion into NetworkX.
As referenced in the Jupyter Notebook Template, use Python scripts to transform tabular data (CSV, JSON, etc.) into a graph representation.
Load the graph into NetworkX for initial processing and structure verification.

The Jupyter Notebook Template will include placeholders for defining graph nodes, edges, and visualizing small test datasets before full ingestion.

Step 3: Persist / Connect the Graph in ArangoDB

NOTE: If the graph is already loaded into ArangoDB (bypassing Steps 1 and 2), simply use the ArangoDB + NetworkX Integration to connect the ArangoDB graph to NetworkX. This will be required to execute cuGraph GPU-accelerated analytics using NetworkX. See Section 3 of the Jupyter Notebook for more information on how to do this.

If the graph is still in NetworkX, it needs to be persisted to ArangoDB.

Use the ArangoDB + NetworkX integration to store and manage the graph efficiently.
Utilize the 30-day Free Trial of ArangoGraph (the cloud-hosted version of ArangoDB) for scalable storage and querying
Feel free to also use the ArangoDB Community Edition which has no time limit.

The process involves:

Persisting the NetworkX graph to ArangoDB and visualizing a sample of the graph.
Using the ArangoDB Backend to NetworkX for CRUD operations on the graph.
Running validation queries to ensure successful storage.

The Jupyter Notebook Template will include all the necessary pre-written code templates for interacting with ArangoDB, making it extremely easy for participants to insert and query their data.

Step 4: Build the Agentic App for Querying the Graph

Step 4 will require the bulk of the creative effort, as the previous steps are straightforward, guided by the Jupyter Notebook Template, and easily reproducible regardless of the dataset.

The design of the Agentic App, the type of queries and analytics it features, and how the query results are surfaced and visualized by the end user, will constitute the majority of the input for the key judging criteria. For example, an Agentic App that showcases Hybrid Queries (see below) will receive extra credit.

The Agentic App will process natural language queries and dynamically determine the optimal retrieval method. Implementation of the Agentic App can be done via LangGraph and LangChain.

Dual Query Execution:

SIMPLE QUERIES → Dynamic AQL (via LangChain)

Uses ArangoDB’s LangChain Integration Pack to convert natural language queries into optimized AQL queries.
Example query:
"Find all direct connections of Alice" → AQL traversal

COMPLEX QUERIES → GPU-Accelerated Graph Analytics (via NetworkX/cuGraph)

Executes cuGraph algorithms (e.g., PageRank, Community Detection, Shortest Path) using the cuGraph Backend to NetworkX (by way of the ArangoDB Backend to NetworkX).
Runs on Google Colab or Kaggle Notebooks to leverage cloud GPUs. Additional GPU credits can be purchased (~$10) through Colab or Kaggle if the free-tier is not enough for your use.
Example query:
"Find the most influential person in the network" → PageRank via NetworkX (CPU) or cuGraph (GPU)

HYBRID QUERY EXECUTION → Combining AQL and cuGraph for Contextual Responses

For more complex queries, the system dynamically combines AQL traversal with GPU-accelerated analytics to generate contextually rich responses in natural language.

HOW IT WORKS:

Query Breakdown: The agent determines if the query requires both graph traversal (AQL) and graph analytics (NetworkX/cuGraph).

AQL finds Alice’s direct and second-degree connections.
NetworkX/cuGraph PageRank ranks them by influence.
Example: "Who are Alice’s most influential connections?

Execution & Response:

Runs AQL to retrieve relevant graph data (traversal).

Passes results to NetworkX/cuGraph for deeper analysis.
Synthesizes a natural language response, e.g.:
"Alice is connected to Bob, Charlie, and Dana. Charlie has the strongest network impact."

The Jupyter Notebook template will provide pre-built code blocks, guiding participants on how to dynamically select AQL vs. NetworkX/cuGraph execution paths based on user input.

Step 5: Submit Your Solution

The submission should include:

Your notebook (stored in a public Github Repo)
A 5-10 minute, public YouTube video, with screen capture/recording and talk track explaining the dev process and appication functionality.

YouTube Video Guidelines:

Your background and why you participated
Which dataset you chose and why (what is the business problem: 1-2 slides)
How you converted the data to a graph (if you provided the dataset)
The steps taken to persist/load the data into ArangoDB if you provided the data set.
Visualize a sample of the graph.
How the Agentic App dynamically retrieves and processes natural language queries based on intent. Include a detailed walk-through of the Jupyter notebook components. Highlight the various agent tools used.
A real-time demo/screen recording of natural language agent/app with a variety of queries retrieving graph insights and other visualization of the results.

Hint: be creative!

The Jupyter Notebook Template will serve as the central development workspace, allowing participants to track their progress, document findings, and refine their implementations before final submission.

The Future of AI is Graph-Powered

By the end of this hackathon, you will have built an Agentic Application that integrates:

GraphRAG for more precise Retrieval-Augmented Generation.
cuGraph & NetworkX for GPU-accelerated graph analytics.
ArangoDB for scalable graph storage, visualization, and querying.

This competition offers a rare opportunity to work hands-on with the most advanced tools in the AI and graph space, providing practical skills that can be applied in real-world AI-driven applications.

Let’s get started!

Hackathon Sponsors

Prizes

$29,750 in prizes