text-minning-for-taxonomy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "from getpass import getpass\n",
    "import dotenv\n",
    "from dotenv import load_dotenv\n",
    "\n",
    "os.environ[\"LANGCHAIN_TRACING_V2\"] = \"true\"\n",
    "os.environ[\"LANGCHAIN_PROJECT\"] = \"Text-mining-for-taxonomy\"\n",
    "load_dotenv()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "import logging\n",
    "import operator\n",
    "from typing_extensions import Annotated, List, Optional, TypedDict\n",
    "\n",
    "logging.basicConfig(level=logging.WARNING)\n",
    "logger = logging.getLogger(\"tnt-llm\")\n",
    "\n",
    "class Doc(TypedDict):\n",
    "    id: str\n",
    "    content: str\n",
    "    summary: Optional[str]\n",
    "    explanation: Optional[str]\n",
    "    category: Optional[str]\n",
    "\n",
    "class TaxonomyGenerationState(TypedDict):\n",
    "    # The raw docs; we inject summaries within them in the first step\n",
    "    documents: List[Doc]\n",
    "    # Indices to be concise\n",
    "    minibatches: List[List[int]]\n",
    "    # Candidate Taxonomes (full trajectory)\n",
    "    clusters: Annotated[List[List[dict]], operator.add]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Summarize docs\n",
    "\n",
    "Chat logs can get quite long. Taxonomy generation step needs to see large, diverse minibatches to be able to adequately capture the distribution of categories. To ensure they can all fit efficiently into the context window, First summarize each chat log. Downstream steps will use these summaries instead of the raw doc content."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "from langchain import hub\n",
    "from langchain_openai import ChatOpenAI\n",
    "from langchain_core.output_parsers import StrOutputParser\n",
    "from langchain_core.runnables import RunnableConfig, RunnableLambda, RunnablePassthrough\n",
    "\n",
    "summary_prompt = hub.pull(\"wfh/tnt-llm-summary-generation\").partial(\n",
    "    summary_prompt=20, explanation_length=30\n",
    ")\n",
    "\n",
    "def parse_summary(xml_string: str) -> dict:\n",
    "    summary_pattern = r\"<summary>(.*?)</summary>\"\n",
    "    explanation_pattern = r\"<explanation>(.*?)</explanation>\"\n",
    "\n",
    "    summary_match = re.search(summary_pattern, xml_string, re.DOTALL)\n",
    "    explanation_match = re.search(explanation_pattern, xml_string, re.DOTALL)\n",
    "\n",
    "    summary = summary_match.group(1).strip() if summary_match else \"\"\n",
    "    explanation = explanation_match.group(1).strip() if explanation_match else \"\"\n",
    "\n",
    "    return {\"summary\": summary, \"explanation\": explanation}\n",
    "\n",
    "summary_llm_chain = (\n",
    "    summary_prompt\n",
    "    | ChatOpenAI(model=\"gpt-4o-mini\")\n",
    "    | StrOutputParser()\n",
    "    # Customise the tracking name for easier organization\n",
    ").with_config(run_name=\"GenerateSummary\")\n",
    "summary_chain = summary_llm_chain | parse_summary\n",
    "\n",
    "# Now combine as a \"map\" operation in a map-reduce chain \n",
    "# Input: state\n",
    "# Output: state U summaries\n",
    "# Processes docs in parallel\n",
    "def get_content(state: TaxonomyGenerationState):\n",
    "    docs = state['documents']\n",
    "    return [{\"content\": doc['content'], \"summary_length\": 20} for doc in docs]  # Adjust the summary_length value as needed\n",
    "\n",
    "\n",
    "map_step = RunnablePassthrough.assign(\n",
    "    summaries=get_content\n",
    "    # This effectively creates a \"map\" operation\n",
    "    # Note you can make this more robust by handling individual errors\n",
    "    | RunnableLambda(func=summary_chain.batch, afunc=summary_chain.abatch)\n",
    ")\n",
    "\n",
    "def reduce_summaries(combined: dict) -> TaxonomyGenerationState:\n",
    "    summaries = combined['summaries']\n",
    "    documents = combined['documents']\n",
    "    return {\n",
    "        \"documents\": [\n",
    "            {\n",
    "                \"id\": doc['id'],\n",
    "                \"content\": doc['content'],\n",
    "                \"summary\": summ_info['summary'],\n",
    "                \"explanation\": summ_info['explanation'],\n",
    "            }\n",
    "            for doc, summ_info in zip(documents, summaries)\n",
    "        ]\n",
    "    }\n",
    "map_reduce_chain = map_step | reduce_summaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Split into Minibatches\n",
    "\n",
    "Each minibatch contains a random sample of docs. This lets the flow identify inadequacies in the current taxonomy using new data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "def get_minibatches(state: TaxonomyGenerationState, config: RunnableConfig):\n",
    "    batch_size = config['configurable'].get(\"batch_size\", 200)\n",
    "    original = state['documents']\n",
    "    indices = list(range(len(original)))\n",
    "    random.shuffle(indices)\n",
    "    if len(indices) < batch_size:\n",
    "        return {\"minibatches\": [indices]}\n",
    "    \n",
    "    num_full_batches = len(indices) // batch_size\n",
    "\n",
    "    batches = [\n",
    "        indices[i * batch_size: (i+1) * batch_size] for i in range(num_full_batches)\n",
    "    ]\n",
    "    leftovers = len(indices) % batch_size\n",
    "    if leftovers:\n",
    "        last_batch = indices[num_full_batches * batch_size :]\n",
    "        elements_to_add = batch_size - leftovers\n",
    "        last_batch += random.sample(indices, elements_to_add)\n",
    "        batches.append(last_batch)\n",
    "\n",
    "    return {\"minibatches\": batches}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Taxonomy Generation Utilities"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Dict\n",
    "from langchain_core.runnables import Runnable\n",
    "\n",
    "def parse_taxa(output_text: str) -> Dict:\n",
    "    \"\"\"Extract the taxonomy from the generated output.\"\"\"\n",
    "    cluster_matches = re.findall(\n",
    "        r\"\\s*<id>(.*?)</id>\\s*<name>(.*?)</name>\\s*<description>(.*?)</description>\\s*\",\n",
    "        output_text,\n",
    "        re.DOTALL,\n",
    "    )\n",
    "    clusters = [\n",
    "        {'id': id.strip(), \"name\": name.strip(), \"description\": description.strip()}\n",
    "        for id, name, description in cluster_matches\n",
    "    ]\n",
    "    # We don't parse the explanation since it isn't used downstream\n",
    "    return {'clusters': clusters}\n",
    "\n",
    "def format_docs(docs: List[Doc]) -> str:\n",
    "    xml_table = \"<conversation>\\n\"\n",
    "    for doc in docs:\n",
    "        xml_table += f'<conv_summ id={doc[\"id\"]}>{doc[\"summary\"]}</conv_summ>\\n'\n",
    "    xml_table +=\"</conversation>\"\n",
    "    return xml_table\n",
    "\n",
    "def format_taxonomy(clusters):\n",
    "    xml = \"<cluster_table>\\n\"\n",
    "    for label in clusters:\n",
    "        xml += \"  <cluster>\\n\"\n",
    "        xml += f'    <id>{label[\"id\"]}</id>\\n'\n",
    "        xml += f'    <name>{label[\"name\"]}</name>\\n'\n",
    "        xml += f'    <description>{label[\"description\"]}</description>\\n'\n",
    "        xml += \"  </cluster>\\n\"\n",
    "    xml += \"</cluster_table>\"\n",
    "    return xml\n",
    "\n",
    "def invoke_taxonomy_chain(\n",
    "        chain: Runnable,\n",
    "        state: TaxonomyGenerationState,\n",
    "        config: RunnableConfig,\n",
    "        mb_indices: List[int],\n",
    ") -> TaxonomyGenerationState:\n",
    "    configurable = config['configurable']\n",
    "    docs = state['documents']\n",
    "    minibatch = [docs[idx] for idx in mb_indices]\n",
    "    data_table_xml = format_docs(minibatch)\n",
    "\n",
    "    previous_taxonomy = state['clusters'][-1] if state['clusters'] else []\n",
    "    cluster_table_xml = format_taxonomy(previous_taxonomy)\n",
    "\n",
    "    updated_taxonomy = chain.invoke(\n",
    "        {\"data_xml\": data_table_xml,\n",
    "         \"use_case\": configurable['use_case'],\n",
    "         \"cluster_table_xml\": cluster_table_xml,\n",
    "         \"suggestion_length\": configurable.get(\"suggestion_length\", 30),\n",
    "         \"cluster_name_length\": configurable.get(\"cluster_name_length\", 10),\n",
    "         \"cluster_description_length\": configurable.get(\"cluster_description_length\", 30),\n",
    "         \"explanation_length\": configurable.get(\"explanation_length\", 20),\n",
    "         \"max_num_clusters\": configurable.get(\"max_num_clusters\", 25),\n",
    "         }\n",
    "    )\n",
    "\n",
    "    return {\n",
    "        \"clusters\": [updated_taxonomy['clusters']],\n",
    "    }\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generate initial taxonomy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We will share an LLM for each step of the generate -> update -> review cycle\n",
    "taxonomy_generation_llm = ChatOpenAI(model=\"gpt-4o\")\n",
    "\n",
    "# Initial generation\n",
    "taxonomy_generation_prompt = hub.pull(\"wfh/tnt-llm-taxonomy-generation\").partial(\n",
    "    use_case='Generate the taxonomy that can be used to label the user intent in the conversation.',\n",
    ")\n",
    "\n",
    "taxa_gen_llm_chain = (\n",
    "    taxonomy_generation_prompt | taxonomy_generation_llm | StrOutputParser()\n",
    ").with_config(run_name='GenerateTaxonomy')\n",
    "\n",
    "generate_taxonomy_chain = taxa_gen_llm_chain | parse_taxa\n",
    "\n",
    "def generate_taxonomy(\n",
    "        state: TaxonomyGenerationState, config: RunnableConfig\n",
    ") -> TaxonomyGenerationState:\n",
    "    return invoke_taxonomy_chain(\n",
    "        generate_taxonomy_chain, state, config, state['minibatches'][0]\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Update Taxonomy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "taxonomy_update_prompt = hub.pull(\"wfh/tnt-llm-taxonomy-update\")\n",
    "\n",
    "taxa_update_llm_chain = (\n",
    "    taxonomy_update_prompt | taxonomy_generation_llm | StrOutputParser()\n",
    ").with_config(run_name='UpdateTaxonomy')\n",
    "\n",
    "update_taxonomy_chain = taxa_update_llm_chain | parse_taxa\n",
    "\n",
    "def update_taxonomy(\n",
    "        state: TaxonomyGenerationState, config: RunnableConfig\n",
    ") -> TaxonomyGenerationState:\n",
    "    which_mb = len(state['clusters']) % len(state['minibatches'])\n",
    "    return invoke_taxonomy_chain(\n",
    "        update_taxonomy_chain, state, config, state['minibatches'][which_mb]\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Review Taxonomy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "taxonomy_review_prompt = hub.pull(\"wfh/tnt-llm-taxonomy-review\")\n",
    "taxa_review_llm_chain = (\n",
    "    taxonomy_review_prompt | taxonomy_generation_llm | StrOutputParser()\n",
    ").with_config(run_name='ReviewTaxonomy')\n",
    "\n",
    "review_taxonomy_chain = taxa_review_llm_chain | parse_taxa\n",
    "\n",
    "def review_taxonomy(\n",
    "        state: TaxonomyGenerationState, config: RunnableConfig\n",
    ") -> TaxonomyGenerationState:\n",
    "    batch_size = config['configurable'].get(\"batch_size\", 200)\n",
    "    original = state['documents']\n",
    "    indices = list(range(len(original)))\n",
    "    random.shuffle(indices)\n",
    "    return invoke_taxonomy_chain(\n",
    "        review_taxonomy_chain, state, config, indices[:batch_size]\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define the Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langgraph.graph import StateGraph, START, END\n",
    "\n",
    "graph = StateGraph(TaxonomyGenerationState)\n",
    "graph.add_node(\"summarize\", map_reduce_chain)\n",
    "graph.add_node(\"get_minibatches\", get_minibatches)\n",
    "graph.add_node(\"generate_taxonomy\", generate_taxonomy)\n",
    "graph.add_node(\"update_taxonomy\", update_taxonomy)\n",
    "graph.add_node(\"review_taxonomy\", review_taxonomy)\n",
    "\n",
    "graph.add_edge('summarize', 'get_minibatches')\n",
    "graph.add_edge(\"get_minibatches\", \"generate_taxonomy\")\n",
    "graph.add_edge(\"generate_taxonomy\", 'update_taxonomy')\n",
    "\n",
    "def should_review(state: TaxonomyGenerationState) -> str:\n",
    "    num_minibatches = len(state['minibatches'])\n",
    "    num_revisions = len(state['clusters'])\n",
    "    if num_revisions < num_minibatches:\n",
    "        return \"update_taxonomy\"\n",
    "    return \"review_taxonomy\"\n",
    "graph.add_conditional_edges(\n",
    "    \"update_taxonomy\",\n",
    "    should_review,\n",
    "    # Optional (but required for the diagram to be drawn correctly below)\n",
    "    {\"update_taxonomy\": \"update_taxonomy\", 'review_taxonomy': \"review_taxonomy\"},\n",
    ")\n",
    "graph.add_edge('review_taxonomy', END)\n",
    "graph.add_edge(START, 'summarize')\n",
    "\n",
    "app = graph.compile()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Image\n",
    "\n",
    "Image(app.get_graph().draw_png())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Usage"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Download customer reviews for a products\n",
    "\n",
    "### Kaggle Credentials\n",
    "\n",
    "I don't want to use google drive here, so i decided to use Kaggle API to directly  download dataset from Kaggle competition page.\n",
    "For this:\n",
    "\n",
    "* First, you need to install the Kaggle API by running the following command in a code cell:   \n",
    "\n",
    "\n",
    "```\n",
    "!pip install kaggle\n",
    "```\n",
    "\n",
    "* Next, you need to download your Kaggle API key. To do this, go to your Kaggle account settings page, scroll down to the \"API\" section, and click on the \"Create New API Token\" button. This will download a JSON file with your Kaggle API credentials.  \n",
    "link: https://www.machinelearningmindset.com/kaggle-dataset-in-google-colab/\n",
    "\n",
    "\n",
    "* Upload your Kaggle API key to Jupyter Notebook by clicking on the \"Files\" tab on the left-hand side of the Colab interface, then click on \"Upload\" and select the JSON file containing your Kaggle API credentials.\n",
    "\n",
    "* Run the following commands in a code cell to authenticate the Kaggle API:\n",
    "\n",
    "\n",
    "```\n",
    "import os\n",
    "os.environ['KAGGLE_USERNAME'] = \"your_kaggle_username\"\n",
    "os.environ['KAGGLE_KEY'] = \"your_kaggle_api_key\"\n",
    "\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset URL: https://www.kaggle.com/datasets/nicapotato/womens-ecommerce-clothing-reviews\n",
      "License(s): CC0-1.0\n",
      "womens-ecommerce-clothing-reviews.zip: Skipping, found more recently modified local copy (use --force to force download)\n",
      "Unzipping  data...\n",
      "Unzipping complete.\n"
     ]
    }
   ],
   "source": [
    "# Downloading dataset from kaggle\n",
    "import os\n",
    "import random\n",
    "import shutil\n",
    "import requests\n",
    "import zipfile\n",
    "from pathlib import Path\n",
    "\n",
    "!kaggle datasets download -d nicapotato/womens-ecommerce-clothing-reviews\n",
    "\n",
    "\n",
    "\n",
    "# Unzip journey-springfield.zip\n",
    "with zipfile.ZipFile(\"womens-ecommerce-clothing-reviews.zip\", \"r\") as zip_ref:\n",
    "    print(\"Unzipping  data...\") \n",
    "    zip_ref.extractall()\n",
    "    print(\"Unzipping complete.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df  = pd.read_csv(\"./Womens Clothing E-Commerce Reviews.csv\", index_col=[0])\n",
    "\n",
    "# Function to create Doc objects\n",
    "def create_docs(df):\n",
    "    docs = []\n",
    "    for idx, row in df.iterrows():\n",
    "        doc_id = str(row['Clothing ID'])\n",
    "        review_text = row['Review Text']\n",
    "        doc = Doc(\n",
    "            id=doc_id,\n",
    "            content=f\"<human id={doc_id}>\\n{review_text}\\n</human>\",\n",
    "            summary=None,        # Placeholder, replace with actual summary logic\n",
    "            explanation=None,    # Placeholder, replace with actual explanation logic\n",
    "            category=None        # Placeholder, replace with actual category logic\n",
    "        )\n",
    "        docs.append(doc)\n",
    "    return docs\n",
    "\n",
    "# Create the docs\n",
    "docs = create_docs(df)\n",
    "docs_random = random.sample(docs, min(len(docs), 1000))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Invoke"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "from langchain.cache import InMemoryCache\n",
    "from langchain.globals import set_llm_cache\n",
    "\n",
    "set_llm_cache(InMemoryCache())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "summarize {'documents': [{'id' ...\n",
      "get_minibatches {'minibatches': [[7, ...\n",
      "generate_taxonomy {'clusters': [[{'id' ...\n",
      "update_taxonomy {'clusters': [[{'id' ...\n",
      "review_taxonomy {'clusters': [[{'id' ...\n"
     ]
    }
   ],
   "source": [
    "use_case = (\n",
    "    \"Generate the taxonomy that can be used both to label the user intent\"\n",
    "    \" as well as to identify any required documentation (references, how-tos, etc.)\"\n",
    "    \" that would benefit the user.\"\n",
    ")\n",
    "\n",
    "stream = app.stream(\n",
    "    {\"documents\": docs_random},\n",
    "    {\n",
    "        \"configurable\": {\n",
    "            \"use_case\": use_case,\n",
    "            # Optional:\n",
    "            \"batch_size\": 400,\n",
    "            \"suggestion_length\": 30,\n",
    "            \"cluster_name_length\": 10,\n",
    "            \"cluster_description_length\": 30,\n",
    "            \"explanation_length\": 20,\n",
    "            \"max_num_clusters\": 25,\n",
    "        },\n",
    "        # We batch summarize the docs. To avoid getting errors, we will limit the\n",
    "        # degree of parallelism to permit.\n",
    "        \"max_concurrency\": 2,\n",
    "    },\n",
    ")\n",
    "\n",
    "for step in stream:\n",
    "    node, state = next(iter(step.items()))\n",
    "    print(node, str(state)[:20] + \" ...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Final Result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'clusters': [[{'id': '1',\n",
       "    'name': 'Product Fit and Return Issues',\n",
       "    'description': 'Discussions about sizing problems and returns due to incorrect fit or dissatisfaction.'},\n",
       "   {'id': '2',\n",
       "    'name': 'Product Quality Feedback',\n",
       "    'description': 'Feedback on product quality, including compliments and concerns.'},\n",
       "   {'id': '3',\n",
       "    'name': 'Product Features and Style Preferences',\n",
       "    'description': 'Discussion about product features and style preferences, including recommendations.'},\n",
       "   {'id': '4',\n",
       "    'name': 'User Engagement Issues',\n",
       "    'description': 'Situations with no user interaction or response, suggesting a lack of engagement.'},\n",
       "   {'id': '5',\n",
       "    'name': 'Documentation and Reference Needs',\n",
       "    'description': 'Requests for user guides, how-tos, or other documentation to assist with product use.'}]]}"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "step['review_taxonomy']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "## Final Taxonomy\n",
       "\n",
       "| ID | Name | Description |\n",
       "|----|------|-------------|\n",
       "| 1 | Product Fit and Return Issues | Discussions about sizing problems and returns due to incorrect fit or dissatisfaction. |\n",
       "| 2 | Product Quality Feedback | Feedback on product quality, including compliments and concerns. |\n",
       "| 3 | Product Features and Style Preferences | Discussion about product features and style preferences, including recommendations. |\n",
       "| 4 | User Engagement Issues | Situations with no user interaction or response, suggesting a lack of engagement. |\n",
       "| 5 | Documentation and Reference Needs | Requests for user guides, how-tos, or other documentation to assist with product use. |\n"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import Markdown\n",
    "\n",
    "def format_taxonomy_md(clusters):\n",
    "    md = \"## Final Taxonomy\\n\\n\"\n",
    "    md += \"| ID | Name | Description |\\n\"\n",
    "    md += \"|----|------|-------------|\\n\"\n",
    "\n",
    "    # Fill the table with cluster data\n",
    "    for label in clusters:\n",
    "        id = label['id']\n",
    "        name = label['name'].replace(\n",
    "            \"|\", \"\\\\|\"\n",
    "        ) # Escape any pipe characters within the content\n",
    "        description = label['description'].replace(\n",
    "            \"|\", \"\\\\|\"\n",
    "        ) # Escape any pipe characters\n",
    "        md += f\"| {id} | {name} | {description} |\\n\"\n",
    "\n",
    "    return md\n",
    "\n",
    "Markdown(format_taxonomy_md(step[\"review_taxonomy\"]['clusters'][-1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "llm",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}