Mapped Memgraph's dependency structure as 3 graphs: CMake, Ninja, and Conan. Useful split for finding architecture coupling, rebuild chokepoints, and third-party package risk in a large C++ codebase.
memgraph.com/blog/understan…
English
Marko Budiselić
381 posts
Marko Budiselić
@mbudiselicbuda
Computer scientist, software engineer and entrepreneur.
Republic of Croatia เข้าร่วม Şubat 2011
169 กำลังติดตาม207 ผู้ติดตาม
Showcase of @memgraphdb and how to get better AI procedural memory under skillinsight.io 💪🧠
#ai #skills #memory #graphs
Ante Javor@AnteJavor
We built the Graph of public skills -> skillinsight.io From a non-technical standpoint, Agent Skills are the procedural memory you keep in your head on how to solve a particular problem, which can be very valuable, whether you are aware of that or not. You are constantly adapting and changing that procedural memory since the task is usually not fully deterministic, hence it cannot be a script. Parallel to that, skills have caused some controversy for being a security vulnerability and hallucinated LLM brain fog, but more on that in the future. Staying on the positive side of things and ignoring the negatives for now, agent skills could hold all the operational knowledge, allowing agents to operate semi-autonomously or autonomously to solve the particular operational problem. An example of that would be compiling a Memgraph Rust query module, which is not an easy task since you need the environment, the Memgraph query module API dependency, and knowledge of how to actually do it. Most advanced LLMs, like Codex or Opus, succeed at this after many tries and failures. This is why we build skills for compiling and deploying C++, Rust, and Python query modules that let LLMs practically single-shot the whole process. Back to the topic of the graph of skills, what is the actuall problem here? So if you have hundreds or thousands of skills in your organisation, the question is: how are you going to maintain them, how will they learn and evolve, and how will agents access them? If the tool's API changes, so should the skills, which causes a cascade of events across the files. Then the question becomes: how are those connected and correlated? This is what graphs as a structure are built for, and this is what we in Memgraph are trying to solve from different angles. The graph of skills will serve as our test bench for running the evolution, traceability, and access to the skills, while improving @memgraphdb as the graph database that serves as a real-time context engine for AI.
English
Atomic GraphRAG 👀
What if the entire GraphRAG could run as one query instead of a chain of code steps?
Less orchestration, code, and prompt bloat.
More speed, control, and traceability.
Details: memgraph.com/blog/atomic-gr…
#GraphRAG #GenAI #LLM #GraphDatabase #Cypher @memgraphdb
English
@gudjon @_avichawla Hey @_avichawla and @gudjon - I'm the CTO of Memgraph. I just saw the question. I'd be happy to show and tell you more - would you be up for that?
English
This new graph DB is 496x faster than Neo4j!
(open-source)
Let me break down why:
A traditional graph DB stores two things: nodes (entities) and edges (relationships between them).
When you query a traditional graph DB, it traverses by "pointer chasing":
→ Start at a node
→ Follow a pointer to the connected node
→ Follow another pointer
→ Repeat
This is inherently sequential. One hop at a time. And as your graph grows, this gets painfully slow.
FalkorDB asks a different question:
What if we represent the entire graph as a matrix?
Here's how it works:
Imagine a simple grid. Rows are source nodes, columns are destination nodes.
If Mary follows Bob, you set position [Mary, Bob] = 1.
That's it. Your entire graph is now a matrix of 1s and 0s.
Let's call this the Follows matrix (F).
Here's where it gets interesting:
Finding who Mary’s friends follow? In a traditional graph DB, you hop twice: Mary → friends → friends’ friends.
But with matrices, you multiply the Follows matrix by itself: F × F = F².
This takes just one operation, and you’re done!
Similarly, a complex pattern like “A follows B, B likes C” becomes: Follows × Likes.
This means you can represent traversal as math operations.
Why this matters:
- Matrix operations have been optimized for 50+ years
- Modern hardware (CPUs/GPUs) is built to crunch matrices
- Operations run in parallel (pointer-chasing simply cannot)
While there are a few more optimizations involved (like using sparse matrices, written in C, etc.), this approach makes FalkorDB 496x faster than Neo4j.
The graphic below shows this difference clearly.
Traditional graph DBs go through Cypher QL → Pointer-Based Traversal, while FalkorDB uses a Matrix-Aware Planner that converts queries into matrix operations.
FalkorDB is built entirely on this principle:
- Native Redis module (in-memory, ultra-fast)
- Powered by GraphBLAS for sparse matrix operations
- Auto-translates Cypher queries into matrix algebra
This is hugely important for AI applications because…
Modern AI agents and RAG systems need to traverse complex relationships in real-time. When an agent reasons through a knowledge graph, connecting users to actions to outcomes, every millisecond of latency compounds.
Vector DBs capture semantic similarity. But they miss explicit relationships.
Knowledge graphs fill that gap.
And when your agent needs to perform multi-hop reasoning across thousands of connected entities, matrix-based traversal makes it easier to scale your AI application without running into latency bottlenecks.
FalkorDB is 100% open-source, and you can see the full implementation on GitHub and try it yourself.
I've shared a link to their GitHub repo in the replies.
GIF
English
Quick reminder about @memgraphdb Community Call today, join and learn more about the Atomic GraphRAG Pipelines at crowdcast.io/c/meet-atomic-… 👀
English
@MemgraphDB v3.8 is live 🚀 introducing Atomic GraphRAG! 👀
Now you can combine searches and knowledge graphs in a unified execution layer, the details under memgraph.com/blog/memgraph-…
Want to see it in action? Join crowdcast.io/c/meet-atomic-…
#GraphDB #GraphRAG #AI #Agents
English
Did some experiments on how much it costs to extract entities from text (without prior ontology), seems like by default (gpt_4o_mini, without parallelization, 3-4 paragraph pages) the cost per page is ~0.01 USD 👀 Does that sound right? 🤔
English
Marko Budiselić รีทวีตแล้ว
I just used Code-Graph to ingest the Linux Kernel into @memgraphdb. The knowledge graph has around a million graph entities representing code structure.
It would be interesting to see how much @rustlang will eat into the kernel over time. 🤔 🦀
English
Marko Budiselić รีทวีตแล้ว
Reading about Memgraph today.
Though, a lot of people use Neo4j, I feel Memgraph don't get the recognition it deserves.
Memgraph is created in C++ while Neo4j is in Java which makes it a faster alternative.
For faster query execution and a large number of nodes, Memgraph is clearly a winner.
English
A really nice, in-depth tech blog post about @memgraphdb wired.wasql.com/articles/memgr…
English
Marko Budiselić รีทวีตแล้ว
Finally! A RAG over code solution that actually works (open-source).
Naive chunking used in RAG isn't suited for code.
This is because codebases have long-range dependencies, cross-file references, etc., that independent text chunks just can't capture.
Graph-Code is a graph-driven RAG system that solves this.
It analyzes the Python codebase and builds knowledge graphs to enable natural language querying.
Key features:
- Deep code parsing to extract classes, functions, and relationships.
- Uses Memgraph to store the codebase as a graph.
- Parses pyproject to understand external dependencies.
- Retrieves actual source code snippets for found functions.
Find the repo in the replies!
English
A few days ago...
@iliazintchenko: "You can't vibe code a database."
Me: "Hold my beer." 🤣 Stay tuned for the next live stream! 👀
GIF
English
On the other hand, since it's super easy to generate new code, I can imagine one building a totally new app when requirements change, basically eliminating long-term software maintenance challenge 🤯
English
With the advanced LLM models and code gen tools like @cursor_ai, what's the future of VCS tools like git? 🤔
GIF
English
On the one hand, with many iterations, it's critical to have some environment to stage/rollback different code versions quickly 👀
English
The other day @memgraphdb did integration with @cognee_, take a look at the example under github.com/memgraph/ai-de… 👀 Also, @svpino under x.com/svpino/status/… explaind why graph are top shit for building agents 🤯
Santiago@svpino
Knowledge graphs are infinitely better than vector search for building the memory of AI agents. With five lines of code, you can build a knowledge graph with your data. When you see the results, you'll never go back to vector-mediocrity-land. Here is a quick video:
English
@memgraphdb v3.3 is out! -> #memgraph-v330---june-4th-2025" target="_blank" rel="nofollow noopener">memgraph.com/docs/release-n… Memgraph AI is also growing, check our github.com/memgraph/ai-to… 👀
English