Adds data for remaining sections.

README.md

@@ -8,6 +8,10 @@ tags:
 - aerospace
 - simulation
 configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/reviews.jsonl
 - config_name: reviews
   data_files:
   - split: train
@@ -16,6 +20,34 @@ configs:
   data_files:
   - split: train
     path: data/flights.jsonl
+- config_name: products
+  data_files:
+  - split: train
+    path: data/products.jsonl
+- config_name: motors
+  data_files:
+  - split: train
+    path: data/motors.jsonl
+- config_name: parts
+  data_files:
+  - split: train
+    path: data/parts.jsonl
+- config_name: designs
+  data_files:
+  - split: train
+    path: data/designs.jsonl
+- config_name: clubs
+  data_files:
+  - split: train
+    path: data/clubs.jsonl
+- config_name: glossary
+  data_files:
+  - split: train
+    path: data/glossary.jsonl
+- config_name: plans
+  data_files:
+  - split: train
+    path: data/plans.jsonl
 ---
 
 # RocketReviews Dataset

data/clubs.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:819e3864780fb899fbcc884120f88563de03a61920b90f1f04c452df133b17aa
+size 125866

data/designs.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eafc945a60b85c2bdfffa6c4db34856be31e7c4d55db4059b479225fd572e498
+size 3910828

data/glossary.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0c10d357cd7180de37ed0c802ce6d73db3a69be366252db8128374fde355f49e
+size 299270

data/motors.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5fd7db19d6d7777a0a1d34af235cd2739cccc6381548c61df8ffec548f3e2a6a
+size 471885

data/parts.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca1ad0958eaedc898b216089c4c66d7b5875178fd0504967dccbcd13f48869bb
+size 5125543

data/plans.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f48f34e3f8bb446140518b1af1a999b180168e8c4b5c7cfb590ece486c2bdcd3
+size 73385

data/products.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c6995ca4f63a6e495a02608140121a334d9c2a5d9f61fc5ce929bc16006045b
+size 1663265

scripts/clubs/02_build_data.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+import json
+import logging
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+ROOT = Path(__file__).parent.parent.parent
+SOURCE_DIR = ROOT / "source" / "clubs" / "detail"
+OUTPUT_FILE = ROOT / "data" / "clubs.jsonl"
+PREFIX = "club"
+
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Mapper
+# ---------------------------------------------------------------------------
+
+def transform_club(data: dict) -> dict:
+    """Flatten club JSON into a ChromaDB-ready format."""
+    
+    chroma_id = f"{PREFIX}:{int(data['id']):06d}"
+    
+    # Build searchable document text
+    parts = []
+    name = data.get('name')
+    location = data.get('location') or f"{data.get('city')}, {data.get('state')}"
+    
+    summary = f"Rocketry Club: {name}"
+    if location: summary += f" located in {location}"
+    summary += "."
+    parts.append(summary)
+    
+    affiliations = []
+    if data.get("has_nar"): affiliations.append(f"NAR Section {data.get('nar_section') or ''}")
+    if data.get("has_tripoli"): affiliations.append(f"Tripoli Prefecture {data.get('tripoli_prefecture') or ''}")
+    if affiliations:
+        parts.append("Affiliations: " + ", ".join(affiliations).strip() + ".")
+        
+    if data.get("description"):
+        parts.append(data["description"])
+
+    document = " ".join(parts)
+    
+    # Flatten metadata
+    metadata = {
+        "id": data["id"],
+        "name": name,
+        "city": data.get("city"),
+        "state": data.get("state"),
+        "country": data.get("country"),
+        "has_nar": data.get("has_nar"),
+        "has_tripoli": data.get("has_tripoli"),
+        "url": data.get("url")
+    }
+    
+    metadata = {k: v for k, v in metadata.items() if v is not None}
+    
+    return {
+        "id": chroma_id,
+        "document": document,
+        "metadata": metadata
+    }
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    if not SOURCE_DIR.exists():
+        log.error(f"Source directory {SOURCE_DIR} not found.")
+        return
+
+    OUTPUT_FILE.parent.mkdir(parents=True, exist_ok=True)
+    
+    count = 0
+    with OUTPUT_FILE.open("w", encoding="utf-8") as out:
+        for shard_dir in sorted(SOURCE_DIR.iterdir()):
+            if not shard_dir.is_dir(): continue
+            for file_path in sorted(shard_dir.glob("*.json")):
+                try:
+                    with file_path.open("r", encoding="utf-8") as f:
+                        raw_data = json.load(f)
+                    processed = transform_club(raw_data)
+                    out.write(json.dumps(processed, ensure_ascii=False) + "\n")
+                    count += 1
+                except Exception as e:
+                    log.error(f"Error processing {file_path}: {e}")
+
+    log.info(f"Successfully built {count} records in {OUTPUT_FILE}")
+
+if __name__ == "__main__":
+    main()

scripts/designs/02_build_data.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+import json
+import logging
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+ROOT = Path(__file__).parent.parent.parent
+SOURCE_DIR = ROOT / "source" / "designs" / "detail"
+DEEP_PARSED_DIR = ROOT / "source" / "designs" / "files" / "json"
+OUTPUT_FILE = ROOT / "data" / "designs.jsonl"
+PREFIX = "design"
+
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Mapper
+# ---------------------------------------------------------------------------
+
+def transform_design(data: dict, deep_data: dict = None) -> dict:
+    """Flatten design JSON into a ChromaDB-ready format."""
+    
+    chroma_id = f"{PREFIX}:{int(data['id']):06d}"
+    
+    # Build searchable document text
+    parts = []
+    title = data.get('title') or data.get('name')
+    mfr = data.get('manufacturer')
+    fmt = data.get('format')
+    
+    summary = f"Rocket Design: {title}"
+    if mfr: summary += f" (Manufacturer: {mfr})"
+    summary += f" in {fmt} format."
+    parts.append(summary)
+    
+    designer_obj = data.get("designer")
+    if isinstance(designer_obj, dict) and designer_obj.get("name"):
+        parts.append(f"Designed by {designer_obj['name']}.")
+        
+    if data.get("comments"):
+        parts.append(f"Comments: {data['comments']}")
+        
+    # Stability metrics
+    metrics = []
+    cg = data.get("cg")
+    if isinstance(cg, dict) and cg.get("location_in"):
+        metrics.append(f"CG: {cg['location_in']} in")
+        
+    cp = data.get("cp")
+    if isinstance(cp, dict) and cp.get("location_in"):
+        metrics.append(f"CP: {cp['location_in']} in")
+        
+    if data.get("margin"):
+        metrics.append(f"Margin: {data['margin']} {data.get('margin_status', '')}")
+        
+    if metrics:
+        parts.append("Metrics: " + ", ".join(metrics) + ".")
+
+    # Parts List (Relationship)
+    if data.get("parts"):
+        parts.append(f"Includes components: {', '.join(data['parts'])}.")
+
+    document = " ".join(parts)
+    
+    # Flatten metadata
+    metadata = {
+        "id": data["id"],
+        "format": fmt,
+        "manufacturer": mfr,
+        "designer_name": designer_obj.get("name") if isinstance(designer_obj, dict) else None,
+        "stage_count": deep_data.get("stage_count") if isinstance(deep_data, dict) else None,
+        "url": data.get("url")
+    }
+    
+    metadata = {k: v for k, v in metadata.items() if v is not None}
+    
+    return {
+        "id": chroma_id,
+        "document": document,
+        "metadata": metadata
+    }
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    if not SOURCE_DIR.exists():
+        log.error(f"Source directory {SOURCE_DIR} not found.")
+        return
+
+    OUTPUT_FILE.parent.mkdir(parents=True, exist_ok=True)
+    
+    count = 0
+    with OUTPUT_FILE.open("w", encoding="utf-8") as out:
+        for shard_dir in sorted(SOURCE_DIR.iterdir()):
+            if not shard_dir.is_dir(): continue
+            for file_path in sorted(shard_dir.glob("*.json")):
+                try:
+                    with file_path.open("r", encoding="utf-8") as f:
+                        raw_data = json.load(f)
+                    
+                    # Try to find deep parsed data
+                    deep_data = None
+                    deep_path = DEEP_PARSED_DIR / f"{int(raw_data['id']):06d}.json"
+                    if deep_path.exists():
+                        with deep_path.open("r", encoding="utf-8") as df:
+                            deep_data = json.load(df)
+                            
+                    processed = transform_design(raw_data, deep_data)
+                    out.write(json.dumps(processed, ensure_ascii=False) + "\n")
+                    count += 1
+                except Exception as e:
+                    log.error(f"Error processing {file_path}: {e}")
+
+    log.info(f"Successfully built {count} records in {OUTPUT_FILE}")
+
+if __name__ == "__main__":
+    main()

scripts/glossary/02_build_data.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+import json
+import logging
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+ROOT = Path(__file__).parent.parent.parent
+SOURCE_DIR = ROOT / "source" / "glossary" / "detail"
+OUTPUT_FILE = ROOT / "data" / "glossary.jsonl"
+PREFIX = "glossary"
+
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Mapper
+# ---------------------------------------------------------------------------
+
+def transform_glossary(data: dict) -> dict:
+    """Flatten glossary JSON into a ChromaDB-ready format."""
+    
+    chroma_id = f"{PREFIX}:{data['slug']}"
+    
+    # Searchable text is the term + full definition
+    term = data.get('term')
+    definition = data.get('description') or data.get('short_description')
+    
+    document = f"{term}: {definition}"
+    
+    # Metadata
+    metadata = {
+        "slug": data["slug"],
+        "term": term,
+        "url": data.get("url")
+    }
+    
+    metadata = {k: v for k, v in metadata.items() if v is not None}
+    
+    return {
+        "id": chroma_id,
+        "document": document,
+        "metadata": metadata
+    }
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    if not SOURCE_DIR.exists():
+        log.error(f"Source directory {SOURCE_DIR} not found.")
+        return
+
+    OUTPUT_FILE.parent.mkdir(parents=True, exist_ok=True)
+    
+    count = 0
+    with OUTPUT_FILE.open("w", encoding="utf-8") as out:
+        for shard_dir in sorted(SOURCE_DIR.iterdir()):
+            if not shard_dir.is_dir(): continue
+            for file_path in sorted(shard_dir.glob("*.json")):
+                try:
+                    with file_path.open("r", encoding="utf-8") as f:
+                        raw_data = json.load(f)
+                    processed = transform_glossary(raw_data)
+                    out.write(json.dumps(processed, ensure_ascii=False) + "\n")
+                    count += 1
+                except Exception as e:
+                    log.error(f"Error processing {file_path}: {e}")
+
+    log.info(f"Successfully built {count} records in {OUTPUT_FILE}")
+
+if __name__ == "__main__":
+    main()

scripts/motors/02_build_data.py

@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+import json
+import logging
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+ROOT = Path(__file__).parent.parent.parent
+SOURCE_DIR = ROOT / "source" / "motors" / "detail"
+OUTPUT_FILE = ROOT / "data" / "motors.jsonl"
+PREFIX = "motor"
+
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Mapper
+# ---------------------------------------------------------------------------
+
+def transform_motor(data: dict) -> dict:
+    """Flatten motor JSON into a ChromaDB-ready format."""
+    
+    chroma_id = f"{PREFIX}:{int(data['id']):06d}"
+    
+    # Build searchable document text
+    parts = []
+    title = data.get('title') or data.get('designation')
+    mfr = data.get('manufacturer')
+    
+    summary = f"Rocket Motor: {title}"
+    if mfr: summary += f" manufactured by {mfr}"
+    summary += "."
+    parts.append(summary)
+    
+    perf = data.get("performance", {})
+    phys = data.get("physical", {})
+    
+    stats = []
+    if data.get("letter"): stats.append(f"Class: {data['letter']}")
+    if perf.get("total_impulse_ns"): stats.append(f"Total Impulse: {perf['total_impulse_ns']} Ns")
+    if perf.get("average_thrust_n"): stats.append(f"Average Thrust: {perf['average_thrust_n']} N")
+    if phys.get("diameter_mm"): stats.append(f"Diameter: {phys['diameter_mm']} mm")
+    if stats:
+        parts.append("Performance: " + ", ".join(stats) + ".")
+        
+    if data.get("description"):
+        parts.append(f"Description: {data['description']}")
+
+    document = " ".join(parts)
+    
+    # Flatten metadata
+    metadata = {
+        "id": data["id"],
+        "designation": data.get("designation"),
+        "manufacturer": mfr,
+        "letter": data.get("letter"),
+        "diameter_mm": phys.get("diameter_mm"),
+        "total_impulse_ns": perf.get("total_impulse_ns"),
+        "average_thrust_n": perf.get("average_thrust_n"),
+        "url": data.get("url")
+    }
+    
+    metadata = {k: v for k, v in metadata.items() if v is not None}
+    
+    return {
+        "id": chroma_id,
+        "document": document,
+        "metadata": metadata
+    }
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    if not SOURCE_DIR.exists():
+        log.error(f"Source directory {SOURCE_DIR} not found.")
+        return
+
+    OUTPUT_FILE.parent.mkdir(parents=True, exist_ok=True)
+    
+    count = 0
+    with OUTPUT_FILE.open("w", encoding="utf-8") as out:
+        for shard_dir in sorted(SOURCE_DIR.iterdir()):
+            if not shard_dir.is_dir(): continue
+            for file_path in sorted(shard_dir.glob("*.json")):
+                try:
+                    with file_path.open("r", encoding="utf-8") as f:
+                        raw_data = json.load(f)
+                    processed = transform_motor(raw_data)
+                    out.write(json.dumps(processed, ensure_ascii=False) + "\n")
+                    count += 1
+                except Exception as e:
+                    log.error(f"Error processing {file_path}: {e}")
+
+    log.info(f"Successfully built {count} records in {OUTPUT_FILE}")
+
+if __name__ == "__main__":
+    main()

scripts/parts/02_build_data.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+import json
+import logging
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+ROOT = Path(__file__).parent.parent.parent
+SOURCE_DIR = ROOT / "source" / "parts" / "detail"
+OUTPUT_FILE = ROOT / "data" / "parts.jsonl"
+PREFIX = "part"
+
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Mapper
+# ---------------------------------------------------------------------------
+
+def transform_part(data: dict) -> dict:
+    """Flatten part JSON into a ChromaDB-ready format."""
+    
+    chroma_id = f"{PREFIX}:{data['slug']}"
+    
+    # Build searchable document text
+    parts = []
+    title = data.get('title')
+    cat = data.get('category')
+    mfr = data.get('manufacturer')
+    mat = data.get('material')
+    
+    summary = f"Rocket Part: {title}"
+    if cat: summary += f" ({cat})"
+    if mfr: summary += f" manufactured by {mfr}"
+    summary += "."
+    parts.append(summary)
+    
+    # Add physical specs dynamically
+    specs = []
+    if mat: specs.append(f"material: {mat}")
+    
+    # Capture dimensions (diameter, length, chords, etc)
+    for key, val in data.items():
+        if key in ["slug", "category", "title", "manufacturer", "manufacturer_url", "material", "related_designs", "scraped_at", "url"]:
+            continue
+        specs.append(f"{key.replace('_', ' ')}: {val}")
+        
+    if specs:
+        parts.append("Specifications: " + ", ".join(specs) + ".")
+        
+    if data.get("related_designs"):
+        designs = [d['name'] for d in data['related_designs']]
+        parts.append(f"Featured in designs: {', '.join(designs)}.")
+
+    document = " ".join(parts)
+    
+    # Flatten metadata
+    metadata = {
+        "slug": data["slug"],
+        "category": cat,
+        "manufacturer": mfr,
+        "material": mat,
+        "url": data.get("url")
+    }
+    
+    metadata = {k: v for k, v in metadata.items() if v is not None}
+    
+    return {
+        "id": chroma_id,
+        "document": document,
+        "metadata": metadata
+    }
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    if not SOURCE_DIR.exists():
+        log.error(f"Source directory {SOURCE_DIR} not found.")
+        return
+
+    OUTPUT_FILE.parent.mkdir(parents=True, exist_ok=True)
+    
+    count = 0
+    with OUTPUT_FILE.open("w", encoding="utf-8") as out:
+        for shard_dir in sorted(SOURCE_DIR.iterdir()):
+            if not shard_dir.is_dir(): continue
+            for file_path in sorted(shard_dir.glob("*.json")):
+                try:
+                    with file_path.open("r", encoding="utf-8") as f:
+                        raw_data = json.load(f)
+                    processed = transform_part(raw_data)
+                    out.write(json.dumps(processed, ensure_ascii=False) + "\n")
+                    count += 1
+                except Exception as e:
+                    log.error(f"Error processing {file_path}: {e}")
+
+    log.info(f"Successfully built {count} records in {OUTPUT_FILE}")
+
+if __name__ == "__main__":
+    main()

scripts/plans/02_build_data.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+import json
+import logging
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+ROOT = Path(__file__).parent.parent.parent
+SOURCE_DIR = ROOT / "source" / "plans" / "detail"
+OUTPUT_FILE = ROOT / "data" / "plans.jsonl"
+PREFIX = "plan"
+
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Mapper
+# ---------------------------------------------------------------------------
+
+def transform_plan(data: dict) -> dict:
+    """Flatten plan JSON into a ChromaDB-ready format."""
+    
+    chroma_id = f"{PREFIX}:{data['slug']}"
+    
+    # Searchable text: Title, source, and style
+    title = data.get('title')
+    source = data.get('source')
+    style = data.get('style')
+    site = data.get('site', {}).get('name')
+    
+    summary = f"Rocket Plan: {title}"
+    if source: summary += f" (Source: {source})"
+    summary += f" in {style or 'Standard'} style."
+    if site: summary += f" Hosted on {site}."
+    
+    document = summary
+    
+    # Metadata
+    metadata = {
+        "slug": data["slug"],
+        "title": title,
+        "source": source,
+        "style": style,
+        "site_name": site,
+        "url": data.get("url"),
+        "external_url": data.get("site", {}).get("url")
+    }
+    
+    metadata = {k: v for k, v in metadata.items() if v is not None}
+    
+    return {
+        "id": chroma_id,
+        "document": document,
+        "metadata": metadata
+    }
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    if not SOURCE_DIR.exists():
+        log.error(f"Source directory {SOURCE_DIR} not found.")
+        return
+
+    OUTPUT_FILE.parent.mkdir(parents=True, exist_ok=True)
+    
+    count = 0
+    with OUTPUT_FILE.open("w", encoding="utf-8") as out:
+        for shard_dir in sorted(SOURCE_DIR.iterdir()):
+            if not shard_dir.is_dir(): continue
+            for file_path in sorted(shard_dir.glob("*.json")):
+                try:
+                    with file_path.open("r", encoding="utf-8") as f:
+                        raw_data = json.load(f)
+                    processed = transform_plan(raw_data)
+                    out.write(json.dumps(processed, ensure_ascii=False) + "\n")
+                    count += 1
+                except Exception as e:
+                    log.error(f"Error processing {file_path}: {e}")
+
+    log.info(f"Successfully built {count} records in {OUTPUT_FILE}")
+
+if __name__ == "__main__":
+    main()

scripts/products/02_build_data.py

@@ -0,0 +1,97 @@
+#!/usr/bin/env python3
+import json
+import logging
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+ROOT = Path(__file__).parent.parent.parent
+SOURCE_DIR = ROOT / "source" / "products" / "detail"
+OUTPUT_FILE = ROOT / "data" / "products.jsonl"
+PREFIX = "product"
+
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+log = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Mapper
+# ---------------------------------------------------------------------------
+
+def transform_product(data: dict) -> dict:
+    """Flatten product JSON into a ChromaDB-ready format."""
+    
+    chroma_id = f"{PREFIX}:{int(data['id']):06d}"
+    
+    # Build searchable document text
+    parts = []
+    title = data.get('title') or data.get('name')
+    mfr = data.get('manufacturer', {}).get('name')
+    
+    summary = f"Product: {title}"
+    if mfr: summary += f" manufactured by {mfr}"
+    summary += "."
+    parts.append(summary)
+    
+    specs = data.get("specs")
+    if specs:
+        spec_parts = []
+        if specs.get("diameter_in"): spec_parts.append(f"diameter: {specs['diameter_in']} in")
+        if specs.get("length_in"): spec_parts.append(f"length: {specs['length_in']} in")
+        if specs.get("power_class"): spec_parts.append(f"power class: {specs['power_class']}")
+        if specs.get("skill_level"): spec_parts.append(f"skill level: {specs['skill_level']}")
+        if specs.get("recovery"): spec_parts.append(f"recovery: {specs['recovery']}")
+        if spec_parts:
+            parts.append("Specifications: " + ", ".join(spec_parts) + ".")
+
+    document = " ".join(parts)
+    
+    # Flatten metadata
+    metadata = {
+        "id": data["id"],
+        "name": data.get("name"),
+        "type": data.get("type"),
+        "manufacturer_name": mfr,
+        "power_class": specs.get("power_class") if specs else None,
+        "skill_level": specs.get("skill_level") if specs else None,
+        "url": data.get("url")
+    }
+    
+    metadata = {k: v for k, v in metadata.items() if v is not None}
+    
+    return {
+        "id": chroma_id,
+        "document": document,
+        "metadata": metadata
+    }
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    if not SOURCE_DIR.exists():
+        log.error(f"Source directory {SOURCE_DIR} not found.")
+        return
+
+    OUTPUT_FILE.parent.mkdir(parents=True, exist_ok=True)
+    
+    count = 0
+    with OUTPUT_FILE.open("w", encoding="utf-8") as out:
+        for shard_dir in sorted(SOURCE_DIR.iterdir()):
+            if not shard_dir.is_dir(): continue
+            for file_path in sorted(shard_dir.glob("*.json")):
+                try:
+                    with file_path.open("r", encoding="utf-8") as f:
+                        raw_data = json.load(f)
+                    processed = transform_product(raw_data)
+                    out.write(json.dumps(processed, ensure_ascii=False) + "\n")
+                    count += 1
+                except Exception as e:
+                    log.error(f"Error processing {file_path}: {e}")
+
+    log.info(f"Successfully built {count} records in {OUTPUT_FILE}")
+
+if __name__ == "__main__":
+    main()