feat: Add instruction-tuned dataset generation for LLM fine-tuning

Add script to convert raw NEON articles into instruction-tuned formats
suitable for LoRA and other fine-tuning methods.

Features:
- Support for 4 output formats: alpaca, chat, sharegpt, completion
- Varied German instruction templates for better model generalization
- Length filtering options (--min-length, --max-length)
- Category translation to human-readable German names
- Metadata preservation for traceability

Generated datasets are gitignored as they can be easily regenerated
from the source data (~18k articles processed in seconds).

.gitignore

@@ -1 +1,9 @@
 **/*.env
+
+# Python
+__pycache__/
+*.py[cod]
+.venv/
+
+*.jsonl
+!stern_neon_user_poetry.jsonl

README.md

@@ -1,22 +1,25 @@
 ---
 license: wtfpl
 task_categories:
-- text-classification
-- summarization
-- text-generation
-- sentence-similarity
+    - text-classification
+    - summarization
+    - text-generation
+    - sentence-similarity
 language:
-- de
-- en
+    - de
+    - en
 tags:
-- art
-- poetry
-- literature
-- articles
-- opinion
+    - art
+    - poetry
+    - literature
+    - articles
+    - opinion
+    - fine-tuning
+    - lora
+    - instruction-tuning
 pretty_name: Stern NEON Articles
 size_categories:
-- 10K<n<100K
+    - 10K<n<100K
 ---
 
 # Structured Stern NEON Community Articles
@@ -47,6 +50,7 @@ This dataset can be used for text classification, question answering, text gener
 - **Question Answering**: The dataset can be used to train a model to answer questions about the articles.
 - **Text Generation**: The dataset can be used to train a model to generate new articles.
 - **Text-to-Text Generation**: The dataset can be used to train a model to generate summaries of the articles.
+- **Fine-Tuning / LoRA**: The dataset can be converted to instruction format for fine-tuning LLMs (see [Instruction-Tuned Dataset Generation](#instruction-tuned-dataset-generation) below).
 
 ### Out-of-Scope Use
 
@@ -78,17 +82,17 @@ The main structure of the dataset is as follows:
 
 ```json
 {
-  "created":1190362560,
-  "author":"Wortfechter",
-  "profile_url":"http://www.neon.de/user/Wortfechter",
-  "title":"Kopftuch im Flughafen",
-  "subtitle":"In Teheran ist das Kopftuch gesetzlich vorgeschrieben. Auch im Flughafen.",
-  "text":"Auf unserem Weg nach Kambodscha führte uns unser Flug über Teheran nach Bangkok. Das erste, was wir auf unserer Reise also zu sehen bekommen sollten, war der Sicherheitsbereich im Imam Khomeini Airport in Teheran. Alle Mädels waren bestens ausgerüstet mit langen Klamotten und Tüchern, die sie mehr oder weniger professionell um ihren Kopf zu wickeln versuchten. Da in Teheran das Kopftuch für Frauen gesetzlich vorgeschrieben ist, mussten auch wir auf dem Flughafen alles außer unserer Hände und Gesichter verdecken.\n   \n\n   Als ich nun also mehr schlecht als recht eingewickelt aus dem Flugzeug stolperte, wurde ich vom Passkontrolleur erstmal gefragt, ob ich denn Muslimin sei. Auf meine Verneinung hin wollte er wissen, warum ich denn dann ein Kopftuch trage. Sehr witzig, der Mann.\n   \n   Im Flughafen war es natürlich warm, unter den Kopftüchern war es natürlich noch wärmer und in langen Klamotten erst recht. Zunächst wurden wir mit riesigen Muffins und Kaffee/Cola/Wasser for free doch recht nett begrüßt, doch nach einigen Stunden wurde es verdammt nervig. Es würde mich nicht wundern, wenn einige der Mädels eine richtige Abneigung entwickeln würden gegen dieses Land, in dem man als Frau selbst auf dem Flughafen alles außer der Hände und dem Gesicht verdecken muss. Nicht, dass wir halbnackt durch den Flughafen hüpfen wollten, aber bei den Temperaturen wäre ein T-Shirt schon was Feines gewesen. Im Flugzeug wurden vorsorglich an alle Unwissenden Kittel verteilt, auf dem Rückflug gab es sogar Kopftücher, dafür aber auch deutsche Touris, die aussahen, als würden sie in Thailand einen ganz bestimmten Tourismus pflegen und unsere Mädels anpöbelten, weil sie \"zu lange\" am öffentlichen internetfähigen Rechner standen.\n   \n   Als wir die Kopftücher nach einiger Zeit lüfteten, wurden wir gleich dezent darauf hingewiesen, dass es Vorschrift sei, sie zu tragen. Keine Begründung. Einfach nur \"That's a rule\" - and that's it.\n   \n\n   Bei allem Verständnis für andere Kulturen und Sitten fühlte ich mich - unter meinem Kopftuch schwitzend - ein wenig in meiner persönlichen Freiheit eingeschränkt.",
-  "url":"http://www.neon.de:80/artikel/kaufen/reise/kopftuch-im-flughafen/652640",
-  "archive_url":"https://web.archive.org/web/20140815233601/http://www.neon.de:80/artikel/kaufen/reise/kopftuch-im-flughafen/652640",
-  "main_category":"kaufen",
-  "sub_category":"reise",
-  "id":652640
+    "created": 1190362560,
+    "author": "Wortfechter",
+    "profile_url": "http://www.neon.de/user/Wortfechter",
+    "title": "Kopftuch im Flughafen",
+    "subtitle": "In Teheran ist das Kopftuch gesetzlich vorgeschrieben. Auch im Flughafen.",
+    "text": "Auf unserem Weg nach Kambodscha führte uns unser Flug über Teheran nach Bangkok. Das erste, was wir auf unserer Reise also zu sehen bekommen sollten, war der Sicherheitsbereich im Imam Khomeini Airport in Teheran. Alle Mädels waren bestens ausgerüstet mit langen Klamotten und Tüchern, die sie mehr oder weniger professionell um ihren Kopf zu wickeln versuchten. Da in Teheran das Kopftuch für Frauen gesetzlich vorgeschrieben ist, mussten auch wir auf dem Flughafen alles außer unserer Hände und Gesichter verdecken.\n   \n\n   Als ich nun also mehr schlecht als recht eingewickelt aus dem Flugzeug stolperte, wurde ich vom Passkontrolleur erstmal gefragt, ob ich denn Muslimin sei. Auf meine Verneinung hin wollte er wissen, warum ich denn dann ein Kopftuch trage. Sehr witzig, der Mann.\n   \n   Im Flughafen war es natürlich warm, unter den Kopftüchern war es natürlich noch wärmer und in langen Klamotten erst recht. Zunächst wurden wir mit riesigen Muffins und Kaffee/Cola/Wasser for free doch recht nett begrüßt, doch nach einigen Stunden wurde es verdammt nervig. Es würde mich nicht wundern, wenn einige der Mädels eine richtige Abneigung entwickeln würden gegen dieses Land, in dem man als Frau selbst auf dem Flughafen alles außer der Hände und dem Gesicht verdecken muss. Nicht, dass wir halbnackt durch den Flughafen hüpfen wollten, aber bei den Temperaturen wäre ein T-Shirt schon was Feines gewesen. Im Flugzeug wurden vorsorglich an alle Unwissenden Kittel verteilt, auf dem Rückflug gab es sogar Kopftücher, dafür aber auch deutsche Touris, die aussahen, als würden sie in Thailand einen ganz bestimmten Tourismus pflegen und unsere Mädels anpöbelten, weil sie \"zu lange\" am öffentlichen internetfähigen Rechner standen.\n   \n   Als wir die Kopftücher nach einiger Zeit lüfteten, wurden wir gleich dezent darauf hingewiesen, dass es Vorschrift sei, sie zu tragen. Keine Begründung. Einfach nur \"That's a rule\" - and that's it.\n   \n\n   Bei allem Verständnis für andere Kulturen und Sitten fühlte ich mich - unter meinem Kopftuch schwitzend - ein wenig in meiner persönlichen Freiheit eingeschränkt.",
+    "url": "http://www.neon.de:80/artikel/kaufen/reise/kopftuch-im-flughafen/652640",
+    "archive_url": "https://web.archive.org/web/20140815233601/http://www.neon.de:80/artikel/kaufen/reise/kopftuch-im-flughafen/652640",
+    "main_category": "kaufen",
+    "sub_category": "reise",
+    "id": 652640
 }
 ```
 
@@ -166,11 +170,108 @@ wird doch alles besser und gut und dann werde ich auch gesünder aussehen.
 Morgen fängt das schon an.
 ```
 
+## Instruction-Tuned Dataset Generation
+
+The repository includes a script to convert the raw articles into instruction-tuned formats suitable for fine-tuning LLMs with LoRA or other methods.
+
+### Supported Output Formats
+
+| Format       | Description                     | Use With                     |
+| ------------ | ------------------------------- | ---------------------------- |
+| `alpaca`     | Instruction/Input/Output format | Most trainers, LLaMA-Factory |
+| `chat`       | ChatML messages format          | Chat model fine-tuning       |
+| `sharegpt`   | ShareGPT conversations format   | Axolotl, Unsloth             |
+| `completion` | Simple text completion format   | Basic text generation        |
+
+### Usage
+
+```bash
+# Install dependencies (uses only Python stdlib)
+pip install -r scripts/requirements.txt
+
+# Generate Alpaca format (default)
+python scripts/generate_instructions.py stern_neon_user_poetry.jsonl -o neon_alpaca.jsonl
+
+# Generate ShareGPT format for Axolotl/Unsloth
+python scripts/generate_instructions.py stern_neon_user_poetry.jsonl -o neon_sharegpt.jsonl -f sharegpt
+
+# Filter by text length (500-5000 characters)
+python scripts/generate_instructions.py stern_neon_user_poetry.jsonl -o neon_filtered.jsonl --min-length 500 --max-length 5000
+```
+
+### Command Line Options
+
+| Option         | Description                                               | Default    |
+| -------------- | --------------------------------------------------------- | ---------- |
+| `input`        | Path to input JSONL file                                  | (required) |
+| `-o, --output` | Path to output JSONL file                                 | (required) |
+| `-f, --format` | Output format: `alpaca`, `chat`, `sharegpt`, `completion` | `alpaca`   |
+| `--min-length` | Minimum text length in characters                         | `100`      |
+| `--max-length` | Maximum text length in characters                         | No limit   |
+| `--seed`       | Random seed for reproducibility                           | `42`       |
+
+### Example Output (Alpaca Format)
+
+```json
+{
+    "instruction": "Schreibe einen Artikel mit dem Titel: \"Morgen.\"",
+    "input": "",
+    "output": "Ich frage mich, ob das wirklich ich bin...",
+    "metadata": {
+        "title": "Morgen.",
+        "author": "entfesselt",
+        "category": "Gefühle / Erwachsenwerden",
+        "id": 988270
+    }
+}
+```
+
+### Example Output (ShareGPT Format)
+
+```json
+{
+    "conversations": [
+        {
+            "from": "system",
+            "value": "Du bist ein kreativer Autor im Stil der Stern NEON Community..."
+        },
+        {
+            "from": "human",
+            "value": "Schreibe einen Artikel mit dem Titel: \"Morgen.\""
+        },
+        { "from": "gpt", "value": "Ich frage mich, ob das wirklich ich bin..." }
+    ],
+    "id": "neon_988270"
+}
+```
+
+### Instruction Templates
+
+The script uses varied instruction templates to improve model generalization:
+
+- Title-based: _"Schreibe einen Artikel mit dem Titel: {title}"_
+- Category-based: _"Schreibe einen persönlichen Artikel über {category}."_
+- Combined: _"Schreibe einen {category}-Artikel mit dem Titel {title}."_
+- With context: _"Schreibe einen Artikel mit dem Titel {title}. Thema: {subtitle}"_
+
+### Training Recommendations
+
+For fine-tuning with LoRA, we recommend:
+
+1. **Base Models**: Llama 3 8B, Mistral 7B, or German models like LeoLM
+2. **Training Frameworks**:
+    - [Unsloth](https://github.com/unslothai/unsloth) — Fastest, 2x speed, use `sharegpt` format
+    - [Axolotl](https://github.com/OpenAccess-AI-Collective/axolotl) — Most flexible, use `sharegpt` format
+    - [LLaMA-Factory](https://github.com/hiyouga/LLaMA-Factory) — Use `alpaca` format
+
+---
+
 ## JSONL Normalization Script
 
 A Python script (`normalize_jsonl.py`) is included in this repository to help clean and prepare the dataset for LLM fine-tuning. This script uses an OpenAI-compatible API to normalize the `text` field of each entry, ensuring high-quality, consistent data for model training.
 
 ### Features
+
 - **Filters entries**: Skips entries with empty or missing `text` fields
 - **State tracking**: Skips already processed entries (marked as normalized or failed) to avoid duplicate work and API calls
 - **AI-powered normalization**: Uses OpenAI or compatible APIs to clean, standardize, and preserve the literary quality of the text
@@ -182,22 +283,23 @@ A Python script (`normalize_jsonl.py`) is included in this repository to help cl
 ### Usage
 
 1. **Install dependencies**
-   ```bash
-   pip install -r requirements.txt
-   ```
+    ```bash
+    pip install -r requirements.txt
+    ```
 2. **Set your API key**
-   - Export as environment variable: `export OPENAI_API_KEY="your-api-key"`
-   - Or use the `--api-key` flag
+    - Export as environment variable: `export OPENAI_API_KEY="your-api-key"`
+    - Or use the `--api-key` flag
 3. **Run the script**
-   ```bash
-   python normalize_jsonl.py stern_neon_user_poetry.jsonl
-   ```
-   This will create:
-   - `normalized_entries.jsonl` — Successfully normalized entries
-   - `failed_normalizations.jsonl` — Entries that failed normalization
-   - `normalize_log.txt` — Detailed log of the process
+    ```bash
+    python normalize_jsonl.py stern_neon_user_poetry.jsonl
+    ```
+    This will create:
+    - `normalized_entries.jsonl` — Successfully normalized entries
+    - `failed_normalizations.jsonl` — Entries that failed normalization
+    - `normalize_log.txt` — Detailed log of the process
 
 #### Command Line Options
+
 - `input_file` — Path to input JSONL file (required)
 - `-o, --output` — Output file for normalized entries (default: normalized_entries.jsonl)
 - `-f, --failed` — Output file for failed entries (default: failed_normalizations.jsonl)
@@ -209,10 +311,12 @@ A Python script (`normalize_jsonl.py`) is included in this repository to help cl
 - `--force-reprocess` — Force reprocessing of already normalized entries
 
 #### State Handling & Resume
+
 - The script automatically skips already processed entries (normalized or failed), allowing you to resume processing if interrupted.
 - To reprocess all entries, use the `--force-reprocess` flag.
 
 #### Example
+
 ```bash
 python normalize_jsonl.py stern_neon_user_poetry.jsonl --max-entries 10
 ```

scripts/generate_instructions.py

@@ -0,0 +1,370 @@
+#!/usr/bin/env python3
+"""
+Generate instruction-tuned dataset from Stern NEON articles.
+
+This script converts the raw JSONL articles into various formats suitable
+for fine-tuning LLMs with LoRA or other methods.
+
+Output formats:
+- Alpaca format (instruction, input, output)
+- ChatML/Messages format (for chat models)
+- Completion format (simple text format)
+"""
+
+import json
+import random
+import argparse
+from pathlib import Path
+from typing import Generator
+from dataclasses import dataclass
+
+# Category translations for German instructions
+CATEGORY_TRANSLATIONS = {
+    "fuehlen": "Gefühle",
+    "kaufen": "Konsum & Lifestyle",
+    "freie-zeit": "Freizeit",
+    "sehen": "Beobachtungen",
+    "machen": "Aktivitäten",
+    "wissen": "Wissen",
+    "erwachsen-werden": "Erwachsenwerden",
+    "familie": "Familie",
+    "liebe": "Liebe",
+    "sex": "Sexualität",
+    "freundschaft": "Freundschaft",
+    "reise": "Reisen",
+    "computer-internet": "Computer & Internet",
+    "musik": "Musik",
+    "film-fernsehen": "Film & Fernsehen",
+    "buecher": "Bücher",
+    "sport": "Sport",
+    "essen-trinken": "Essen & Trinken",
+    "mode": "Mode",
+    "wohnen": "Wohnen",
+    "arbeit": "Arbeit",
+    "studium": "Studium",
+    "schule": "Schule",
+    "politik": "Politik",
+    "gesellschaft": "Gesellschaft",
+}
+
+# Instruction templates - varied to improve model generalization
+INSTRUCTION_TEMPLATES = [
+    # Title-based
+    "Schreibe einen Artikel mit dem Titel: \"{title}\"",
+    "Verfasse einen persönlichen Text zum Thema: \"{title}\"",
+    "Erstelle einen NEON-Artikel mit der Überschrift: \"{title}\"",
+
+    # Category-based
+    "Schreibe einen persönlichen Artikel über {category}.",
+    "Verfasse einen emotionalen Text zum Thema {category}.",
+
+    # Title + Category
+    "Schreibe einen {category}-Artikel mit dem Titel \"{title}\".",
+    "Erstelle einen persönlichen Text über {category}. Der Titel soll sein: \"{title}\"",
+
+    # With subtitle context
+    "Schreibe einen Artikel mit dem Titel \"{title}\". Thema: {subtitle}",
+    "Verfasse einen Text zum Thema: {subtitle}",
+]
+
+# System prompts for chat format
+SYSTEM_PROMPTS = [
+    "Du bist ein kreativer Autor im Stil der Stern NEON Community. Du schreibst persönliche, emotionale und authentische Texte über das Leben junger Erwachsener in Deutschland.",
+    "Du bist ein talentierter Autor für persönliche Essays und Erfahrungsberichte. Dein Schreibstil ist introspektiv, ehrlich und berührend.",
+    "Du schreibst im Stil von Stern NEON: persönlich, nachdenklich, manchmal melancholisch, immer authentisch. Deine Texte handeln vom Erwachsenwerden, von Liebe, Freundschaft und den kleinen Momenten des Lebens.",
+]
+
+
+@dataclass
+class Article:
+    """Represents a single article from the dataset."""
+    title: str
+    subtitle: str | None
+    text: str
+    author: str
+    main_category: str
+    sub_category: str
+    article_id: int
+
+    @classmethod
+    def from_json(cls, data: dict) -> "Article | None":
+        """Create an Article from JSON data, returns None if invalid."""
+        text = data.get("text", "").strip()
+        title = data.get("title", "").strip()
+
+        # Skip articles with empty or very short text
+        if not text or len(text) < 100 or not title:
+            return None
+
+        return cls(
+            title=title,
+            subtitle=data.get("subtitle"),
+            text=text,
+            author=data.get("author", "Anonym"),
+            main_category=data.get("main_category", ""),
+            sub_category=data.get("sub_category", ""),
+            article_id=data.get("id", 0),
+        )
+
+    def get_category_name(self) -> str:
+        """Get human-readable category name."""
+        sub = CATEGORY_TRANSLATIONS.get(self.sub_category, self.sub_category)
+        main = CATEGORY_TRANSLATIONS.get(self.main_category, self.main_category)
+        if sub and sub != main:
+            return f"{main} / {sub}"
+        return main or "Allgemein"
+
+
+def load_articles(input_path: Path) -> Generator[Article, None, None]:
+    """Load and parse articles from JSONL file."""
+    with open(input_path, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                data = json.loads(line)
+                article = Article.from_json(data)
+                if article:
+                    yield article
+            except json.JSONDecodeError as e:
+                print(f"Warning: Failed to parse line: {e}")
+                continue
+
+
+def generate_instruction(article: Article) -> str:
+    """Generate a varied instruction for an article."""
+    # Choose template based on available data
+    available_templates = INSTRUCTION_TEMPLATES[:3]  # Title-based always available
+
+    if article.main_category or article.sub_category:
+        available_templates.extend(INSTRUCTION_TEMPLATES[3:7])  # Category templates
+
+    if article.subtitle:
+        available_templates.extend(INSTRUCTION_TEMPLATES[7:])  # Subtitle templates
+
+    template = random.choice(available_templates)
+
+    return template.format(
+        title=article.title,
+        category=article.get_category_name(),
+        subtitle=article.subtitle or "",
+    )
+
+
+def to_alpaca_format(article: Article) -> dict:
+    """Convert article to Alpaca instruction format."""
+    return {
+        "instruction": generate_instruction(article),
+        "input": "",
+        "output": article.text,
+        "metadata": {
+            "title": article.title,
+            "author": article.author,
+            "category": article.get_category_name(),
+            "id": article.article_id,
+        }
+    }
+
+
+def to_chat_format(article: Article) -> dict:
+    """Convert article to ChatML/messages format."""
+    system_prompt = random.choice(SYSTEM_PROMPTS)
+    user_message = generate_instruction(article)
+
+    return {
+        "messages": [
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_message},
+            {"role": "assistant", "content": article.text},
+        ],
+        "metadata": {
+            "title": article.title,
+            "author": article.author,
+            "id": article.article_id,
+        }
+    }
+
+
+def to_completion_format(article: Article) -> dict:
+    """Convert article to simple completion format."""
+    category = article.get_category_name()
+    subtitle_line = f"\n### Untertitel: {article.subtitle}" if article.subtitle else ""
+
+    text = f"""### Kategorie: {category}
+### Titel: {article.title}{subtitle_line}
+
+{article.text}"""
+
+    return {
+        "text": text,
+        "metadata": {
+            "title": article.title,
+            "author": article.author,
+            "id": article.article_id,
+        }
+    }
+
+
+def to_sharegpt_format(article: Article) -> dict:
+    """Convert article to ShareGPT format (used by Axolotl and others)."""
+    system_prompt = random.choice(SYSTEM_PROMPTS)
+    user_message = generate_instruction(article)
+
+    return {
+        "conversations": [
+            {"from": "system", "value": system_prompt},
+            {"from": "human", "value": user_message},
+            {"from": "gpt", "value": article.text},
+        ],
+        "id": f"neon_{article.article_id}",
+    }
+
+
+FORMAT_HANDLERS = {
+    "alpaca": to_alpaca_format,
+    "chat": to_chat_format,
+    "completion": to_completion_format,
+    "sharegpt": to_sharegpt_format,
+}
+
+
+def process_dataset(
+    input_path: Path,
+    output_path: Path,
+    output_format: str = "alpaca",
+    min_length: int = 100,
+    max_length: int | None = None,
+    seed: int = 42,
+) -> dict:
+    """Process the entire dataset and write to output file."""
+    random.seed(seed)
+
+    handler = FORMAT_HANDLERS.get(output_format)
+    if not handler:
+        raise ValueError(f"Unknown format: {output_format}. Choose from: {list(FORMAT_HANDLERS.keys())}")
+
+    stats = {
+        "total_processed": 0,
+        "skipped_short": 0,
+        "skipped_long": 0,
+        "categories": {},
+    }
+
+    with open(output_path, "w", encoding="utf-8") as out_file:
+        for article in load_articles(input_path):
+            # Length filtering
+            text_len = len(article.text)
+            if text_len < min_length:
+                stats["skipped_short"] += 1
+                continue
+            if max_length and text_len > max_length:
+                stats["skipped_long"] += 1
+                continue
+
+            # Convert to output format
+            output_record = handler(article)
+            out_file.write(json.dumps(output_record, ensure_ascii=False) + "\n")
+
+            # Update stats
+            stats["total_processed"] += 1
+            cat = article.get_category_name()
+            stats["categories"][cat] = stats["categories"].get(cat, 0) + 1
+
+    return stats
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate instruction-tuned dataset from Stern NEON articles",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Generate Alpaca format (default)
+  python generate_instructions.py ../stern_neon_user_poetry.jsonl -o ../neon_alpaca.jsonl
+
+  # Generate ChatML format for chat models
+  python generate_instructions.py ../stern_neon_user_poetry.jsonl -o ../neon_chat.jsonl -f chat
+
+  # Generate ShareGPT format for Axolotl
+  python generate_instructions.py ../stern_neon_user_poetry.jsonl -o ../neon_sharegpt.jsonl -f sharegpt
+
+  # Filter by text length
+  python generate_instructions.py ../stern_neon_user_poetry.jsonl -o ../neon_filtered.jsonl --min-length 500 --max-length 5000
+        """
+    )
+
+    parser.add_argument(
+        "input",
+        type=Path,
+        help="Path to input JSONL file (stern_neon_user_poetry.jsonl)",
+    )
+    parser.add_argument(
+        "-o", "--output",
+        type=Path,
+        required=True,
+        help="Path to output JSONL file",
+    )
+    parser.add_argument(
+        "-f", "--format",
+        choices=list(FORMAT_HANDLERS.keys()),
+        default="alpaca",
+        help="Output format (default: alpaca)",
+    )
+    parser.add_argument(
+        "--min-length",
+        type=int,
+        default=100,
+        help="Minimum text length in characters (default: 100)",
+    )
+    parser.add_argument(
+        "--max-length",
+        type=int,
+        default=None,
+        help="Maximum text length in characters (default: no limit)",
+    )
+    parser.add_argument(
+        "--seed",
+        type=int,
+        default=42,
+        help="Random seed for reproducibility (default: 42)",
+    )
+
+    args = parser.parse_args()
+
+    if not args.input.exists():
+        print(f"Error: Input file not found: {args.input}")
+        return 1
+
+    print(f"Processing {args.input}...")
+    print(f"Output format: {args.format}")
+    print(f"Output file: {args.output}")
+    print()
+
+    stats = process_dataset(
+        input_path=args.input,
+        output_path=args.output,
+        output_format=args.format,
+        min_length=args.min_length,
+        max_length=args.max_length,
+        seed=args.seed,
+    )
+
+    print("=" * 50)
+    print("Processing complete!")
+    print(f"  Total articles processed: {stats['total_processed']}")
+    print(f"  Skipped (too short): {stats['skipped_short']}")
+    print(f"  Skipped (too long): {stats['skipped_long']}")
+    print()
+    print("Top categories:")
+    sorted_cats = sorted(stats["categories"].items(), key=lambda x: x[1], reverse=True)
+    for cat, count in sorted_cats[:10]:
+        print(f"  {cat}: {count}")
+    print()
+    print(f"Output written to: {args.output}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    exit(main())

scripts/requirements.txt

@@ -2,4 +2,9 @@ pymongo
 aiohttp
 requests
 
+# For instruction dataset generation (no extra deps needed, stdlib only)
+# Optional: for dataset validation and HuggingFace upload
+# datasets
+# huggingface_hub
+