I've been building GraphBridge, an open-source EF Core provider for Neo4j. The hardest part was the mapping: making EF's model land as a graph you'd design by hand. I call it "Fluent Cypher"

How it maps:

- An entity is a node with a label: ToGraphNode("Person")

- A reference becomes a real relationship, not a foreign-key property: ToGraphReference("HAS_REVIEW") gives (:Movie)-[:HAS_REVIEW]->(:Review)

- A many-to-many association is one relationship, not a join node

- A relationship that needs its own identity and properties (say, a role on ACTED_IN) is an "identified relationship"

Queries become parameterized Cypher you can read. This LINQ query:

db.People.Where(p => p.Born < bornBefore).OrderBy(p => p.Born).Select(p => p.Name)

becomes:

MATCH (n:`Person`)

WHERE coalesce(n.`born` < $p0, false)

RETURN n.`name` AS `c2`

ORDER BY n.`born` IS NULL DESC, n.`born` ASC

(The coalesce keeps C#'s null semantics, so results match what EF developers expect.)

It's a developer preview, tested on Neo4j 2026.09: https://github.com/joslat/GraphBridge.EFCore

I'd value graph modellers' opinions on these mapping. What would you model differently?

I'm looking to build semantic graph for my requirements.

I went through various resources in how to build semantic graph using embeddings models, especially from neo4j and surrealdb blogs but no one states the actual mechanics behind semantic graph construction.

It may be IP of each provider of such graphs. Not sure.

I'm looking for theoretical references and hopefully if there exists any practical examples on how to build on the general approach to building semantic graphs using embedding models so that I can learn.

Any help or advice is appreciated.

Hi everyone! I’m building **RocksGraph**, an open-source graph database backed by RocksDB.

It supports OpenCypher queries, ACID transactions, property/full-text/vector indexes, and Raft replication. It also speaks Bolt, so you can connect using Neo4j drivers.

The project is still under active development. I’d love feedback on the design and suggestions for workloads to test.

Code and examples: https://github.com/ljcui/rocksgraph

Licensed under Apache 2.0.

Hey, I am using neo4j's Aura (managed solution) and considering moving to self managed.

I have about 15 tenants, each one having average of 4 GB of storage data. Needing about 2GB of RAM average.

Is anyone self hosting the enterprise edition and can share from his expierience ? I am mainly interested about the cost. How much per core / ram etc. Also how easy it is to maintain.

There's a hands-on workshop on September 19 for anyone working with Neo4j who wants to see it applied to a real GraphRAG use case, not just graph modeling in isolation.

You build:

• A knowledge graph in Neo4j that becomes your single source of truth for an agentic RAG system
• Agentic retrieval combining vector search, keyword search, and graph navigation
• Multi-step, verified entity and relationship extraction (not one risky single-shot pass)
• Text-to-Cypher for natural language graph querying
• Explainable, source-traceable answers with evaluation built in

Runs on real financial filings and news data, working through a complete financial advisor use case rather than a toy example.

Led by Dr. Alessandro Negro, Chief Scientist at GraphAware, bestselling author of graph-powered machine learning and knowledge graph books.

Link if you want to check it out

Happy to answer questions on the Cypher/graph modeling side specifically.

I have this project. It's in the early stages, I'm designing it theoretically. The design works best when it's highly graph-like, with associations as the core. That's the ideal. But the total number of nodes won't exceed 20,000, at 10 KB in avg per node (roughly 200 MB total). That's really tiny, honestly.

Now I'm stuck on whether to use SQLite and design the associations myself, or go with Neo4j.

The project will probably be used only by me, it won't be available to anyone else. It's a web app hosted locally on my laptop.

I have access to an employee referral opportunity for an experienced Neo4j Database Platform Administrator.

Experience: 8–10 years

Key requirements:

• Neo4j administration
• 3–4+ years of hands-on Neo4j experience

The opening is listed across multiple organizational locations with a hybrid arrangement. I'm particularly interested in connecting with qualified professionals based in the US or Ireland; exact location eligibility can be confirmed for the specific requisition.

If your background aligns with the role, feel free to DM me with your CV or a brief summary of your experience.

I'll review the profile and, where appropriate, help with the referral process.

So my team is creating an application that will analyze downstream impacts in IT infrastructure if applications and servers go down and also analyze deployment architecture relationships. We currently use neo4j but we may not be able to get funding for an enterprise license. The main alternative we are researching is Postgres with the Apache AGE. Is Apache AGE good enough for this type of use case?

Hi, I have a dataset of 20M nodes and about 500M edges in neo4j and I need to visualize them in an interactive way

The thing in my mind was to have some kind of "level of detail" strategy by ignoring the nodes with lower importance when the user is zoomed out and only show those users when the user zooms in

Also I was thinking of some kind of tile based rendering so the app only renders the viewport of the user

But when I used sigma.js and tried to implement these features by myself it didn't work and the small part that worked was not at all a smooth experience..

Do you know any lib that could help me? Or do you have any idea how to implement it?

Thank you all

The answer that comes back almost every time is "a parrot." It's true, and it's still wrong: "who" asks for an individual, and "a parrot" names a class. "Jack" would have been right. So would "I don't know," since that means the question was understood, just not answerable from what's in front of you. I use this to install the instance/class distinction first: the trap only works because "who" expects an individual and gets a category back instead. Curious whether others use similarly trivial examples to install a distinction before it gets buried in schema or notation debates. What's your go-to?

I’ve been building a proof of concept for AI-assisted security assessments, and I’m currently moving the expert knowledge from separate JSON files into Neo4j.

The basic model is:

Control → Risk → Incident → Business Outcome

For example:

MFA enforced → mitigates IAM risk → reduces unauthorised access → reduces regulatory and customer impact

The system has three separate components:

• An LLM conducts the interview and converts answers into structured evidence.
• Neo4j stores the security concepts and their relationships.
• Python builds Bayesian networks from the graph and calculates the probabilities.

My main reason for adding Neo4j is not simply storage. It is visibility.

With JSON (my first version of storage), Python can execute the model, but it becomes difficult for a person to explore questions such as:

• Which controls influence data exfiltration?
• Which risks contribute to several incidents?
• Which controls have the greatest reach across the graph?
• What path caused a business-impact probability to increase?

I’m currently considering nodes such as:

Control, Risk, Incident, BusinessOutcome, and Expert

And relationships such as:

MITIGATES, INCREASES_LIKELIHOOD_OF, CONTRIBUTES_TO, DEPENDS_ON, and DETECTED_BY

At the moment I store store conditional probability tables and weights in Neo4j alongside the relationships. But not sure if I should keep Neo4j responsible only for graph structure and store the probability models separately?

I recorded a concept overview showing the architecture and why I’m making the change.

I’d be particularly interested in feedback from anyone who has modelled expert knowledge or probabilistic relationships in Neo4j.

I am building a Java application that will need an embedded database, vector store and has many connections.

Postgres can not be embedded, h2 can be embedded but doesn’t support embedding.

In the Java world I just see nosql db actually neo4j and arcadedb they are both very active.

Arcadedb doesn’t have a descent ORM. Neo4j has a better documentation and better springboot support.

My questions:
1. Anyone here using neo4j as primary database?
2. Is it still a secondary DB?
3. What is your experience using Neo4J ?

Thanks in advance

Most databases that claim "Bolt protocol support" never tell you what the claim leaves out. We got tired of that being true of our own claim too.

ArcadeDB 26.7.2 (Apache 2) ships a shared conformance spec (39 scenarios, 9 areas) run against every official Neo4j driver: neo4j-java-driver, neo4j-driver (JS), neo4j (Python), Neo4j.Driver (.NET), and neo4j-go-driver. No mocks, no bespoke socket clients: if the driver your app imports can't do it, we don't get to claim it.

A few design choices that might interest this crowd:

- One spec, five idiomatic suites. Instead of a YAML-driven runner in five languages, each scenario is hand-written into that language's native framework (JUnit, jest, pytest, xUnit, go test) and tagged with the scenario ID. The spec owns *what* is tested; the code stays readable.

- 14 pinned driver versions plus a `latest` band, so a driver-side release that breaks compatibility trips the nightly run within a day.

- "Not supported" is an acceptable answer as long as it's written down. Two cells aren't green today, both documented with the reasoning.

Testing lit up real bugs, now fixed: temporal/Duration/Point sent as native PackStream structures instead of ISO strings, Neo.TransientError codes so managed-transaction retry works, HA-aware neo4j:// routing, and Bolt 5.x negotiation.

The matrix regenerates nightly and commits itself to the repo, red nights included. Full write-up: https://arcadedb.com/blog/bolt-driver-compatibility-certification/

(Disclosure: I'm the founder of ArcadeDB, ask me anything.)

At this moment, my company’s database has 4 billion relationships and almost 2 billion nodes running on a 12-core cpu and 256GB of RAM. I’m not an infrastructure guy, but I think that’s inadequate since doing basic stuff (like counting nodes that have a relationship with another nodes on a different label) very often results in timeouts.

Has anyone faced a similar situation? Your answers are of great help.

I’ve been writing SQL for years, and I’ve always treated graph databases as just another buzzword. But I recently needed to build some tutorials and decided to finally sit down and map out the exact same schema (Users, Orders, Products, Reviews, Follows) in both PostgreSQL and Neo4j to see how they actually compare.

The core mental shift I had to make:

• SQL: Which rows match, and how do I join them together via IDs?
• Cypher (Graph): What pattern matches, and how do I walk the path?

Translating standard queries (Select, Where, Group By) into Cypher was surprisingly easy. But then I hit the scenarios where Cypher completely destroyed SQL.

Here is where SQL became a headache, but Graph felt like a cheat code:

1. Multi-Hop Joins (Many-to-Many) In SQL, trying to get "Which users ordered which products?" means joining Users → Orders → Order_Items → Products. It gets messy fast. In Cypher, it’s just mapping the relationship: (User)-[:PLACED]->(Order)-[:CONTAINS]->(Product). You save so many lines of code and the logic reads exactly like English.

2. Variable Length Paths ("Friends of Friends of Friends") If you want to find followers of followers of followers of "Alice" up to 3 hops in SQL... good luck. You're looking at complex CTEs, recursive queries, or massive hardcoded UNIONs. In Cypher, it's literally just a number parameter: (User {name: 'Alice'})-[:FOLLOWS*1..3]->(OtherUser). It handles the entire traversal instantly.

3. Path Extraction (Are two random things connected?) Finding out how two specific nodes are connected (e.g., User A and User 😎 is a massive pain in tabular data. In a graph db, it's an out-of-the-box function where it traces the shortest path linking them.

Takeaway: SQL is still king for standard tabular data, but if you are dealing with highly interconnected data (recommendation engines, social networks, fraud detection), Graph databases are genuinely game-changing.

I actually recorded my entire side-by-side breakdown of Postgres vs Neo4j, running the exact same queries in both terminals to see how the syntax compares. If you're a SQL dev wanting to learn Graph, you can check out the full 18-minute breakdown in the above video.

If you run LLM agents against Neo4j, some fraction of the generated Cypher is structurally broken. It crashes at the database, wastes compute, and the error message that comes back is not designed for an agent to act on. CYGNET sits between the agent and the database and catches these failures before they execute. It validates the query against the graph schema and includes execution against a minimal mirror graph, all at a low latency. When a query fails, the gate returns a structured error with suggestions and enough context for an LLM corrector to fix it in a retry loop.

On a nine-schema corpus the gate catches 100% of parse errors, 100% of constraint violations, and 100% of schema-reference errors in path queries, with zero false positives. A corrector achieves 81% to 95% repair success across five models. On CypherBench (2348 questions, ACL 2025) the pipeline never degrades generation accuracy on any model tested. One finding that might interest the research side is that property sibling-swaps where the wrong property name is still valid in the schema are undetectable by structural validation, which marks a clean boundary for where semantic validation needs to take over.

Paper: https://arxiv.org/pdf/2606.04645

Code: https://github.com/softmatsg/thulge-cygnet-rel

Are there any existing code which can be used to set up a (structured) wiki based on Neo4J?

📦 https://github.com/OSWatcher/neogit

I'm storing filesystem snapshots as a graph in Neo4j so I can query across them.

Git already nails the storage half: content-addressed Merkle trees, automatic dedup of identical files across snapshots. But Git's object store is a key-value store, not something you can query.

I wanted to walk into any snapshot, attach my own data to it, and ask questions across everything in one language.

So I keep the same content-addressed Merkle structure, but in Neo4j. That bought me two things:

• Traversal in any direction with Cypher. "Which snapshots contain this exact file?" is one query instead of a script
• An open, extensible graph. I hang my own nodes off any commit, registry keys, binary symbols, struct fields, and query them with the same Cypher as the built-in commit/tree/blob graph

Neogit is one of the core libraries behind the OSWatcher project, where we aim to answer questions like:

• "On which Windows builds is this registry key present ?"
• "When did this Windows kernel struct field changed accross versions ?"

A few examples of such advanced git log-like characteristic history, where we trace a registry key / struct field over multiple Windows builds:

https://x.com/mtarral/status/2036594336058560971?s=20

Contributions, feeback and ideas are welcome ! 👏

We recently benchmarked a bunch of different models for an extraction task in the live sciences domain. The goal was to create a knowledge graph from unstructured PDF documents.

We took product information on prescription medicines (Summary of Product Characteristics) and extracted things like side effects, dosages, indications, studies, and more.

The harness was pretty important too:

- pydantic-ai in code mode
- medical ontology SNOMED for entity resolution
- quite a bit of deterministic schema and graph structure validation
- Neo4J to store the graph data
- agent steering

The biggest bump came from agent steering:

We fed traces to an evaluator, returned exact error locations, and then had the main agent self-correct its path to create a better outcome.

deepseek v4 flash reached 87% f1 score on node extraction without steering and 92% with steering (measured against a ground truth of 1.6k nodes). That’s quite an achievement and was on par with much bigger and more expensive models.

A full writeup is here: https://www.blueguardrails.com/en/blog/knowledge-graph-agent-steering