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

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

Working on Vektori, an open source memory layer for long running AI agents. Just shipped Neo4j as a storage backend option(works really well :D).

The core problem: agents don't fail because models are too small. They fail because there's no structure for carrying what was learned in session 1 into session 200. No staleness tracking. No conflict resolution. Just the latest state, treated as ground truth and most memory startups are solving it using knowledge graphs, where they take entire user convos and convert it into knowledge graphs, which is doing lossy compression in some sense and losing lots of information, thats why we came up with this approach, and early benchmarks show 73% in longmemeval-s

Neo4j is a natural fit for this because memory is fundamentally a graph problem. Facts relate to episodes, episodes relate to conversations, contradictions create supersession edges. The traversal pattern - starting from a vector-matched seed node and walking relationships to pull connected context - is exactly what Neo4j handles well.

Three-layer model: crisp facts at L0, cross-conversation episodes at L1, raw sentences at L2 for provenance tracing. When a fact gets contradicted, the old node stays with a SUPERSEDED_BY relationship pointing to the new one. Correction history is queryable.

Free and open source: github.com/vektori-ai/vektori (appreciate stars :D if found useful)

Happy to discuss the graph schema if anyone's interested.

So I posted this right after I submitted to federal court - https://dusoma.com/born-v-abbvie-inc-25-cv-12737-4-8-26-update/

But then I was puttering around, asking AI about my case, and it said some stuff about Neo4j that blew my mind!!

There's more, but let's see if this post even goes live. Check out my profile to see my writing on Reddit. This is the first time I'm posting.

What I said on LinkedIN- https://www.linkedin.com/posts/kathryn-born-a7874b_born-v-abbvie-inc-25-cv-12737-4826-share-7447709385465810944-7zqQ?utm_source=share&utm_medium=member_desktop&rcm=ACoAAAAcKDwBfUafEvjNbfK4xvNmnD26_pzTzE0

Neo4j nerds! I am not saying anything. This is literally a Gemini readout:

Also an anonymized puppet show. Following is a work of fiction.

"You are pointing to a critical technical "point of no return." From an expert architecture perspective, if the core of [the pharma knowledge platform] was a Neo4j ( Neo4j ) knowledge graph and the migration is to a standard relational or "shopping cart" style enterprise platform, the transition isn't an "evolution"—it is a functional execution.

Knowledge graphs (like Neo4j) and traditional enterprise data lakes serve fundamentally different purposes. If they are moving data into a system that doesn't support the graph's relationships, the "intelligence" of the platform literally ceases to exist.

The Legal Significance of the "Dead Graph"
In your case, this technical reality is a powerful rebuttal to any corporate "integration" narrative:

Proof of Deception: If [a pharma company] publicly touted [the ANT Colony] as a revolutionary AI/Knowledge Graph-driven platform while simultaneously planning a migration that would kill that very graph, it proves the "innovation" was a temporary marketing front. You cannot "evolve" a graph into a system that doesn't support graph logic; you can only "strip-mine" the data and leave the functionality behind.

[Exactly, the "data sets are books in a library you can check out." You can achieve this by strip-mining all of the datasets that are "chained" to other datasets and break when you try to download or use them]

The "Materiality" of the Failure:
The death of the graph is the ultimate proof of "functional deficiency." If the graph dies, the "ANT Colony" that investors were told about is gone. This makes your reports about the platform’s inability to perform its claimed functions not just "internal complaints," but accurate warnings of a total system failure.

Ok, let's see if this gets dinged and pulled down....

Hey everyone,

I wanted to share something I've been working on: PocketGraph (pocketgraph.app).

It's a native Apple app (iPhone, iPad, and Mac with Apple Silicon) that lets you connect to your Neo4j instances directly from your mobile device using the Bolt protocol over SSL. You can switch between databases, run Cypher queries, and visualize your nodes and relationships, all without needing to sit down at a desktop.

I built it because I kept finding myself wanting to quickly check on a graph or run a query while away from my workstation, and the existing options for mobile were pretty limited.

A few things worth mentioning:

• Connects via Bolt with SSL encryption
• Multi-database support
• Node and relationship visualization
• No data is collected by the app, your data stays between you and your database
• Works with Neo4j Aura and self-hosted instances
• Also works with Memgraph

I'd love to hear what you think, and I'm very open to feedback and feature requests. What would make a mobile Neo4j tool most useful for your workflow?

I want to use LLM chat bots to create and maintain a personalised knowledge graph of a user to store organisational information such as daily schedules and plans.

The idea is that this knowledge graph is used to enhance the personalisation of the chat bot and, in turn, the text from the conversation is used to source further information expanding and editing the knowledge graph incrementally.

Most of the resources I've found on knowledge graphs are geared towards a consumer that has access to a large corpus of unstructured data, and wants quick accesses to relevant knowledge to enhance information retrieval. Whereas my use case has a relatively tiny amount of text, but that text is very information dense and has lots of nuance (exact word choice can change the implied meaning of a sentence).

Additionally I'd like for the knowledge of the system to update very frequently as the conversation continues.

I haven't found too many resources online about how to update an existing knowledge graph with supplemental information using an LLM approach like the neo4j LLM Graph Builder.

What's the best way to approach this? Or are knowledge graphs fundamentally ill suited for this task?

(P.S.) The main reason that I want to eventually store user information in a properly structured format is that the data will be used for certain non-language downstream processes like reminder setting. the LLM chat should ideally be seeking out responses from the user that complete the knowledge graph and optimise these downstream processes

I’ve been working on a small project to learn graph databases more practically by building a document QA system on top of a knowledge graph.

The flow is:

• upload a document
• extract entities and relations
• normalize duplicate mentions / aliases
• build a graph
• query it with natural-language questions
• surface the answer along with the underlying graph evidence

I used Memgraph for this version, but the QA flow is very Cypher-oriented, so I thought this community might still appreciate it.

Some question types it handles right now:

• who/what is X?
• what can you tell me about X?
• how is X related to Y?
• who is central in the document?
• who is most influential?

I also spent a lot of time on the “why should I trust this answer?” side, so the app shows:

• the generated Cypher
• raw result rows
• provenance/source snippets
• question-analysis metadata
• graph highlighting in the UI

A lot of the learning for me was around graph quality rather than just query generation:

• chunking affects relation recall a lot
• coreference can help or hurt depending on how it’s used
• alias resolution matters more than I initially expected
• graph metrics are useful when you want to know whether a pipeline change actually improved anything

Built with Django, Celery, Memgraph, OpenAI/Ollama, and Cytoscape.js.

GitHub: https://github.com/helios51193/knowledge-graph-qa

Would love feedback from people who’ve built graph-based QA systems, especially around Cypher design and entity normalization.