100 Days of Chunking with LlamaParse and Undefined guides for WordPress & WooCommerce

Chunking Shipping and Returns Policies

Shipping and returns documents look simple until a retrieval system has to answer a customer-specific question. A shipping policy may contain delivery zones, exclusions, processing times, carrier caveats, and product-specific rules. A returns policy may combine eligibility requirements, time limits, refund methods, condition requirements, and regional exceptions. If these sections are chunked as long pages, a WooCommerce assistant can retrieve relevant words without retrieving the rule that changes the answer. For agencies building customer support, storefront search, or order-service workflows, the objective is not merely to split policy text into equal-sized pieces. The objective is to preserve each decision the policy makes and the conditions attached to it. Why policy documents need deliberate chunking A customer rarely asks for the whole policy. Typical questions are

Chunking Installation and User Guides

Installation and user guides are among the highest-value documents in a WooCommerce support and operations knowledge base. They contain exact procedures, version-specific instructions, warnings, configuration values, and troubleshooting steps. They are also easy to damage during parsing because meaning often depends on hierarchy, numbered steps, tables, screenshots, and code blocks. A useful chunking pipeline should preserve the relationship between a task, its prerequisites, its ordered steps, and the expected result. Splitting every paragraph into an independent vector record may produce technically valid chunks that are operationally useless. The goal is to create chunks that can answer questions such as “How do I configure the webhook for the payment gateway?” without losing the settings, sequence, or warnings required to complete the task. Why installation guides need

Chunking WooCommerce Product Documentation

WooCommerce product documentation is rarely a single, uniform document. It usually combines product fields, extension settings, REST API properties, import instructions, hooks, compatibility notes, and version-specific behavior. A chunking pipeline that treats every paragraph as equivalent will often produce retrieval results that are technically related but operationally incomplete. For agencies, the objective is not simply to split documentation into smaller pieces. The objective is to create chunks that preserve the relationships a developer or support engineer needs when implementing, debugging, or explaining a WooCommerce product feature. Why WooCommerce product documentation is difficult to chunk A typical product document may contain several distinct information types: Customer-facing descriptions and purchasing guidance. Store-manager instructions for configuring product data. Developer documentation for hooks, filters, templates, and APIs. Compatibility requirements

Designing a Document Processing Pipeline

A reliable document-processing pipeline is more than a parser followed by a vector database. For a WooCommerce agency, it must handle inconsistent supplier PDFs, product spreadsheets, shipping documents, support exports, and policy files while preserving the information needed for search, retrieval, and automation. The pipeline should make each transformation explicit. That makes failures observable, reprocessing safe, and chunking decisions easier to improve without rebuilding the entire system. 1. Define the document contract Start by deciding what the pipeline promises to produce. A useful output contract usually includes: The original document identifier and source location. The document type, such as product catalogue, invoice, return policy, or shipping guide. Normalized text and structured fields extracted from the document. Page, section, table, and paragraph boundaries. Chunk text with

When to Apply Your Own Chunking Rules

Default chunking is a useful starting point, but WooCommerce knowledge bases often contain structures that generic rules cannot preserve reliably. Product specifications, shipping conditions, refund policies, subscription terms, and developer documentation each need different boundaries. Apply your own chunking rules when the meaning of a retrieved passage depends on a structure that the default parser or splitter is likely to break. Use default chunking when the content is already coherent Start with the chunking behavior provided by your LlamaParse and Undefined workflow when documents are short, consistently formatted, and written as ordinary prose. A well-structured blog post, a short implementation guide, or a simple FAQ may retrieve accurately without custom handling. Before changing the rules, test representative questions rather than judging chunks by size alone.

When to Let the Parser Create Structure

In a WooCommerce retrieval pipeline, chunking should not begin with arbitrary character counts. It should begin with the structure already present in the source document. When a parser can reliably identify headings, tables, lists, paragraphs, and repeated page elements, that structure is usually more useful than a second layer of manual segmentation. What “parser-created structure” means A document parser converts a file into semantic elements instead of returning one unstructured text string. For example, a product feed specification or fulfillment guide might be represented as: { "type": "heading", "level": 2, "text": "Backorder handling" } { "type": "paragraph", "text": "When inventory is unavailable, the store may accept payment and create an order with a backordered line item." } { "type": "table", "headers": ["Status", "Customer email", "Stock

Parsing First, Chunking Second

For WooCommerce search, support, and merchandising workflows, chunking should not be the first transformation applied to a document. The reliable order is: parse the source into meaningful structure, normalize that structure, and only then create retrieval chunks. Why parsing must come first A PDF, product export, invoice, or support document is usually organized for human reading rather than machine retrieval. A page may contain a heading, a two-column layout, a table, a footer, and a product note that visually belongs to the heading above it. Splitting the raw file by character count can separate those relationships before the chunker has a chance to use them. Parsing converts the source into text and structural signals such as headings, paragraphs, lists, tables, page boundaries, and metadata. For

A Hybrid Parsing and Chunking Architecture

A production retrieval system for WooCommerce rarely has one document type or one parsing strategy. Product manuals may arrive as PDFs, supplier catalogs may contain dense tables, policy pages may be HTML, and order or product data may already be structured JSON. Applying the same parser and chunking rule to every input usually produces either incomplete context or unnecessarily large retrieval units. A hybrid architecture separates parsing from chunking and chooses the right strategy for each content region. The parser preserves structure, the router identifies the content type, and the chunker creates retrieval units that match how an agency’s support, merchandising, and operations teams ask questions. Separate the pipeline into distinct stages A useful architecture has five stages: Ingestion: Store the original file, URL, product

LlamaParse vs Unstructured: Different Jobs

For WooCommerce agencies building search, retrieval, catalog enrichment, or support workflows, LlamaParse and Unstructured can appear to solve the same problem: turning documents into text. They do not have the same primary job. The important distinction is whether you need a parser optimized for extracting usable content from complex documents, or a general document-processing pipeline that identifies and partitions document elements. The short version LlamaParse is primarily a document parser. It is designed to extract information from difficult files such as PDFs, slide decks, spreadsheets, and documents while preserving useful structure and improving the resulting representation for downstream language-model applications. Unstructured is primarily a document partitioning and ingestion toolkit. It breaks files into typed elements such as titles, narrative text, list items, tables, and page

Choosing Where Chunking Should Happen

Chunking is not a single step that belongs in every system component. For a WooCommerce agency, the right location depends on what the source document represents, how often it changes, and which downstream systems need to search or generate answers from it. A product catalogue, a shipping policy, and an order export have very different boundaries. Applying the same chunking rule to all three usually creates either oversized retrieval results or fragments that lack the context required to be useful. The main locations for chunking In a document pipeline using LlamaParse and a downstream retrieval or indexing system such as Undefined, chunking can happen in several places: During parsing: The parser identifies headings, paragraphs, tables, lists, and other document structure. This is useful when the

Recovering the Original Elements

When a WooCommerce document is chunked for search or retrieval, the chunk should not become the only copy of the content. Product specifications, refund policies, tax rules, and implementation notes often need to be displayed in their original context. Recovering the original elements means preserving enough provenance to move from a retrieved chunk back to the parser’s source elements. Why original elements matter A chunk is an application-level view of a document. It may combine a heading with several paragraphs, split a table across boundaries, or include text from adjacent sections to improve retrieval. That is useful for embeddings, but it can be problematic when an agency needs to: Show the exact source passage behind an answer. Link a support response to a page, section,

How Unstructured Handles Tables

Tables are often the most commercially important part of a WooCommerce document. A product catalog may contain dimensions and variation data, a pricing guide may define customer tiers, and a shipping document may map destination, weight, and delivery cost. If a table is reduced to an undifferentiated block of text, retrieval can lose the relationship between a row and its column headings. Unstructured treats a detected table as a distinct document element rather than assuming that every page is a sequence of paragraphs. That gives a WooCommerce agency two useful representations: readable text for search and language-model context, and structured HTML for applications that need to preserve rows and columns. Table extraction as an element When a supported partitioner identifies a table, it produces a

Preserving Page Boundaries

Why Page Boundaries Matter in Document Chunking Page boundaries are easy to lose when a parsed document is converted into one continuous string. For WooCommerce agencies, that loss can create practical retrieval problems: a product specification may become separated from its table heading, an invoice total may be associated with the wrong page, or a shipping policy may be retrieved without the exception listed on the following page. When building a knowledge system with LlamaParse and Undefined, treat the page as meaningful document structure rather than incidental formatting. Preserve the page number, source location, and page-level content before applying any secondary chunking strategy. What It Means to Preserve a Page Boundary Preserving boundaries does not necessarily mean that every chunk must contain exactly one page.

Why Section Boundaries Matter

In a WooCommerce knowledge base, a chunk is not just a fixed number of characters. It is a unit of meaning that a retrieval system can return to an agent, developer, or support specialist. Section boundaries are one of the strongest signals for deciding where that unit should begin and end. When a parser ignores document structure, it can split a setup instruction from its prerequisite, separate a pricing table from its explanatory notes, or combine unrelated policies into the same embedding. The resulting chunks may still look readable in isolation, but retrieval quality declines because the context no longer matches the question. What a section boundary represents A section boundary usually appears as a heading, subheading, page transition, table boundary, list boundary, or change

Chunking by Title with Unstructured

For WooCommerce agencies, a useful chunking strategy should preserve the structure that gives a document meaning. A returns policy, shipping guide, or product implementation manual is not just a sequence of paragraphs: headings define the scope of the content that follows. Unstructured’s title-based chunking strategy uses those section boundaries when creating chunks. What title-based chunking does Unstructured first partitions a source document into semantic elements such as titles, paragraphs, list items, and tables. The by_title strategy then groups those elements into chunks while avoiding unnecessary movement across section boundaries. This is useful for retrieval systems because a chunk headed International Returns is more meaningful than a character window that begins halfway through a section and ends inside a different topic. Basic implementation The following example

Basic Chunking with Unstructured

WooCommerce search and retrieval systems usually receive content in uneven shapes: product descriptions, attribute lists, shipping policies, order documentation, support pages, and exported catalog files. Before embedding that content, an agency needs a predictable way to divide it into retrieval-sized pieces. Unstructured provides a straightforward pipeline for doing this: partition a document into typed elements, then combine those elements into chunks with controlled size and overlap. Partitioning and chunking are different operations Unstructured first parses a source document into elements such as Title, NarrativeText, ListItem, Table, and Image. Partitioning is responsible for identifying those elements. Chunking is the later step that combines or splits element text so it fits the limits of an embedding model or retrieval system. This distinction matters for WooCommerce projects. A

Understanding Unstructured Elements

When a document is parsed for retrieval-augmented generation, the parser does more than return one long string. It identifies meaningful parts of the source and represents them as elements. A heading, paragraph, table, list, image, or page break can become a separate element with its own text and metadata. Understanding these elements is important when building a knowledge system for WooCommerce agencies. Product specifications, implementation guides, support procedures, and client documentation often contain a mixture of prose, tables, lists, screenshots, and code. Treating every source as plain text can destroy the structure that makes the information useful. What an unstructured element represents An unstructured element is a parsed unit that combines content with information about its role and origin. A typical element may contain: Text:

Partitioning vs Chunking in Unstructured: A Practical Guide for WooCommerce Content Pipelines

In an Unstructured-based content pipeline, partitioning and chunking solve different problems. Partitioning converts a source document into meaningful elements such as titles, paragraphs, lists, tables, images, and page breaks. Chunking then combines those elements into retrieval-sized text units for embeddings, vector search, or large-language-model prompts. Keeping these stages separate is especially important for WooCommerce agencies. Product catalogs, policy pages, order guides, technical documentation, and support exports have different structures. If a pipeline treats every source as a plain string, it can easily split a shipping table from its heading, mix unrelated product sections, or produce chunks that are too large for reliable retrieval. What partitioning does in Unstructured Partitioning is the document-understanding stage. Functions such as partition_pdf, partition_html, and partition_docx inspect a file or document

What Unstructured Adds After Parsing

Parsing is only the first step in making WooCommerce documents useful to an application. A parser can extract text from a PDF, DOCX file, HTML page, or spreadsheet, but the resulting text still needs structure before it can support reliable search, retrieval, classification, or automation. Unstructured adds a document-element layer after parsing. Instead of treating a file as one long string, it represents the content as typed elements such as titles, paragraphs, list items, tables, headers, and footers. That additional structure is valuable when an agency is building a knowledge base from product catalogs, supplier agreements, return policies, implementation guides, or client support documentation. From parsed text to typed elements A plain parser output might contain the following text: Returns Policy Items may be returned

From Parsed Document to Searchable Knowledge

Parsing a document is only the first step in making it useful to a search system. LlamaParse can turn PDFs, word-processing files, spreadsheets, and other complex sources into structured text, but searchable knowledge requires a second pipeline: normalize the parsed output, preserve its meaning, divide it into useful chunks, enrich each chunk with metadata, and index it for retrieval. For a WooCommerce agency, this pipeline can support internal documentation search, merchant support assistants, product knowledge bases, implementation runbooks, and customer-service tools. The important distinction is that a parsed document is an output format, while searchable knowledge is an information model. 1. Start with a parsed document, not a plain text blob Documents usually contain more structure than their visible text suggests. A merchant policy may

Keeping Document Context During Parsing

Parsing is not just the act of extracting words from a PDF, DOCX file, or scanned document. It is the point at which a document’s meaning can either be preserved or lost. For WooCommerce agencies, that distinction matters when building search, support, catalog, and operations tools from store documentation. A chunk containing “The fee is 2.9%” is not useful if the parser discarded the heading that identifies the fee, the table row that identifies the payment method, or the page context that identifies the country. Good chunking starts with context preservation during parsing. Why document context matters Most retrieval systems do not return an entire document to a language model. They return a small number of chunks. Each chunk must therefore carry enough information to

Scanned PDFs Are a Different Problem

Scanned PDFs should not be treated like ordinary PDFs. A digitally generated PDF usually contains a text layer that can be extracted with reasonable fidelity. A scanned PDF is often a collection of page images. Before a retrieval or chunking pipeline can interpret it, the images must be converted into text through optical character recognition (OCR). That distinction matters for WooCommerce agencies. Product catalogs, supplier price lists, invoices, installation manuals, compliance documents, and signed forms are frequently delivered as scans. If the ingestion pipeline assumes that every PDF already contains clean text, it may produce empty documents, incomplete chunks, or search results that appear to ignore relevant source material. Why scanned PDFs require a separate ingestion path For a text-based PDF, extraction can preserve words,

When OCR Becomes Part of the Pipeline

WooCommerce document workflows often begin with files that were never designed for software: scanned supplier invoices, photographed packing slips, legacy product catalogs, warranty forms, and return documents saved as image-only PDFs. In those cases, OCR is not a convenience added before search. It is an ingestion stage that directly affects extraction, chunking, retrieval, and automation quality. Why OCR changes the shape of a document pipeline A text-native PDF usually exposes characters, reading order, page boundaries, and sometimes table structure. An image-only PDF exposes pixels. OCR must infer the characters and their positions before a parser can create a usable representation. That inference introduces several failure modes: Characters can be substituted, such as 0 for O or 1 for I. Columns can be read in the

Extracting Useful Metadata from Documents

Document chunks are much more useful when they carry the metadata needed to identify, filter, and prioritize them. For a WooCommerce agency, a chunk from a product manual should not be treated the same way as a chunk from a return policy, a shipping guide, or an internal implementation note. Metadata gives retrieval systems the additional context they need without forcing every query to search every piece of text. Instead of asking a vector index to discover that a passage belongs to a particular product, region, or policy version, the application can store those attributes explicitly. What useful metadata looks like Useful metadata is structured information that supports a later operation such as filtering, ranking, routing, or displaying citations. Typical fields for WooCommerce document workflows

Preserving Lists and Product Specifications

WooCommerce catalogs often contain the information customers need most in lists: ingredients, compatible models, included accessories, care instructions, dimensions, and technical specifications. If a document parser turns those structures into disconnected sentences, a retrieval system may return incomplete or misleading product information. For agencies building product search, support assistants, or catalog migration tools with LlamaParse and Undefined, list preservation should be treated as a data-integrity requirement rather than a formatting preference. Why list structure matters in WooCommerce content A product document may contain several kinds of lists: Feature lists describing product benefits Bullet points containing package contents Numbered installation or maintenance steps Key-value specifications such as voltage, dimensions, and material Compatibility lists naming supported devices, models, or software versions These structures carry relationships that plain

Handling Headings and Sections

Why headings matter when chunking WooCommerce content Headings are structural signals, not just visual formatting. In WooCommerce documentation, a heading often identifies the product, workflow, API resource, or failure condition that gives the following paragraphs their meaning. A paragraph about stock status means something different under “REST API response fields” than under “Checkout troubleshooting.” If a chunk contains body text without its parent headings, retrieval may return technically correct text with the wrong context. A support assistant could retrieve instructions for updating a product but omit whether the instructions apply to the block editor, the REST API, or a custom integration. Preserve the heading hierarchy during parsing When processing documents with LlamaParse, retain the heading text and its level in the parsed representation whenever the

Why Tables Are Difficult for Search

Tables look structured to a human reader, but they are often one of the least reliable document elements for search and retrieval. A person can identify the column headers, follow a row across the page, and understand that a value belongs to a particular product or condition. A search index usually receives a sequence of extracted text with much of that spatial and relational meaning removed. Why table meaning gets lost Most search systems work best with text that has a clear reading order. Tables do not naturally have one. A parser may return cells row by row, column by column, or in the order that the PDF stores drawing objects. Those orders are not always equivalent to the way the table appears visually. Consider

Parsing PDFs Without Losing Their Structure

PDFs are convenient for publishing product catalogs, installation guides, compliance documents, invoices, and technical manuals. They are much less convenient for retrieval systems. A parser that extracts only the visible words can destroy the relationships that make the document useful: a price can become separated from its product, a table row can be read in the wrong order, and a heading can be detached from the section it describes. For WooCommerce agencies, this matters when building search, support assistants, catalog importers, or internal knowledge tools. The goal is not simply to turn a PDF into plain text. The goal is to preserve enough structure that downstream chunking and retrieval still represent the source accurately. Why ordinary PDF text extraction fails A PDF usually stores text

What LlamaParse Brings to Document Processing

WooCommerce projects often depend on documents that were never designed for machine processing. Vendor catalogs arrive as PDFs, supplier price lists contain merged cells, product specifications use inconsistent headings, and tax or shipping policies may be scanned images. Extracting text from these files is only the first step. The useful information must also retain its structure, relationships, and context before it can be searched, chunked, or used in an automation. LlamaParse is a document parsing service designed for this kind of workload. It converts complex files into representations that are more useful to downstream retrieval and language-model applications than a basic text extractor. From raw files to usable document content A conventional PDF-to-text utility may return the characters on a page while losing the relationships

The Chunking Pipeline for WooCommerce

WooCommerce content is rarely organized in the way a retrieval system needs. A single product may contain a short description, a long description, attributes, variations, shipping restrictions, return rules, and purchase instructions. Store policies may live on separate pages, while operational details are buried in FAQs or customer-service documents. A reliable chunking pipeline turns these sources into small, self-contained records without losing the relationships that make the information useful. For agencies, the goal is not simply to split text into equal lengths. The goal is to produce chunks that can answer questions such as Which size should I order?, Can this product ship to Alaska?, or What is the return window for sale items? with the correct store and product context. 1. Define the retrieval

Characters, Tokens and Embeddings

When building retrieval-augmented systems for WooCommerce stores, three measurements are easy to confuse: characters, tokens, and embeddings. They describe different stages of the content pipeline, and choosing the wrong one can lead to oversized chunks, incomplete product context, higher API costs, or poor search results. Characters are a simple size estimate A character is a letter, number, space, punctuation mark, or other symbol in a text string. Character counts are easy to calculate and useful for initial inspection after a document has been parsed. For example, a product description might contain 4,800 characters, including HTML text, headings, specifications, and line breaks. That number tells you how large the raw string is, but it does not reliably tell you how much context a language model will

The Role of Chunk Size in Search or Retrieval

Chunk size is one of the highest-impact configuration choices in a retrieval-augmented search system. It determines how much text is embedded and returned as a single unit, which affects retrieval precision, context completeness, latency, storage cost, and the quality of answers generated from the retrieved content. For a WooCommerce agency, this decision matters whenever a system searches product documentation, support tickets, store policies, implementation notes, theme files, or customer-facing content. A chunk that is too small may match a query precisely but omit the conditions needed to interpret the match. A chunk that is too large may contain the answer, but bury it among unrelated content and reduce retrieval precision. What chunk size controls A chunk is usually measured in tokens, although some systems configure

Understanding Elements Before Creating Chunks

Chunking should begin with an understanding of the elements in a document, not with an arbitrary character limit. For a WooCommerce agency, this distinction matters because product guides, setup manuals, refund policies, API references, and support exports all contain different structures. A heading, table, warning, code sample, and paragraph should not be treated as interchangeable text. What an element represents An element is a meaningful unit produced during parsing. Depending on the parser and output format, an element may represent a title, heading, paragraph, list item, table, image description, code block, page header, page footer, or other document component. Before creating chunks with LlamaParse and Undefined, inspect the parsed output and identify which fields describe: Content: the visible text or structured data. Type: whether the

Documents Have Structure: Use It

Why flat text creates weak search results WooCommerce projects depend on documents whose meaning is tied to structure. A return policy, product catalog, installation guide, and shipping matrix do not communicate information in the same way. If each document is converted into one uninterrupted stream of text and split every 500 words, important relationships are lost. A chunk might contain a heading without the section it describes, a table row without its column labels, or a product specification separated from the product name. The resulting search result may contain the right words but still be unusable to an agency team, store manager, or support specialist. Chunk by document boundaries Start with the structure already present in the source document. Useful boundaries include: Document title and

Why Naive Text Splitting Often Fails

Why Naive Text Splitting Often Fails Text chunking is easy to underestimate. A WooCommerce agency may take product descriptions, documentation, support articles, and store policies, split them into fixed-size blocks, and assume the resulting content is ready for search, retrieval, or downstream processing. In practice, naive splitting often separates the information customers need from the context that makes it useful. What Naive Splitting Looks Like The simplest approach divides text every 500 characters or 1,000 tokens, sometimes with a fixed overlap: chunk_size = 1000 chunk_overlap = 100</n This method is predictable, but it knows nothing about headings, paragraphs, product fields, HTML elements, tables, or WooCommerce shortcodes. A split can occur in the middle of a sentence, list item, price rule, or code example. How Context

What Makes a Good Chunk?

Chunking Is a Content Design Problem A chunk is a self-contained section of content stored and retrieved as a unit. For a WooCommerce agency, that content might come from product documentation, support procedures, developer guides, client contracts, or checkout troubleshooting notes. A good chunk gives a reader—or a search system—enough information to understand one specific topic without requiring the entire source document. It should preserve the relationship between the subject, the relevant conditions, and the action or answer. What Makes a Chunk Good? One clear purpose: The chunk answers one closely related question or explains one procedure. Enough context: It identifies the product, feature, platform, or condition being discussed. Logical boundaries: It starts and ends at a heading, paragraph group, list, or complete procedural step

Parsing Is Not the Same as Chunking

When a WooCommerce project involves product catalogs, order exports, policy documents, or support content, two data-preparation tasks are often treated as if they were interchangeable: parsing and chunking. They solve different problems, and confusing them can lead to incomplete product data, broken search results, and unreliable downstream workflows. What parsing does Parsing converts a source file into structured, usable content. The parser identifies text, tables, headings, lists, links, page boundaries, and other document elements, depending on the format and the quality of the source. For example, a product specification PDF might contain: A product name and SKU Several paragraphs of description A technical specifications table A warranty section Footnotes and page headers A successful parsing step should preserve the relationship between those elements. The SKU

From WooCommerce Documents to Searchable Knowledge

Why WooCommerce documents need structure before search WooCommerce stores often contain valuable information across product guides, supplier PDFs, shipping policies, return documents, installation instructions, FAQs, and internal operating procedures. When these files are uploaded into a search system as raw text, important relationships are easily lost. Tables may become unreadable, headings can be separated from their content, and a result may not indicate which product, region, or customer group it applies to. A useful document pipeline should preserve the meaning of each section while adding enough metadata to filter results accurately. LlamaParse can be used at the extraction stage to convert complex documents into structured text, including documents that contain headings, tables, and mixed layouts. The parsed output can then be split into searchable chunks

Why Chunking Matters for WooCommerce AI Search

Why Chunking Matters for WooCommerce AI Search Product data is rarely written in a way that search systems can use efficiently. A WooCommerce product page may combine the product name, short description, long description, specifications, shipping information, variations, reviews, and custom fields in one large document. Treating that entire page as a single search unit makes it harder to retrieve the most relevant information for a customer’s question. Chunking solves this problem by splitting product and store content into smaller, meaningful sections. Each section can then be indexed and retrieved independently, giving a search system a better chance of finding the exact information needed to answer a query or filter a catalog. What Chunking Means in WooCommerce A chunk is a self-contained piece of content