neo4j.com

What is Neo4j?

Neo4j is a graph data platform: a database and set of tools built around storing data as nodes (entities) and relationships (connections between them), rather than as rows in tables. Its pitch is that when the connections between data points matter as much as the data itself, querying those connections directly is faster and more natural than reconstructing them with joins.

What the platform includes

• AuraDB — a fully managed graph database service, for teams that don't want to run the infrastructure themselves.
• Graph Database (self-managed) — the deploy-it-yourself option for those who need control over where data lives.
• Graph Analytics and Graph Data Science — running graph algorithms (paths, centrality, community detection, similarity) over connected data, either on managed or self-managed deployments.
• Virtual Graph — building and querying a knowledge graph on top of data that already lives elsewhere, without migrating it first.
• Aura Agent — building context-aware AI agents.
• GraphRAG — combining graph retrieval with large language models so AI answers are grounded in connected, structured context.
• Enterprise Studio and Fleet Manager — query, explore and visualize data; manage multiple deployments from one place.

Who it's for

The page organizes uses by industry (financial services, healthcare and life sciences, public sector, retail, telecommunications) and by problem: fraud detection, identity and access management, master data management, real-time recommendations, supply chain, digital twins, and financial crime intelligence. In practice, that means two broad audiences:

1. Application and data teams whose core questions are about relationships — "who is connected to whom, through what path, and how strongly" — such as recommendation engines, fraud rings, or dependency mapping.
2. AI and data science teams that want a knowledge layer under a model, so generated answers can be traced back to real entities and relationships instead of relying on the model's memory alone.

When it's the right fit — and when it isn't

A useful next step: pick one concrete question your current system answers awkwardly — for example, "which accounts share a device or address within two hops of a flagged transaction?" — and try modeling just that slice. Neo4j's own learning resources include GraphAcademy for free courses, and the Neo4j documentation for deployment and query details. Compare that experience against your existing stack before committing to a migration; the trade-off is usually modeling effort and a new query language in exchange for much simpler relationship queries.

How does Neo4j make AI agents more accurate with GraphRAG?

Neo4j's pitch is that a graph database can act as the "knowledge layer" behind an AI agent, and GraphRAG is the retrieval pattern that connects the two. Instead of retrieving isolated text chunks by vector similarity alone, GraphRAG retrieves connected facts and relationships, so the model answers from structured context rather than guessing. Neo4j's platform page frames this as making AI systems more accurate and cites independent research claiming GraphRAG makes AI agents substantially more truthful. That claim is the vendor's summary of third-party research, not a guarantee for your data.

H3 How the pieces fit together

• Knowledge graph as the source of truth. Entities (customers, products, accounts, incidents) and their relationships are stored as a graph, which is the format Neo4j is built around.
• GraphRAG retrieval. An agent's question is turned into a graph query or traversal that pulls the relevant subgraph — the entity plus its neighbors and paths — and hands that to the LLM as context.
• Agent memory and tooling. The same graph can hold conversation state, preferences and prior decisions, which the agent reads and writes through APIs or the Model Context Protocol.

H3 A concrete scenario

A fraud analyst asks an agent: "Is this account linked to any known mule network?" A vector-only system might return documents mentioning fraud. A GraphRAG setup can traverse shared addresses, devices, transfer patterns and prior cases, then return the specific paths that connect the account to suspicious activity — with the relationships as evidence the analyst can inspect.

H3 Trade-offs to weigh

H3 Next step

Pick one high-value question your users ask that depends on connections between things — not just similarity of text — and prototype it as a small graph plus a retrieval query. If you need a managed starting point, see Neo4j; for background on the pattern itself, look at arXiv and for the open-source implementation, GitHub.

Should I choose Neo4j AuraDB or a self-managed graph database?

Choose AuraDB when you want to spend your time on graph modeling and queries rather than on cluster operations, backups and upgrades; choose self-managed when you need control over where data lives, how the environment is tuned, or how it fits into existing infrastructure. Both paths are presented on Neo4j as ways to store and query connected data, so the real difference is operational, not conceptual.

When AuraDB is the better fit

• Small teams without a database operator. A managed service removes patching, scaling and backup chores, which matters if your graph is one component of a larger application.
• Fast starts and variable workloads. You can stand up a graph for a prototype, demo or new product feature without provisioning servers first.
• AI and agent projects. The site pairs its managed offering with graph-based retrieval and agent capabilities, so a team building a knowledge layer for AI can stay on one managed path instead of assembling infrastructure.

When self-managed makes more sense

• Data residency, network isolation or on-premises requirements. Regulated environments often cannot place a core datastore in a vendor cloud.
• Existing platform standards. If your organization already runs its own databases, monitoring and identity systems, a self-managed graph database fits that operating model.
• Specialized tuning or extensions. Workloads with unusual memory, storage or algorithm needs may benefit from direct control over the deployment.

A practical way to decide

A useful next step: write down the two or three constraints you cannot bend — data location, uptime responsibility, and who is on call — then check those against the deployment and pricing options on Neo4j. If none of your constraints are hard, start managed and revisit the decision once the graph is in production and its real load is known.

How do I learn Neo4j through GraphAcademy?

GraphAcademy is Neo4j's free online learning center, offering courses and certifications for people who want to work with graph databases and the wider graph platform. It sits alongside the developer documentation and community resources on Neo4j Graph Intelligence Platform, so you can pair structured lessons with reference material as you go.

What it's good for

• Beginners who need the graph model explained before touching a database.
• Developers who already know SQL or another database and want to translate that knowledge into Cypher, Neo4j's query language.
• Data scientists and analysts moving into graph algorithms, graph analytics, or GraphRAG-style work with AI systems.
• Anyone preparing for a certification who wants a defined curriculum rather than scattered tutorials.

A sensible path

1. Start with the fundamentals: what a graph is, nodes, relationships, properties, and basic Cypher reads and writes.
2. Move to modeling. This is where most newcomers struggle, because graph design rewards thinking about the questions you'll ask rather than normalizing tables.
3. Practice in a real instance. Courses are far more useful when you run every query yourself rather than reading along.
4. Branch by role: developer courses for application building, data science courses for algorithms and embeddings, AI-focused material for retrieval and agent memory.
5. Take a certification once you can model and query without looking things up constantly.

How to decide if it fits you

Practical notes

GraphAcademy is free and self-paced, which makes it easy to trial before committing budget. The trade-off is that self-paced learning depends on your own discipline, and the breadth of the catalog means it's easy to wander. Pick one learning path and finish it.

As a next step, create a free account, enroll in the introductory Cypher course, and complete it end to end in a sandbox database before choosing a specialization. If you get stuck, the Neo4j community Discord and developer blog are the natural companions to the courses.

Can Neo4j help with fraud detection and financial crime intelligence?

Yes. Fraud detection and financial crime intelligence are two of the use cases Neo4j explicitly lists, alongside GraphRAG and knowledge graphs. The core idea is that fraud rarely lives in a single record — it lives in the relationships between accounts, devices, transactions and people, which is exactly what a graph database is built to store and query.

Where a graph approach fits best

• Money movement and mule networks: following funds through chains of accounts to find the accounts that only exist to pass money along.
• Identity linkage: spotting shared phone numbers, addresses, devices or beneficiaries that connect seemingly unrelated customers.
• Circular flows and layering: detecting loops and round-tripping that are hard to express as table joins.
• Real-time screening: checking a transaction against known bad actors and their extended network at the moment of authorization.
• Case work and intelligence analysis: letting an investigator explore a network visually instead of reading a spreadsheet.

How the platform pieces map to the problem

A concrete way to test it

Pick one known fraud pattern from your own case history — say, three or more accounts sharing a device and passing funds within 48 hours. Model just those entities and relationships, then write the traversal as a query. If a pattern that took an analyst hours to assemble by hand comes back in seconds, the graph case is proven on your data rather than on a vendor claim.

Who benefits and who should look elsewhere

Graph pays off when relationships are the signal and the questions are multi-hop. If your fraud detection is mostly rules on single transactions with no network dimension, a conventional analytics stack may be simpler and cheaper. If your analysts are already drawing link charts by hand, that manual work is the strongest sign a graph belongs underneath it.

Next step

Start with the free GraphAcademy courses to build fluency, then read the graph-thinking material in the Neo4j developer resources. If you want to see the pattern-detection approach in practice, the GitHub repositories tagged with Neo4j examples are a reasonable place to look for a worked fraud query you can adapt.

How much does Neo4j cost?

Neo4j doesn't publish a single price. It sells several products on different models, so the cost depends on which one you use and how you deploy it. The official Neo4j pricing page is the only place to get current numbers, since plans and tiers change.

What drives the cost

• Deployment model. Fully-managed cloud services (AuraDB, Aura Graph Analytics, Aura Agent) are typically subscription-based and priced by usage or capacity. Self-managed products (Graph Database, Graph Analytics, Graph Data Science) are licensed for you to run on your own infrastructure, so your total cost also includes servers, storage and operations staff.
• Scale and workload. Managed tiers usually scale with data size, compute or query volume, so a small prototype and a production system land in very different brackets.
• Edition and features. The self-managed database has community and commercial editions; enterprise features, clustering and support sit in the paid tiers.
• Support and add-ons. Enterprise support, training and services are usually separate line items.

A practical way to decide

For a concrete next step: write down your graph size, expected query load and whether you can run servers yourself, then request a quote or start a free trial on the official pricing page. That gives you a real number instead of a range. If you're comparing options, Neo4j's own docs and GraphAcademy are useful for estimating what a workload actually requires before you talk to sales.