MarketMind
The news names one company. Who else just moved — and who quietly won?
A US export ban hit the chip sector. Every name went red. One went green. Nobody typed it.
The green node is SMIC — a Chinese foundry the same sanction protects. MarketMind flagged it the moment the news landed, and the next day it really closed up +3.45%. I never told it to hunt for a winner. The graph found one on its own.
That's the whole idea. A headline names one company; a curated dependency graph — suppliers, customers, partners, owners, rivals, and the standing sanctions sitting over all of them — works out everyone else in the blast radius: how hard they're hit, along what path, and which way they move. It reasons about exposure, not price.
What is MarketMind?
A reasoning engine on a Neo4j graph, fronted by an Aura agent. You ask in plain English — "what did the 2023 chip export controls do?" — and it finds the event, runs the cascade, shows the path (NVIDIA → TSMC → …, fading each hop), names the regime, and points at the non-obvious name the headline skipped. Every number it hands back is a tool query against the graph. It doesn't freestyle.
The graph
Small on purpose — 104 companies, 257 dependency edges, 27 events — and every edge hand-vetted. The point isn't size; it's one rule.
Four relationship types ever propagate company-to-company: SUPPLIES_TO, COMPETES_WITH, OWNS, PARTNERS_WITH. That's the cascade. Everything else — countries, commodities, themes, sanctions — only seeds the shock at the right doorstep, then gets out of the way. It's never walked. (Let a Sector node into the path and every chipmaker becomes two hops from every other chipmaker, and the whole thing turns to soup. So I don't.)
Two more pieces make SMIC turn green:
- A standing
Conditionnode. A sanction isn't a one-off event — it's a state of the world that sits there until it's lifted. ItCONSTRAINScompanies with a sign: minus for the firms it hurts, plus for the domestic one it protects. Tighten it, and the graph re-prices the whole set — beneficiary included — with no new modelling. - Validation lives in the graph. Every real next-day move is an
ImpactRecordnode (2,565 of them), so "did this actually happen?" is a traversal, not a footnote.
The agent
Seven tools, each doing one honest job.
Agent walkthrough video:
- Only usage (short): https://youtu.be/9v3TOlErWVw?si=E8ijdtXalxpedH24
- Full walkthrough: https://youtu.be/garN__tbDcA?si=k-3slowOp8VSs4MZ
| you ask | it calls | you get |
|---|---|---|
| "what did the 2023 chip controls do?" | find_event → impact_cascade |
NVDA −0.66 · AMD −0.51 · TSMC −0.48 · … SMIC +0.35 (up) |
| "did that really happen?" | validate_history |
NVDA −7.12% · SMIC +3.45% — misses kept in |
| "why is NVDA exposed?" | company_dependency_map |
its suppliers, customers, rivals, owners |
| "what constrains SMIC?" | active_conditions |
the export-control rule, and which way it cuts |
| "will NVDA go up tomorrow?" | — | it declines, politely |
The language model only names the company the news actually hit. The graph does everything past the headline.
And another one, to follow up:
The honest part
This is where most "AI + markets" demos promise you tomorrow's close. I won't — and the backtest is why. (If I could reliably call tomorrow's close, I'd be doing that for a living, not entering a hackathon.) Live data is the next experiment — and it'll face the same honest backtest before I claim a thing. We'll see what happens 
On 27 held-out events, against real prices, next-day direction lands around 47% — a coin flip. A dumb whole-sector average actually beats me on raw direction, 48.3% to 46.6%. I left that in the README; cropping it felt wrong.
What it does do, measurably: it surfaces about 20% of the movers the headline never named — which a headline-only reader catches zero of — and explains each with a path you can audit. The app overlays the real returns with ✓ and ✗, misses and all.
So: not a price oracle. A way to see who's in the blast radius and why, with the receipts. A sharp true claim beats a suspicious one.
There's an app, too
Same graph, same engine, made cinematic. The news lands and a shockwave ripples out in red, fading by hop, SMIC green in the corner. Flip to a world map and the same shock arcs from Washington to Shanghai. Hit the Time Machine and the real next-day numbers drop in with their ✓/✗. Click any node for the per-hop math.
Note: I may have gotten a little carried away making this look like a trading-floor command center — but it's still genuinely useful under the hood. Still iterating; if you'd have built it differently, I'd love to hear how.
App video — with the particle effects, because watching the shock actually ripple outward is half the point 
: https://youtu.be/2oStQKmEpBA?si=ffTew9XaNpMigvtc
One footnote, kept honest
The graph and all seven tools are live and verified on Neo4j Aura (Free tier) — everything above is real output from the running instance, driven from the Aura console.
Taking the agent external — the public, shareable REST endpoint — is currently held up by an unresolved credit-redemption issue I'm still working through. (UPDATE - it is fixed, see the note below) So rather than wait around, I run the same thing locally, two ways, both checked against the hosted agent:
- the same graph in a local Neo4j (Docker). Identical seed and records, where the same Cypher-Template tools return the same rows as the hosted agent — and a parity script confirms it agrees to the sign, on every one of the 27 events.
- a local agent on Microsoft's Agent Framework (with Azure OpenAI as the model). It does the same job: the model reads the headline and names the company; the cascade engine — in-process, and at parity with the Cypher — propagates it through the graph.
Same graph, same engine, same answers - but most probably much more latency... as the Aura Agent is native and co-located to the Aura db. The hosted endpoint only adds the public door; the moment the credit-redemption issue is sorted, it goes up with nothing else to change.
Update! - Now it works with the Aura Agent! I left the workaround under a flag - documented in the source code - see below so you can still play with it fully locally
I have published the app as open source, as the issue with the credit redeeming is gone - thanks @Ari_Neo4j for the supper support and incredibly fast reaction time!!!
Check it out here: GitHub - joslat/MarketMind: When news breaks, the damage travels. MarketMind traces it across a Neo4j company-dependency graph — who's hit, how hard, and the non-obvious name the headline never mentioned. Reasoning + exposure, not prediction. · GitHub - and remember to star it!!
(it has all the necessary artifacts for you to recreate the graph database, seed the data, regenerate the golden dataset with the calibration needed and the Aura Agent)
---
Built on Neo4j Aura, a directional cascade engine in three languages kept at parity, and an unreasonable amount of re-checking the numbers.