In this blog, we will build a knowledge graph for product recommendations using taxonomy and complementary taxonomy. <a href="https://github.com/cocoindex-io/cocoindex" target="_blank" rel="noopener nofollow">CocoIndex</a> makes it easy to build and maintain knowledge graphs with continuous source updates.
<img src="https://media.daily.dev/image/upload/s--ZTPTz8ZS--/f_auto/v1746680123/ugc/content_8ace9252-302c-44d4-8927-d4ca5e9c4c8c?_a=BAMClqUq0" alt="product-graph">
Product taxonomy is a way to organize product catalogs in a logical and hierarchical structure; a great detailed explanation can be found <a href="https://help.shopify.com/en/manual/products/details/product-category" target="_blank" rel="noopener nofollow">here</a>. In practice, it is a complicated problem: a product can be part of multiple categories, and a category can have multiple parents.
We will use LLM to extract a list of taxonomies from product descriptions. We will also use LLM to generate a list of complementary taxonomies for each product - for example, when someone buys a notepad, they may also buy a pen as a complementary product. We’ll use Knowledge Graph to explore the relationships between products that can be further used for product recommendations or labeling.
The source code is available at <a href="https://github.com/cocoindex-io/cocoindex/tree/main/examples/product_taxonomy_knowledge_graph" target="_blank" rel="noopener nofollow">CocoIndex Examples - product_taxonomy</a>.
We are constantly improving, and more features and examples are coming soon.
Stay tuned and follow our progress by starring our <a href="https://github.com/cocoindex-io/cocoindex" target="_blank" rel="noopener nofollow">GitHub repo</a>.
<a href="https://github.com/cocoindex-io/cocoindex" target="_blank" rel="noopener nofollow"><img src="https://img.shields.io/github/stars/cocoindex-io/cocoindex?color=5B5BD6" alt="GitHub"></a>
<h2>Data flow to build knowledge graph</h2>
<h3>Overview</h3>
<img src="https://media.daily.dev/image/upload/s--ETpPkk8_--/f_auto/v1746680264/ugc/content_d10c3f0a-c838-41ed-8579-043d7bc4c4f7?_a=BAMClqUq0" alt="overview">
The core flow is about <a href="https://github.com/cocoindex-io/cocoindex/blob/1d42ab31692c73743425f7712c9af395ef98c80e/examples/product_taxonomy_knowledge_graph/main.py#L75-L177" target="_blank" rel="noopener nofollow">~100 lines of python code</a>
<h3>Add documents as source</h3>
<pre><code class="language-python">@cocoindex.flow_def(name=&quot;StoreProduct&quot;)
def store_product_flow(flow_builder: cocoindex.FlowBuilder, data_scope: cocoindex.DataScope):
 data_scope[&quot;products&quot;] = flow_builder.add_source(
 cocoindex.sources.LocalFile(path=&quot;products&quot;,
 included_patterns=[&quot;*.json&quot;]),
 refresh_interval=datetime.timedelta(seconds=5))
</code></pre>
Here <code>flow_builder.add_source</code> creates a <a href="https://cocoindex.io/docs/core/data_types#KTable" target="_blank" rel="noopener nofollow">KTable</a>.
<code>filename</code> is the key of the KTable.
<img src="https://media.daily.dev/image/upload/s--XXDvQHQN--/f_auto/v1746680307/ugc/content_ad8b749e-24b2-46cc-aa9e-231c1d642147?_a=BAMClqUq0" alt="ingestion">
<h3>Process each product</h3>
We will parse the JSON file for each product, and transform the data to the format that we need for downstream processing.
<h4>Data Mapping</h4>
<pre><code class="language-python">@cocoindex.op.function(behavior_version=2)
def extract_product_info(product: cocoindex.typing.Json, filename: str) -&gt; ProductInfo:
 return ProductInfo(
 id=f&quot;{filename.removesuffix(&#x27;.json&#x27;)}&quot;,
 url=product[&quot;source&quot;],
 title=product[&quot;title&quot;],
 price=float(product[&quot;price&quot;].lstrip(&quot;$&quot;).replace(&quot;,&quot;, &quot;&quot;)),
 detail=Template(PRODUCT_TEMPLATE).render(**product),
 )
</code></pre>
Here we define a function for data mapping, e.g.,
<ul>
<li>clean up the <code>id</code> field</li>
<li>map <code>title</code> -&gt; <code>title</code></li>
<li>clean up the <code>price</code> field</li>
<li>generate a markdown string for the product detail</li>
</ul>
<h4>Flow</h4>
Within the flow, we plug in the data mapping transformation to process each product JSON.
<pre><code class="language-python">with data_scope[&quot;products&quot;].row() as product:
 data = (product[&quot;content&quot;]
 .transform(cocoindex.functions.ParseJson(), language=&quot;json&quot;)
 .transform(extract_product_info, filename=product[&quot;filename&quot;]))
 product_node.collect(id=data[&quot;id&quot;], url=data[&quot;url&quot;], title=data[&quot;title&quot;], price=data[&quot;price&quot;])
</code></pre>
<ol>
<li>The first <code>transform()</code> parses the JSON file.</li>
<li>The second <code>transform()</code> performs the defined data mapping.</li>
<li>We collect the fields we need for the product node in Neo4j.</li>
</ol>
<img src="https://media.daily.dev/image/upload/s--auMcDV2A--/f_auto/v1746680355/ugc/content_1681bd1b-3305-4296-a9f6-95f2602a7f01?_a=BAMClqUq0" alt="mapping">
<h2>Extract taxonomy and complementary taxonomy using LLM</h2>
<h4>Product Taxonomy Definition</h4>
Since we are using LLM to extract product taxonomy, we need to provide a detailed instruction at the class-level docstring.
<pre><code class="language-python">@dataclasses.dataclass
class ProductTaxonomy:
 &quot;&quot;&quot;
 Taxonomy for the product.
 
 A taxonomy is a concise noun (or short noun phrase), based on its core functionality, without specific details such as branding, style, etc.
 &quot;&quot;&quot;
 name: str
</code></pre>
<h4>Define Product Taxonomy Info</h4>
<pre><code class="language-python">@dataclasses.dataclass
class ProductTaxonomyInfo:
 &quot;&quot;&quot;
 Taxonomy information for the product.

 Fields:
 - taxonomies: Taxonomies for the current product.
 - complementary_taxonomies: Think about when customers buy this product, what else they might need as complementary products. 
 &quot;&quot;&quot;
 taxonomies: list[ProductTaxonomy]
 complementary_taxonomies: list[ProductTaxonomy]
</code></pre>
For each product, we want some insight about its taxonomy and complementary taxonomy and we could use that as bridge to find related product using knowledge graph.
<h4>LLM Extraction</h4>
Finally, we will use <code>cocoindex.functions.ExtractByLlm</code> to extract the taxonomy and complementary taxonomy from the product detail.
<pre><code class="language-python">taxonomy = data[&quot;detail&quot;].transform(cocoindex.functions.ExtractByLlm(
 llm_spec=cocoindex.LlmSpec(
 api_type=cocoindex.LlmApiType.OPENAI, model=&quot;gpt-4.1&quot;),
 output_type=ProductTaxonomyInfo))
</code></pre>
<img src="https://media.daily.dev/image/upload/s--UPKtdx2k--/f_auto/v1746680389/ugc/content_51aee644-e536-4452-aa03-5cbfc568a5d6?_a=BAMClqUq0" alt="llm-extraction-pen">
For example, LLM takes the description of the gel pen, and extracts taxonomy to be gel pen.
Meanwhile, it suggests that when people buy gel pen, they may also be interested in notebook etc as complimentary taxonomy.
And then we will collect the taxonomy and complementary taxonomy to the collector.
<pre><code class="language-python">with taxonomy[&#x27;taxonomies&#x27;].row() as t:
 product_taxonomy.collect(id=cocoindex.GeneratedField.UUID, product_id=data[&quot;id&quot;], taxonomy=t[&quot;name&quot;])
with taxonomy[&#x27;complementary_taxonomies&#x27;].row() as t:
 product_complementary_taxonomy.collect(id=cocoindex.GeneratedField.UUID, product_id=data[&quot;id&quot;], taxonomy=t[&quot;name&quot;])
</code></pre>
<h3>Build knowledge graph</h3>
<h4>Basic concepts</h4>
All nodes for Neo4j need two things:
<ol>
<li>Label: The type of the node. E.g., <code>Product</code>, <code>Taxonomy</code>.</li>
<li>Primary key field: The field that uniquely identifies the node. E.g., <code>id</code> for <code>Product</code> nodes.</li>
</ol>
CocoIndex uses the primary key field to match the nodes and deduplicate them. If you have multiple nodes with the same primary key, CocoIndex keeps only one of them.
<img src="https://media.daily.dev/image/upload/s--CnwMMk5Q--/f_auto/v1746680440/ugc/content_1fdc11b0-caa7-4d9c-a981-7ea65aad4f56?_a=BAMClqUq0" alt="dedupe">
There are two ways to map nodes:
<ol>
<li>When you have a collector just for the node, you can directly export it to Neo4j. For example <code>Product</code>. We’ve collected each product explicitly.</li>
<li>When you have a collector for relationships connecting to the node, you can map nodes from selected fields in the relationship collector. You must declare a node label and primary key field.</li>
</ol>
For example,
<pre><code class="language-python">product_taxonomy.collect(id=cocoindex.GeneratedField.UUID, product_id=data[&quot;id&quot;], taxonomy=t[&quot;name&quot;])
</code></pre>
Collects a relationship, and taxonomy node is created from the relationship.
<h4>Export <code>Product</code> nodes to Neo4j</h4>
<pre><code class="language-python">product_node.export(
 &quot;product_node&quot;,
 cocoindex.storages.Neo4j(
 connection=conn_spec,
 mapping=cocoindex.storages.Nodes(label=&quot;Product&quot;)
 ),
 primary_key_fields=[&quot;id&quot;],
)
</code></pre>
<img src="https://media.daily.dev/image/upload/s--ITFQgPQ_--/f_auto/v1746680492/ugc/content_d96bc957-6b66-41ed-b98b-12ed239f27c2?_a=BAMClqUq0" alt="export-product">
<h4>Export <code>Taxonomy</code> nodes to Neo4j</h4>
To export them as Neo4j nodes, we need to first declare <code>Taxonomy</code> nodes.
<pre><code class="language-python">flow_builder.declare(
 cocoindex.storages.Neo4jDeclaration(
 connection=conn_spec,
 nodes_label=&quot;Taxonomy&quot;,
 primary_key_fields=[&quot;value&quot;],
 )
)
</code></pre>
Next, export the <code>product_taxonomy</code> as relationship to Neo4j.
<pre><code class="language-python">product_taxonomy.export(
 &quot;product_taxonomy&quot;,
 cocoindex.storages.Neo4j(
 connection=conn_spec,
 mapping=cocoindex.storages.Relationships(
 rel_type=&quot;PRODUCT_TAXONOMY&quot;,
 source=cocoindex.storages.NodeFromFields(
 label=&quot;Product&quot;,
 fields=[
 cocoindex.storages.TargetFieldMapping(
 source=&quot;product_id&quot;, target=&quot;id&quot;),
 ]
 ),
 target=cocoindex.storages.NodeFromFields(
 label=&quot;Taxonomy&quot;,
 fields=[
 cocoindex.storages.TargetFieldMapping(
 source=&quot;taxonomy&quot;, target=&quot;value&quot;),
 ]
 ),
 ),
 ),
 primary_key_fields=[&quot;id&quot;],
)
</code></pre>
<img src="https://media.daily.dev/image/upload/s--Vd4OpYI---/f_auto/v1746680634/ugc/content_bfe4c928-bbeb-4e3c-be7e-c237e897993f?_a=BAMClqUq0" alt="export-taxonomy">
Then export complementary taxonomy similarly
<img src="https://media.daily.dev/image/upload/s--EGIBU0GB--/f_auto/v1746680705/ugc/content_ef4a2910-643b-417f-b8d1-d359b67dd82a?_a=BAMClqUq0" alt="export-complementary">
<h3>Browse the knowledge graph</h3>
You can explore the knowledge graph in Neo4j Browser.
<img src="https://media.daily.dev/image/upload/s--q5EbcPN3--/f_auto/v1746680800/ugc/content_10ba1c0e-0456-4a7a-b8af-5980a393a8c0?_a=BAMClqUq0" alt="product-graph">
If you love this article, please give us a star at <a href="https://github.com/cocoindex-io/cocoindex" target="_blank" rel="noopener nofollow">GitHub repo</a>.

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

Learn how to build a knowledge graph for product recommendations using product taxonomy and complementary taxonomy. This approach uses LLMs to extract and map product-related data for enhanced insights and recommendations, supported by CocoIndex software with integration to Neo4j for visualization.

Real-Time Knowledge Graph for Product insights with LLM taxonomy understanding