Yes -- as the post above states, for the AuraDB Free Tier accounts the credits are there but are not able to be seen. Adding a CC will not change that, The team is aware though, but feel free to use them.
hey finished the course and filled the form when can I expect the aura credits into mu account?
@Ari_Neo4j I submitted the project, but it's still not shown in banner
I just added it! Your are officially on the banner. @prashant7090 is added too!
Hi - We send out the Aura credits 2x a week. I believe the next batch will be scheduled for today.
VAT-TaxGraph AI
What It Does
VAT-TaxGraph AI is a Neo4j-powered forensic tax investigation agent that uses graph intelligence to detect suspicious trading behavior, hidden business relationships, and potential VAT fraud.
The agent converts natural language investigation requests into Cypher queries and performs graph-based relationship analysis across companies, directors, and transaction networks.
The system focuses on identifying:
-
circular trading patterns
-
Companies sharing directors
-
non-filer participation in active trade flows
-
suspicious transaction chains
-
seller-only entities
-
tightly connected trading clusters
The agent uses Text2Cypher to generate investigation queries dynamically from user prompts.
Dataset and Why a Graph Fits
I generated a synthetic tax compliance dataset consisting of:
-
Companies
-
Directors
-
VAT trading transactions
Graph modeling was ideal for this case because fraud detection depends heavily on relationships and multi-hop traversal patterns rather than isolated records.
The graph structure allows detection of:
-
hidden ownership structures
-
indirect trading relationships
-
circular transaction flows
-
interconnected suspicious entities
-
fraud rings across multiple companies
Graph Schema
Nodes:
-
Company(pin, name, filing_status)
-
Director(director_id, name)
Relationships:
-
(Director)-[:DIRECTS]->(Company)
-
(Company)-[:SOLD_TO]->(Company)
The dataset was imported into Neo4j AuraDB Professional using Aura credits and queried through Cypher-based investigation workflows.
AI Investigation Capabilities
Example investigation prompts:
-
“Identify circular trading patterns involving Non-Filer companies connected through shared directors.”
-
“Find companies connected through shared directors that are actively trading with each other.”
-
“Trace multi-hop trading relationships connected to companies controlled by the same director.”
The agent generates graph traversal Cypher queries such as:
MATCH p=(d:Director)-[:DIRECTS]->(c1:Company)-[:SOLD_TO*1..4]->(c2:Company)
RETURN p
LIMIT 50;
Technologies Used
-
Neo4j AuraDB Professional
-
Cypher Query Language
-
Text2Cypher Agent
-
Synthetic Fraud Detection Dataset
-
Graph Traversal and Path Analysis
Screenshots
- Aura Agent Console Screenshot
- Graph Visualization Screenshot
Why I Built This
Traditional tabular analysis struggles to uncover hidden relationships between entities involved in suspicious trading behavior.
Graphs make these connections visible and traversable.
TaxGraph AI demonstrates how Neo4j and AI agents can support forensic investigations through explainable graph reasoning and connected intelligence.
@Ari_Neo4j I received my Aura credits and redeemed to my account, but I don't see them. I have created a Professional instance and was wondering if its even needed for this? I have my credit card added in billing. Bit confused as to what gets used first, my card or the credits?
I was told these were sent out last night! 
Thanks for your patience.
Yes - and this is something we learned, and have made the product team aware. My suggestion is to not set up a paid account for the purpose of this project. If you have redeemed your credits, you will be able to use them. Consumption is not visible on the free accounts, so feel free to remove your credit card and use them freely until they run out.
Looking forward to see what you build.
Hi Ari_Neo4j, I have the same question. I have added a CC but can't see how to remove it so I can use my credits freely until they run out.
Thanks for your patience. The silver lining here is that this brings attention to some important issues for our community. However, we are about efficiency and user happiness. I will hopefully have a reply soon.
A new batch of credits have been sent out, and are ready for redemption and use:
@JessedOsborne
@violet.ols.dev
@tiffanyseah94
@irene.chen
@destrin.de
@vivekgupta.ec
@arishwaran.syh
@michael.bateman.com
@bhattacharya.ananya0
@joslat
@vineet.negi
@kevin.dmonte
@hamza.hadfi
@erserz
@martynscn
@sebastianpmenendez
@neerajchormale39
Please DM me if you did receive you credits. Those who requested some over the last 1 will receive theirs tomorrow or Monday.
Looking forward to seeing some more Agents!
Hackathon submission update: HealthGraph Agent: Apple Health to Aura
quick update on my submission. Since my last post I've added a full set of Neo4j Aura elements on top of the original ETL + longevity-query foundation. The whole stack now runs end-to-end: iPhone → Aura graph → Aura Agent → iOS chat. Everything is open source and reproducible.
→ Repo + README: GitHub - ma3u/healthgraph-agent: Apple Health data → Neo4j knowledge graph with longevity-focused analysis. Neo4j Aura Agent Hackathon 2026. · GitHub
The submission is now built on four pillars, each backed by a Neo4j Aura primitive:
1. 
Aura Agent (HealthGraph Agent)
A longevity-focused assistant with 6 tools — Text2Cypher + 5 parameterized Cypher templates (health_overview, workout_recovery, longevity_trends, overtraining_check, exercise_balance). MCP enabled, REST-invokable.
The big addition: the agent is defined as code via the new Aura v2beta1 /agents API (thanks to Ed Sandoval for the pointer). The full agent JSON is committed at agents/healthgraph-coach.json and reconciled with one script (scripts/create_aura_agent.py) supporting three modes: status (default — diff live vs file), --pull (live → file), --push (file → live, POST or PUT). I keep a screenshot of the Console state in the repo for fidelity.
While wiring the iPhone chat I caught and fixed a copy-paste bug in the health_overview Cypher template — it referenced $workout_type while the tool parameters were $start_date/$end_date, so the agent was reporting "tool is currently unavailable". The rewritten template now returns daily metrics (RHR / HRV / steps / sleep_hours / workout_min / kcal / VO2max) for the requested window plus a rolling 30-day baseline ending the day before — exactly what the system prompt asks for.
Three real Q&As are captured at docs/AGENT_DEMO.md (in the repo): a grounded RHR analysis ("56.11 bpm all-time vs 57.82 bpm last-30"), a 12-week overtraining check with CAUTION flags + deload-week recommendations, and a "no data" failure case where the agent honestly reports a gap instead of fabricating.
2. 
Aura Dashboard
Whoop-style NeoDash dashboard at neodash/whoop_dashboard.json — 5 pages, 35 panels: daily hero card (Recovery %, Strain 0–21, Sleep %), Recovery deep-dive, Strain deep-dive, Sleep deep-dive, and 8.5-year Health Monitor. Score formulas in docs/SCORING.md. Pushed into Aura's built-in Tools → Dashboards via scripts/upload_dashboard.py — idempotent (deterministic UUID per title).
3. 
Aura GraphQL Data API + GitHub Pages
GraphQL Data API: curated SDL with @cypher MERGE mutations (ingestDay / ingestWorkout / ingestSleep) at cypher/graphql_schema.graphql. Deployed against the live tenant via scripts/create_aura_data_api.py — aura-cli v1.8.0 has no data-api commands, so the script hits the v1beta5 REST endpoints directly. All three mutations smoke-tested + idempotent.
GitHub Pages: daily Recovery snapshot rendered by scripts/render_snapshot.py, committed by a GitHub Actions workflow on a 06:30 UTC cron (auto-resumes paused Aura instances). The live link is in the header above.
→ Live daily snapshot: HealthGraph dashboard
4. 
iPhone App: HealthKit sync + "Ask your graph"
HealthGraphSync iOS app — Swift 6 / iOS 26.5 SDK. Reads HealthKit on-device, queries Aura for max(Day.date), scans HealthKit since then, presents the per-type delta, then uploads via the three GraphQL @cypher mutations. Includes Rescan last 30 days and Rescan last 365 days flows. Verified end-to-end on real iPhone 17 Pro — graph grew from 3,087 → 3,117 :Day nodes after first sync.
The Dashboard tab embeds an "Ask your graph" panel that calls the same HealthGraph Agent /invoke endpoint via OAuth2 client-credentials. Four suggestion chips compute concrete date ranges at tap time (ISO Mon–Sun for "last week", last 12 weeks for overtraining, last 30 / 60 days for workout-HRV correlations) so the agent always gets specific dates. The fresh answer auto-opens in a draggable overlay (.medium / .large detents) on top of the dashboard, with full Markdown rendering via AttributedString(markdown:) — paragraphs, bullets, numbered lists, inline **bold** / *italic* / `code`, and the trend arrows (↑ improving, ↓ declining, → stable) the agent emits.
BYO Aura
The whole thing is bring-your-own-Aura: every installer points the iOS app and the GitHub workflow at their own Aura instance. There's no shared backend. Both provisioning scripts (create_aura_data_api.py, create_aura_agent.py) take AURA_CLIENT_ID / AURA_CLIENT_SECRET / AURA_INSTANCEID from a local .env and produce a working stack in <5 min.
What's open
-
#5 Auth0 production sign-in path (Apple / Google / GitHub / Microsoft → Bearer JWT to the Data API). Currently using dev-mode
x-api-key; Auth0 work is gated on a manual tenant setup. -
Vector embeddings for similarity search on
DailySummary.description.
Issues closed during this stretch
#2 Apple Health Sync to Aura + In-app Dashboard · #3 GraphQL Data API + Pages dashboard · #4 Aura Agent integration + Neo4j Skills · #6 HealthGraphCoach as code via Aura v2beta1 /agents.
Feedback welcome 
— particularly on whether the agent's tool selection feels right, and on the v2beta1 agents-as-code workflow (super useful, please keep going with it).
Matthias / @ma3u
Hi @Ari_Neo4j , I completed the course last week on the 13th and filled out the form. Please let me know when I can expect the Aura credits to be credited to my account.
65 years of global health data, one graph, five tools — ask anything about why some countries live longer than others.
-
Agent Name:
Aura-Health-Bot — Life Pulse: Global Health Intelligence
-
What it does:
Aura-Health-Bot answers questions about 65+ years of global health data in plain English — instantly, accurately, and with supporting data.
Ask it something like "Which high-income countries have the worst infant mortality?" or "Find countries with a health profile similar to Japan" and it traverses a richly connected Neo4j graph, picks the right tool, and responds with a clear answer and a formatted data table.
It is built for five audiences: healthcare professionals, policymakers, researchers, students, and the general public — anyone who has ever wondered whether spending more on healthcare actually leads to longer lives.
Five specialised tools power the agent:
| Tool | Type | Purpose |
|---|---|---|
| Country Health Overview | Cypher Template | Full health profile for any country and year |
| Top Efficiency Countries | Cypher Template | Countries achieving the most health per dollar spent |
| Country Health Spending Trend | Cypher Template | Year-by-year spending evolution for any country |
| Search Snapshot Context | Similarity Search (Vertex AI · gemini-embedding-001 · 768D) | Find countries with a similar health fingerprint using vector search |
| Natural Language to Cypher | Text2Cypher | Handles any free-form question the templates cannot |
The combination of deterministic Cypher Templates, flexible Text2Cypher, and semantic vector search means the agent handles simple factual queries, complex analytical questions, and fuzzy similarity questions equally well — no prompt engineering required from the user.
Live app: sbb-neo4j-auradb-agent-hackathon-life-pulse-aura-health-bot.streamlit.app
Dataset and Why a Graph Fits
The question this dataset asks: Does spending more money on healthcare always lead to longer lives?
The dataset spans 1960 to 2024 — over 65 years — sourced from three authoritative global institutions:
-
World Bank Open Data (GDP, population, expenditure)
-
WHO Global Health Observatory (life expectancy, mortality)
-
OECD Health Statistics (workforce, spending, outcomes)
It covers every country in the world across 8 key indicator domains: life expectancy, health spending, hospital capacity, infant mortality, maternal mortality, economic context, workforce density, and efficiency.
Why a graph — not a relational database — is the right choice:
A flat table can store this data. A graph can think with it.
-
Relationships are the insight. The question "Which low-income countries achieve high life expectancy despite low spending?" requires traversing Country → Snapshot → LifeExpectancy + HealthSpending + IncomeGroup simultaneously. In SQL that's four JOINs. In Neo4j it's a natural path query.
-
Time is a first-class citizen. Each country's annual snapshots are chained with
[:NEXT_YEAR]relationships, making 60-year trend queries as simple as traversing a linked list — no date arithmetic or self-joins. -
Peer comparison is native. "Compare India to countries in the same income group" is a two-hop traversal: Country → IncomeGroup ← Country. In a graph it reads like a sentence.
-
Vector search lives in the same store. Each
:Snapshotnode carries acontextTextembedding (768D, Vertex AI Gemini). Finding "countries that feel like Japan" is a single vector similarity query over the same graph, no separate vector database needed. -
The schema grows with the problem. Adding pandemic data, mental health indicators, or air quality metrics requires adding nodes — no table migrations, no foreign key rewiring.
The graph model in one picture:
(:Country)-[:IN_REGION]->(:Region)
(:Country)-[:IN_INCOME_GROUP]->(:IncomeGroup)
(:Country)-[:HAS_SNAPSHOT]->(:Snapshot)-[:NEXT_YEAR]->(:Snapshot)
(:Snapshot)-[:HAS_LIFE_EXPECTANCY]->(:LifeExpectancy)
(:Snapshot)-[:HAS_SPENDING]->(:HealthSpending)
(:Snapshot)-[:HAS_CAPACITY]->(:HospitalCapacity)
(:Snapshot)-[:HAS_MORTALITY]->(:InfantMortality)
(:Snapshot)-[:HAS_ECONOMY]->(:EconomicContext)
(:Snapshot)-[:HAS_EFFICIENCY]->(:EfficiencyMetrics)
10 node types. 10 relationship types. Every query is a traversal that would have been a multi-page SQL stored procedure.
Screenshot — Agent in the Aura Console
Agent in Action:
The agent using the Cypher Template tool to retrieve a precise country health profile — shows structured, deterministic retrieval
The agent performing vector similarity search to find countries matching a health profile — shows the semantic intelligence layer.
The agent using the text 2 cypher tool to retrieve a precise country efficiency score.
Dashboards:
Explorer:
Nodes & Relationships:
Agent Link
[Launch Live App](https://sbb-neo4j-auradb-agent-hackathon-life-pulse-aura-health-bot.streamlit.app/)
[MCP Server](https://mcp.neo4j.io/agent?project_id=d0b38bd0-7dc4-4136-9d36-a8a863db33ea&agent_id=21b70856-0c04-4e62-9383-681f9cc0cb66)
[GitHub Repository]( GitHub - shrikantbhadane/SBB-Neo4j-AuraDB-Agent-Hackathon-Life-Pulse: This repository is part of Neo4j AuraDB Agent hackathon, this is using Kaggle dataset for life expectancy and health spending for the period of 1960 till today from World Bank Open Data, the World Health Organization (WHO) Global Health Observatory, and OECD Health Statistics · GitHub )
Thank you so much for joining us!
The credits are sent out 2x a week, and I requested they be sent out today ASAP!
Agent Name
RecallScope Agent
What It Does
RecallScope is an operational recall-response agent for grocery distributors and retailers. It turns public FDA food recall data plus internal supply-chain context into an explainable incident command board and store-level pull sheet.
The agent helps answer:
- What products should we pull or hold?
- Which stores are affected?
- Which suppliers are involved?
- Which customer segments may be exposed?
- What graph evidence supports each action?
Dataset And Why A Graph Fits
RecallScope uses public openFDA food enforcement recall data combined with a realistic synthetic distributor dataset containing SKUs, suppliers, stores, inventory, orders, and customer segments.
A graph fits because recall response is a relationship problem. The important question is not just “what was recalled?” It is “which recalled products match internal SKUs, where are those SKUs stocked, who supplied them, and which customers may be affected?”
Neo4j lets the agent trace paths like:
FDA Recall → Internal SKU → Store Inventory → Supplier → Customer Segment → Action Plan
Aura Agent Tools Used
- Cypher Template tools for incident summaries, pull sheets, action ranking, supplier exposure, and evidence tracing
- Text2Cypher for ad hoc operational questions
- Vector indexes generated for future semantic SKU matching
Demo / Screenshots
Attached:
- Screenshot of the RecallScope Agent in Aura
- Screenshot of the agent producing an incident command board and pull sheet
- Screenshot of the Aura dashboard
- Screenshot of the recall impact graph path
- Short demo video: https://youtu.be/UB2WjVefupc
Notes
The current prototype refreshes openFDA recall data through ingestion scripts and merges it into Neo4j. Internal distributor data is synthetic for the hackathon demo.
The following community members should now have received their Aura Credits for completing the Aura Agent course and participating in the community initiative:
@tarunnarang1992
@kantechaitanyaa
@bruno.henrique.brito
@mariorbavo4
@ramraj
@btakwa04
@Ajaysinghkarayat2
@xiao-susie-bai
@gankogui
@flmn
We cannot wait to see what you build with Aura Agents and Neo4j.
Also welcome the latest projects added to the Community Submission Ticker:
• @shrikantbhadane — Aura-Health-Bot
• @violet.ols.dev — RecallScope Agent
• @dhiraj.patra — RegulatoryRisk GraphAgent
• @shantanunitw01 — CineGraph AI
And @mabu.mate, we updated your ticker link to point to the latest Apple HealthGraph Agent project description so community members can now jump directly to the newest version of your submission from the ticker.
There is still nearly a month left for submissions, so keep building, experimenting, and sharing your Aura Agent projects with the community. The project wall and live ticker continue to grow with new graph-powered ideas every week.
# ReviewGraph AI
## Agent Name
ReviewGraph AI
## What It Does
ReviewGraph AI is an AI code review intelligence agent that helps engineering teams understand pull request risk before merge. It analyzes changed files, review comments, modules, dependency relationships, AI-assisted changes, and known risk patterns.
The agent answers questions like:
- Why is this PR risky?
- Which services are becoming tightly coupled?
- Which files attract the most review concern?
- What risk patterns are linked to AI-assisted changes?
Instead of only flagging issues, ReviewGraph AI explains the graph evidence behind the answer.
## Dataset and Why a Graph Fits
The dataset models a code review system with repositories, pull requests, files, modules, reviewers, review comments, issue types, AI-assisted changes, and risk patterns.
A graph fits naturally because code review risk is relationship-driven. Pull requests modify files, files belong to modules, modules depend on other modules, reviewers comment on files, comments mention issue types, and AI-assisted changes can resemble known risk patterns.
Example graph structure:
(PullRequest)-[:MODIFIES]->(File)
(File)-[:PART_OF]->(Module)
(Module)-[:DEPENDS_ON]->(Module)
(PullRequest)-[:HAS_REVIEW_COMMENT]->(ReviewComment)
(ReviewComment)-[:MENTIONS]->(IssueType)
(AIChange)-[:SIMILAR_TO]->(RiskPattern)
(RiskPattern)-[:CAUSES]->(IssueType)
This allows ReviewGraph AI to reason over dependency cycles, review hotspots, security-sensitive changes, and maintainability risks.
## Tool Used
Text2Cypher
ReviewGraph AI uses Text2Cypher to convert natural-language review questions into Cypher queries over the Neo4j Aura graph.
## Screenshot of Agent in Aura Console
## Screenshot or Short Demo of Agent in Action
Why is PR-184 risky?
PR-184 is risky because it modifies authentication-sensitive files, affects AuthModule, UsersModule, and TokensModule, and is connected to dependency cycles across core identity modules. Review comments also flag duplicated token validation and security-sensitive coupling.
Git Repo URL - https://github.com/tarun1992/reviewGraph-AI