<a href="https://github.com/cocoindex-io/cocoindex" target="_blank" rel="noopener nofollow">CocoIndex</a> now provides native support for <a href="https://github.com/kuzudb/kuzu" target="_blank" rel="noopener nofollow">Kuzu</a> as a target graph data store.
This integration features a high performance knowledge graph stack with real-time updates.
The entire stack is completely open source, from data ingestion, transformation to graph db and query + graph db explorers.
<img src="https://media.daily.dev/image/upload/s--u9XAdgxb--/f_auto/v1749012090/ugc/content_6fd8751f-7425-4dfe-ac6a-a0702564cbfc?_a=BAMClqUq0" alt="cover">
<h2>What is Kuzu</h2>
<a href="https://github.com/kuzudb/kuzu" target="_blank" rel="noopener nofollow">Kuzu</a> is a graph database that is designed to be fast, scalable, and easy to use.
We love Kuzu because it is high performant, lightweight, and open source.
CocoIndex is an ultra performant real-time data transformation framework,
with dataflow programming model, CocoIndex simplifies building and maintaining knowledge graphs with continuous source updates.
You can read the official CocoIndex Documentation for Property Graph Targets <a href="https://cocoindex.io/docs/ops/storages#property-graph-targets" target="_blank" rel="noopener nofollow">here</a>.
We understand preparing data is highly use-case based and there is no one-size-fits-all solution.
We take the composition approach, and instead of building everything, we provide native plugins to embrace the ecosystem and make it easier to plug in and swap any module by standardizing the interface - exactly like LEGO.
If you are using CocoIndex to build your knowledge graph, you can use Kuzu as a target graph data store.
<h2>How to map to Kuzu in CocoIndex</h2>
The GraphDB interface in CocoIndex is standardized, if you are already using Neo4j, you just need to switch the configuration to export to Kuzu as below.
CocoIndex supports exporting to Kuzu through its API server. You can bring up a Kuzu API server locally by running:
<pre><code class="language-bash">KUZU_DB_DIR=$HOME/.kuzudb
KUZU_PORT=8123
docker run -d --name kuzu -p ${KUZU_PORT}:8000 -v ${KUZU_DB_DIR}:/database kuzudb/api-server:latest
</code></pre>
In your CocoIndex flow, you need to add the Kuzu connection spec to your flow.
<pre><code class="language-python">kuzu_conn_spec = cocoindex.add_auth_entry(
 &quot;KuzuConnection&quot;,
 cocoindex.storages.KuzuConnection(
 api_server_url=&quot;http://localhost:8123&quot;,
 ),
)
</code></pre>
<h2>What does it look like to build an indexing flow with CocoIndex + Kuzu</h2>
A CocoIndex knowledge graph example that got the most love is to build knowledge graph with LLM, here is a detailed <a href="https://cocoindex.io/blogs/knowledge-graph-for-docs" target="_blank" rel="noopener nofollow">step-by-step blog</a>.
In the project, we process a list of documents,and use LLM to extract relationships between the concepts in each document.
<img src="https://media.daily.dev/image/upload/s--bRrcrEv3--/f_auto/v1749012281/ugc/content_cbe23965-7e1c-41f8-902f-7b36a97e9ba8?_a=BAMClqUq0" alt="kg-extraction">
We will generate two kinds of relationships from the documents:
<ol>
<li>Relationships between subjects and objects. E.g., “CocoIndex supports Incremental Processing”</li>
<li>Mentions of entities in a document. E.g., “core/basics.mdx” mentions CocoIndex and Incremental Processing.</li>
</ol>
The indexing flow looks like this for Kuzu:
<img src="https://media.daily.dev/image/upload/s--scr4U60D--/f_auto/v1749012295/ugc/content_e6bfd280-c960-41de-9937-83ee6c3d26ee?_a=BAMClqUq0" alt="flow">
The code is available <a href="https://github.com/cocoindex-io/cocoindex/tree/main/examples/docs_to_knowledge_graph" target="_blank" rel="noopener nofollow">here</a>.
<ol>
<li>Ingest the documents into CocoIndex</li>
<li>Process the documents, for each document:
<ol>
<li>Map document nodes: Use LLM to generate summary, and map the documents to Graph nodes in Kuzu.</li>
<li>Map relationship nodes: Use LLM to extract relationships, and export the relationships to Kuzu.</li>
</ol>
</li>
</ol>
Notably, it only takes ~200 lines of python to have a production ready knowledge graph; including class definitions, prompts, and configs.
To highlight how the relationship extraction works, you will define a python class for structured extraction.
<pre><code class="language-python">@dataclasses.dataclass
class Relationship:
 &quot;&quot;&quot;
 Describe a relationship between two entities.
 Subject and object should be Core CocoIndex concepts only, should be nouns. For example, `CocoIndex`, `Incremental Processing`, `ETL`, `Data` etc.
 &quot;&quot;&quot;

 subject: str
 predicate: str
 object: str
</code></pre>
If you have a predefined set of ontology, you can skip the entity extraction use existing entities.
Call a transformation in the flow to extract the relationships from the document.
<pre><code class="language-python">with data_scope[&quot;documents&quot;].row() as doc:
 
 # extract relationships from document
 doc[&quot;relationships&quot;] = doc[&quot;content&quot;].transform(
 cocoindex.functions.ExtractByLlm(
 llm_spec=cocoindex.LlmSpec(
 # Supported LLM: https://cocoindex.io/docs/ai/llm
 api_type=cocoindex.LlmApiType.OPENAI,
 model=&quot;gpt-4o&quot;,
 ),
 output_type=list[Relationship],
 instruction=(
 &quot;Please extract relationships from CocoIndex documents. &quot;
 &quot;Focus on concepts and ignore examples and code. &quot;
 ),
 )
 )
</code></pre>
You could use CocoInsight to verify each pair of the relationships.
<img src="https://media.daily.dev/image/upload/s--ojx-YGtW--/f_auto/v1749012314/ugc/content_32f38cf5-9b73-4409-84b2-4939c316b884?_a=BAMClqUq0" alt="cocoinsight">
and then collect the relationship use <code>entity_relationship</code> collector.
<pre><code class="language-python">with doc[&quot;relationships&quot;].row() as relationship:
 # relationship between two entities
 entity_relationship.collect(
 id=cocoindex.GeneratedField.UUID,
 subject=relationship[&quot;subject&quot;],
 object=relationship[&quot;object&quot;],
 predicate=relationship[&quot;predicate&quot;],
 )
</code></pre>
CocoIndex follows a dataflow programming model.
Rather than defining data operations like creations, updates or deletions, developers only need to focus on transformations or formulas based on source data.
The framework takes care of the data operations such as when to create, update, or delete.
Once you have collected the relationships, you can directly map it to Kuzu as below.
<pre><code class="language-python"> entity_relationship.export(
 &quot;entity_relationship&quot;,
 cocoindex.storages.Kuzu(
 connection=conn_spec,
 mapping=cocoindex.storages.Relationships(
 rel_type=&quot;RELATIONSHIP&quot;,
 source=cocoindex.storages.NodeFromFields(
 label=&quot;Entity&quot;,
 fields=[
 cocoindex.storages.TargetFieldMapping(
 source=&quot;subject&quot;, target=&quot;value&quot;
 ),
 ],
 ),
 target=cocoindex.storages.NodeFromFields(
 label=&quot;Entity&quot;,
 fields=[
 cocoindex.storages.TargetFieldMapping(
 source=&quot;object&quot;, target=&quot;value&quot;
 ),
 ],
 ),
 ),
 ),
 primary_key_fields=[&quot;id&quot;],
 )
</code></pre>
Amazingly, while working on this Kuzu example, I had a previous <a href="https://github.com/cocoindex-io/cocoindex/tree/main/examples/docs_to_knowledge_graph" target="_blank" rel="noopener nofollow">flow</a> that I ran locally with Neo4j.
It was instant to export to Kuzu. CocoIndex is based on incremental processing, and if you have already run this flow before and just switched targets, the intermediate transformation results can be reused.
To run the <a href="https://github.com/kuzudb/explorer" target="_blank" rel="noopener nofollow">Kuzu Explorer</a> - an open source UI for Kuzu, you need to first bring down the Kuzu API server.
And then you can run the following command to start the Kuzu Explorer:
<pre><code class="language-bash">KUZU_EXPLORER_PORT=8124
docker run -d --name kuzu-explorer -p ${KUZU_EXPLORER_PORT}:8000 -v ${KUZU_DB_DIR}:/database -e MODE=READ_ONLY kuzudb/explorer:latest
</code></pre>
We could then access the explorer at <a href="http://localhost:8124" target="_blank" rel="noopener nofollow">http://localhost:8124</a>. We could run a Cypher query to explore the graph.
<pre><code class="language-cypher">MATCH p=()--&gt;() RETURN p
</code></pre>
<img src="https://media.daily.dev/image/upload/s--6Tollse_--/f_auto/v1749012361/ugc/content_720671ec-64a1-4bc3-98eb-a0d5ebdc358f?_a=BAMClqUq0" alt="kuzu-explorer">
<h2>Support us</h2>
We are constantly improving, and more features and examples are coming soon. If this article is helpful, please drop us a star ⭐ at <a href="https://github.com/cocoindex-io/cocoindex" target="_blank" rel="noopener nofollow">GitHub</a> to help us grow.
Thanks for reading!

The official daily.dev AI community. Led by thought leaders and AI experts. Stay tuned for insights, news and discussions. 

CocoIndex now supports Kuzu as a target graph database, creating a complete open-source stack for building high-performance knowledge graphs with real-time updates. The integration allows developers to use LLMs for extracting relationships from documents and storing them in Kuzu with just ~200 lines of Python code. The framework follows a dataflow programming model where developers focus on transformations while CocoIndex handles data operations automatically. The stack includes data ingestion, transformation, graph storage, and visualization tools, with seamless switching between different graph databases like Neo4j and Kuzu.

High performance real-time knowledge graph open source stack with LLM, Kuzu and CocoIndex

checkout - <a href="https://github.com/cocoindex-io/cocoindex" target="_blank" rel="noopener nofollow">https://github.com/cocoindex-io/cocoindex</a> :)