r/Neo4j • u/SuspiciousSurvey5590 • 8d ago
Relate by Neo4j is Live — Open-Source Embedded Database for AI Agents
r/Neo4j • u/SuspiciousSurvey5590 • 8d ago
r/Neo4j • u/No_Restaurant27 • 11d ago
Hi all,
I’m putting together a toy project for an exam to see how well Neo4j, neosemantics and an LLM agent work together. The domain will probably be insurance or banking (haven’t decided yet). The idea is to load document-extracted data as RDF, import an ontology with n10s, and let an agent answer questions through a few tools plus some read-only Cypher.
What I’m hoping to get out of the ontology:
fewer tokens, because the agent works from a compact schema and makes fewer exploratory calls
better guidance on what it can ask next, from domain/range and the class hierarchy
inference handled by the database (subclasses and so on), so the LLM doesn’t spend tokens reasoning about it
relationships that carry real meaning, plus labels and synonyms so the agent understands the business terms
answers that stay consistent and can be traced back to the data
I have two doubts. n10s feels limited, so maybe a triplestore with a real reasoner would fit better, but n10s seems to be the only server-side solution with neo4j. I’m also not sure step-by-step exploration by the agent is the right approach compared with text-to-Cypher or query templates. I would like to give the user a lot of flexibility when asking questions but not even spend a ton of tokens on loading a whole ontology as system prompt or as a tool result.
Does this setup make sense for these goals, or would you do it differently?
Our team is currently designing a permission system and user relationship model (think 3 to 4 levels of organizational hierarchies and shared resource access).
Part of the team is pushing hard to introduce Neo4j because Cypher makes graph traversals very clean to write. The other half wants to keep everything in our existing Postgres instance and just use recursive CTEs or LTREE to avoid adding another operational dependency to our stack.
For those who picked Neo4j for a similar feature: did the maintenance overhead (syncing data with your primary DB, backups, monitoring) end up being worth the clean query syntax? Or did you end up wishing you had just stuck with relational?
r/Neo4j • u/joslatzrh • Oct 22 '26
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?
r/Neo4j • u/Historical_Ad4384 • Oct 19 '26
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.
r/Neo4j • u/Middle-Sky171 • Oct 04 '26
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.
r/Neo4j • u/rahoo_reddit • Sep 23 '26
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.
r/Neo4j • u/lomakin_andrey • Sep 16 '26
r/Neo4j • u/camerongreen95 • Sep 15 '26
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.
r/Neo4j • u/manishshakya007 • Aug 17 '26
r/Neo4j • u/Nice-Rest-8267 • Aug 13 '26
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.
r/Neo4j • u/No-Candy-2185 • Aug 12 '26
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.
r/Neo4j • u/Alone_Cauliflower308 • Aug 10 '26
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
r/Neo4j • u/stixmike • Aug 10 '26
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?
r/Neo4j • u/CeleryPotential1856 • Aug 04 '26
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:
Anyone here using neo4j as primary database?
Is it still a secondary DB?
What is your experience using Neo4J ?
Thanks in advance
r/Neo4j • u/GroundbreakingFun336 • Jul 26 '26
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.
r/Neo4j • u/Zoinkfwip • Jul 20 '26
r/Neo4j • u/Ok_Respect_3503 • Jul 17 '26
r/Neo4j • u/lgarulli • Jul 14 '26
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.)
r/Neo4j • u/Worth-Winner2609 • Jun 19 '26
r/Neo4j • u/mateus_evangelista • Jun 17 '26
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.
r/Neo4j • u/ostwal • Jun 16 '26
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.