In the 8th century, as carpenters in Nara, Japan, labored to build the colossal Tōdai-ji temple, they faced a crisis. The heavy clay soil of the hillside was unstable. Every time the monsoon rains came, the earth would slide, undermining their foundations.
According to temple lore, a wise herbalist named Genzō offered a simple, cheap solution: plant a hairy, unremarkable vine called kuzu (Pueraria montana). The skeptical carpenters obeyed. Within two years, the vine's tuberous roots had grown as thick as a man’s arm, drilling 10 feet down and spreading laterally like a living net. The hillside held. The temple was completed.
This was the first "Kuzu Link"—not a digital connection, but an ecological and structural one. The plant had linked the loose soil into a unified, resilient system. For centuries, that was the vine's identity in Japan: a binder, a healer, and a source of kuzuko (kudzu starch) used in cooling teas and life-saving medicines.
Implementing Kuzu Link in your application is surprisingly straightforward. Below is a practical example using Python (the most common client). kuzu link
In the landscape of modern data architecture, graph databases excel at revealing relationships, while operational data typically resides in relational databases (PostgreSQL, MySQL) or data lakes (S3, Parquet). The challenge has always been synchronization—how to query relationships without the overhead of massive data duplication.
Kuzu Link represents the strategic capability within the Kuzu graph database to bridge this gap. Through its External Data Source Connectors, Kuzu allows users to "link" external data directly into the graph model, enabling a hybrid architecture where data lives elsewhere, but intelligence lives in the graph.
Place frequently traversed properties on the link itself rather than on the nodes. For example, if you often filter "friendships created after 2023," include that timestamp as a property on the [:KNOWS] relationship. Kuzu Link scans relationship columns sequentially, so selective filters on edges execute faster than post-filtering nodes. The Forgotten Link: How a Root Saved an
Kuzu Link supports projected adjacency lists—materialized views that store only a subset of relationship properties. For a dashboard that only needs link.count (e.g., number of transactions), create a projected link without the full transaction history. This reduces I/O dramatically.
Kuzu allows users to attach supported external databases (currently including PostgreSQL, MySQL, DuckDB, and SQLite) using a simple connection string.
Example Syntax:
ATTACH DB 'postgresql://user:pass@host:5432/my_db' AS my_external_db;
Once attached, the tables within the external database become accessible to the Kuzu query engine. This "links" the external system, allowing Kuzu to read metadata and plan queries that span across both local graph data and remote relational tables.
conn.execute("CREATE REL TABLE Follows (FROM User TO User, since INT64)")
Step 4: Insert Data
conn.execute("CREATE (u:User name: 'Alice', age: 30)")
conn.execute("CREATE (u:User name: 'Bob', age: 25)")
conn.execute("CREATE (u1:User name: 'Alice')-[f:Follows since: 2020]->(u2:User name: 'Bob')")
Step 5: Query Data
result = conn.execute("MATCH (u:User)-[f:Follows]->(v:User) RETURN u.name, v.name, f.since")
print(result.get_as_df())