# The Knowledge Graph Mullet: Trimming GraphRAG Complexity

William Lyon, Hypermode | AI Engineer World's Fair 2025 | 32:52

Source: https://www.youtube.com/watch?v=tYCu_57jzL8
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/the-knowledge-graph-mullet-trimming-graphrag-complexity
Published: 2025-06-03
Tags: mcp, rag, tool-use

## TL;DR
- A knowledge graph can expose a property graph interface while storing data as RDF triples, combining easier traversal with scalable storage.
- GraphRAG starts with vector, geographic, or image search, then traverses a domain graph to gather related context for a model.
- Dgraph's MCP server lets models inspect schemas, generate queries, mutate data, and work with graph tools, while Modus provides orchestration for longer-running agents.

## Summary
William Lyon presents the "knowledge graph mullet": property graphs in the front and RDF triples in the back. He argues that Dgraph combines the property graph model for data modeling and querying with RDF as its interchange format and smallest unit of record. The talk uses a news knowledge graph to show how vector search can find relevant text chunks, while graph traversal connects those chunks to articles, topics, organizations, and geographic areas. Lyon then demonstrates DQL queries, geographic search, vector search, graph visualization, and Dgraph's MCP server. MCP allows models such as Claude to inspect schemas, write DQL, load data, verify mutations, and explore graph relationships. The final section connects Dgraph with Modus, an open-source agent orchestration framework, and Hypermode Agents, where a prompt and MCP connections can create an agent that works with GitHub and Notion. The demos also show where model-generated queries need correction.

## Key ideas
### A hybrid graph uses a property graph interface with RDF storage
[00:46](https://www.youtube.com/watch?v=tYCu_57jzL8&t=46s)
Lyon's central analogy puts the property graph "in the front" and RDF triples "in the back." Property graphs make nodes, relationship types, labels, and key-value properties easy to model and query. RDF contributes a triple-based representation built from subject, predicate, and object. Dgraph combines these choices: applications use the property graph model for data modeling and querying, while RDF supports data interchange and triples remain the smallest unit of record. Lyon presents this as a way to expose a familiar graph interface while using the scalability of RDF triples underneath.

### Knowledge graphs describe entities and their meaning
[02:43](https://www.youtube.com/watch?v=tYCu_57jzL8&t=163s)
Lyon defines a knowledge graph as an instance of a property graph. Nodes can have labels that group them by type, relationships have a type and direction, and nodes or relationships can carry arbitrary key-value properties. The data model also captures semantics. A graph can state that a talk has a topic or was presented at a conference, rather than recording only that two opaque strings are related. Lyon connects this to Google's 2012 description of a knowledge graph as being about "things, not strings." A canonical representation of the thing is central to his definition.

### Dgraph maps graph elements onto triples and posting lists
[05:17](https://www.youtube.com/watch?v=tYCu_57jzL8&t=317s)
To model a property graph as RDF triples, Dgraph gives every node a unique ID. That ID points to the node and maps to an offset on disk, which supports graph traversal. The node ID becomes the triple subject. A predicate expresses either a relationship or a property. A relationship points to another node ID, while a property points to a value. Dgraph also uses posting lists, which group a predicate with the unique IDs of nodes connected through it. Lyon says this organization allows efficient traversal while retaining the triple-based storage model.

### GraphRAG uses search as an entry point and traversal for context
[08:56](https://www.youtube.com/watch?v=tYCu_57jzL8&t=536s)
In Lyon's news example, articles connect to authors, topics, organizations, geographic areas, images, and paragraph chunks. Each chunk gets an embedding stored as a node property, so vector similarity search can find a starting point. GraphRAG then traverses from matching chunks to articles, relevant topics, and other articles sharing topics or organizations. Other entry points can include a geospatial index, such as finding news within 50 kilometers of New York City, or image similarity search. Lyon describes this as combining a lexical graph for unstructured content with a domain graph that supplies related context.

### DQL expresses both returned fields and graph traversal
[13:01](https://www.youtube.com/watch?v=tYCu_57jzL8&t=781s)
DQL queries begin with a defined root criterion, often using an index to find starting nodes. A nested selection set then specifies the properties to return and the paths to traverse. Like GraphQL, DQL returns JSON shaped according to that selection set. Lyon's Dgraph examples count articles, find topics connected to the first ten articles, filter articles by publication date, search geographic areas near New York City, and combine vector matches with traversals through topics. Rattell provides a query workbench where these queries can be run and their results visualized as a graph.

### Dgraph's MCP server gives models database tools
[15:44](https://www.youtube.com/watch?v=tYCu_57jzL8&t=944s)
Dgraph exposes an MCP server for each instance. Its read-only endpoint lets a model execute queries and inspect the schema. The full endpoint also supports mutations and schema changes. Lyon shows this through Hypermode, Claude, and an e-commerce graph containing customers, products, and orders. Claude first inspects the empty database, generates a schema, creates data with mutations, and runs queries to verify the result. When it finds missing relationships, it generates another mutation to add them. Lyon describes this as a practical way to learn graph tooling because the model handles initial query generation while the user can inspect the resulting DQL.

### Model-generated graph work needs verification and iteration
[20:37](https://www.youtube.com/watch?v=tYCu_57jzL8&t=1237s)
The MCP demo does not present model-generated queries as automatically correct. Claude checks whether the database contains what it expected and discovers missing relationships in the generated data. Later, when Claude generates product recommendation queries using collaborative filtering, content-based recommendations, and demographic information, one approach produces an error. Claude iterates until it gets expected results. The final HTML report includes the different recommendation approaches, their results, and the DQL query used for each. The example shows both the convenience of database tools for models and the need to inspect their work.

### Modus and Hypermode Agents connect graph tools to agent workflows
[24:05](https://www.youtube.com/watch?v=tYCu_57jzL8&t=1445s)
Lyon says Dgraph provides the knowledge graph and MCP exposes tools, but agent orchestration is still needed. Modus is an open-source framework with abstractions for models, data, agentic flows, and a runtime for stateful, long-running agents. It uses WebAssembly to support SDKs for languages such as Go and AssemblyScript, then generates a unified GraphQL API from the application's types and function signatures. Hypermode Agents builds on this approach. In the demo, an agent receives a prompt, connects to GitHub, Notion, and company documentation through MCP servers, analyzes the Hypernews repository, adds code snippets to social posts, and saves them to a Notion scratchpad. The agent can then eject to Modus code for further customization.

## Notable quotes
- "The knowledge graph mullet, which is all about property graph in the front and RDF triples in the back." (00:46)
- "We're talking about things, not strings." (03:23)
- "But in graph rag, that's just the starting point." (11:23)
- "Fundamentally, MCP is a way of exposing tools to models." (16:40)
- "Claude doesn't always get the queries right." (22:43)

## Tools & references mentioned
- Dgraph
- Hypermode
- Modus
- Hypermode Agents
- Rattell
- RDF
- GraphQL
- DQL
- MCP
- Claude
- Anthropic
- DeepLearning.AI
- Windsurf
- Cursor
- GitHub
- Notion
- Google Knowledge Graph
- Google Spanner
- hyper-news

## Who should watch
- You are building GraphRAG and need a data model that connects vector retrieval with structured traversal.
- Your application needs a model to inspect or query a graph database through MCP, with checks around generated mutations and queries.
- You want to understand how a knowledge graph, an agent runtime, and external MCP connections fit together in an agent application.

## Related talks

- [Practical GraphRAG: Making LLMs Smarter with Knowledge Graphs](https://aietalks.com/talks/practical-graphrag-making-llms-smarter-with-knowledge-graphs) (Michael Hunger, Jesús Barrasa & Stephen Chin, Neo4j, 19:46)
- [GraphRAG: The Marriage of Knowledge Graphs and RAG](https://aietalks.com/talks/graphrag-the-marriage-of-knowledge-graphs-and-rag) (Emil Eifrem, Neo4j, 19:15)
- [Agentic GraphRAG: Simplifying Retrieval Across Structured and Unstructured Data](https://aietalks.com/talks/agentic-graphrag-simplifying-retrieval-across-structured-and-unstructured-data) (Zach Blumenfeld, Neo4j, 15:25)
- [Intro to GraphRAG](https://aietalks.com/talks/intro-to-graphrag) (Zach Blumenfeld, Neo4j, 1:18:35)
- [GraphRAG](https://aietalks.com/talks/graphrag) (Mitesh, NVIDIA & Ching Kyong Lamb, PO.AI & Daniel Chalev, Zep & Mark Bane & Vasilia Marovitz, Cognify & Alex Gilmore, Neo4j & Ola Mabad, Cisco & Michael Hunger & Steven Shen, Neo4j & Tom Smoker, YAL.ai, 4:08:05)