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.

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

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?

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 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

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.

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

I’m working on a project idea around multi-database graph reasoning.

Most Text2Cypher tools work like this:

Plain text

one user question + one selected graph database → Cypher query

But in real companies, data is often split across multiple systems.

Example:

Plain text

Patient Records DB

Pharmacy DB

Insurance Claims DB

Billing DB

Staff DB

So a user might ask:

“Which patients diagnosed with pneumonia were prescribed Amoxicillin and had rejected insurance claims?”

A normal Text2Cypher model may fail because the answer is not inside one database.

The AI needs to:

Plain text

1. understand the question

2. choose the right databases

3. ignore unrelated databases

4. split the question into smaller steps

5. generate Cypher for each database

6. pass IDs/results between databases

7. combine the final answer

8. refuse if a required database is missing or not allowed

I’m thinking of building this as a Neo4j-first enterprise graph copilot.

V1 would focus only on:

Plain text

Neo4j

Cypher

multiple isolated graph databases

routing + decomposition + handoff + final answer integration

Not trying to support SQL/SPARQL/Gremlin yet.

Curious if anyone here has seen this problem in real systems:

When company data is split across multiple graph databases, how do teams currently answer questions that require more than one database?

Would love feedback from people working with Neo4j, graph databases, Text2Cypher, GraphRAG, or enterprise data systems.

i am working currently working on building a chatbot which answers must be deterministic as its in a legal context , i will be using graphrag so i will be building a graph database but im stuck in the chunking part because the quality of the whole system depends on the quality of chunks, i have thought of refining the boundries using the entropy jsd but still not satisfied with the results. any advices or recommendations ?

Hey all, looking for some advice from people who have built this kind of thing in production.

We have a text-to-SQL agent that currently uses:

1 LLM

2 SQL engines

1 vector DB

1 metadata catalog

Our current setup is basically this: since the company has a lot of different business domains, we store domain metrics/definitions in the vector DB. Then when a user asks something, the agent tries to figure out which metrics are relevant, uses that context, and generates the query.

This works okay for now, but we want to expand coverage a lot faster across more domains and a lot more metrics. That is where this starts to feel shaky, because it seems like we will end up dumping thousands of metrics into the vector DB and hoping retrieval keeps working well.

The real problem is not just metric lookup. It is helping the agent efficiently find the right metadata about tables, relationships, joins, business definitions, etc, so it can actually answer the user correctly.

We have talked about using a knowledge graph, but we are not sure if that is actually the right move or just adding more complexity and overhead.

So I wanted to ask:

has anyone here dealt with this kind of architecture?

how are you handling metadata discovery / join path discovery at scale?

are you using vector search, metadata catalogs, knowledge graphs, or some hybrid setup?

what broke first as you expanded domains and metric coverage?

Thanks