Sync from GitHub @ fa87356

app.py

@@ -36,7 +36,11 @@ from pydantic import BaseModel, Field
 # Make the local `knowledge` package importable whether we're running on HF
 # Spaces (cwd = /app) or locally (cwd = repo root, script in space/).
 sys.path.insert(0, str(Path(__file__).resolve().parent))
-from knowledge import KnowledgePipeline  # noqa: E402
+from knowledge import (  # noqa: E402
+    KnowledgePipeline,
+    generate_training_notebook,
+    import_adapter as import_adapter_files,
+)
 
 
 # ────────────────────────────────────────────────────────────────────────────
@@ -583,6 +587,127 @@ def handle_delete_all() -> tuple[str, list]:
     return f"🗑️ Cleared {n} document(s).", render_knowledge_table()
 
 
+# ────────────────────────────────────────────────────────────────────────────
+# LoRA-on-upload (Phase 4b)
+# ────────────────────────────────────────────────────────────────────────────
+
+NOTEBOOK_DIR = Path("data/notebooks")
+NOTEBOOK_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def handle_generate_notebook(
+    selected_doc_names: list[str],
+    adapter_name: str,
+    lora_rank: int,
+    num_epochs: int,
+):
+    """Build a Colab notebook from the chunks of the selected documents."""
+    if not selected_doc_names:
+        return "_Select at least one indexed document first._", None
+    adapter_name = (adapter_name or "").strip() or "user_adapter"
+
+    # Gather chunks for the selected docs from the store.
+    with KNOWLEDGE.store._conn() as c:  # noqa: SLF001 — internal access OK for now
+        rows = c.execute(
+            "SELECT documents.name as name, chunks.text as text "
+            "FROM chunks JOIN documents ON chunks.document_id = documents.id "
+            "WHERE documents.name IN (" + ",".join(["?"] * len(selected_doc_names)) + ") "
+            "ORDER BY chunks.document_id, chunks.chunk_index",
+            selected_doc_names,
+        ).fetchall()
+    chunks = [r["text"] for r in rows]
+    if not chunks:
+        return "_No chunks found for those documents — re-index them?_", None
+
+    safe_name = "".join(ch if ch.isalnum() else "_" for ch in adapter_name)[:40] or "user_adapter"
+    out_path = NOTEBOOK_DIR / f"evollm_train_{safe_name}.ipynb"
+
+    generate_training_notebook(
+        adapter_name=adapter_name,
+        chunks=chunks,
+        source_doc_names=selected_doc_names,
+        lora_rank=int(lora_rank),
+        num_epochs=int(num_epochs),
+        output_path=out_path,
+        description=f"Trained from {len(selected_doc_names)} document(s) via EvoLLM",
+    )
+
+    log_evolution(
+        "knowledge",
+        f"📝 Generated training notebook for '{adapter_name}' "
+        f"({len(chunks)} chunks, {len(selected_doc_names)} doc(s))",
+    )
+
+    msg = (
+        f"✅ **Notebook ready**: `{out_path.name}` ({len(chunks)} training examples).\n\n"
+        f"1. Download the file below\n"
+        f"2. Open it in [Google Colab](https://colab.research.google.com/)\n"
+        f"3. **Runtime → Change runtime type → T4 GPU**, then **Runtime → Run all**\n"
+        f"4. After training, download the two output files (`*.gguf` and `*.json`)\n"
+        f"5. Come back here, go to **🧬 Adapter Pool** tab → **📥 Import trained adapter**"
+    )
+    return msg, str(out_path)
+
+
+def handle_import_adapter(gguf_file, manifest_file):
+    """Receive a trained LoRA + manifest, register a new adapter in the pool."""
+    if not gguf_file or not manifest_file:
+        return "_Drop both the .gguf and the .json files._", render_pool_table()
+    try:
+        gguf_path = gguf_file if isinstance(gguf_file, str) else gguf_file.name
+        manifest_path = manifest_file if isinstance(manifest_file, str) else manifest_file.name
+        info = import_adapter_files(gguf_path, manifest_path)
+    except Exception as e:
+        return f"❌ Import failed: {e}", render_pool_table()
+
+    manifest = info["manifest"]
+    adapter_id = info["adapter_id"]
+
+    # Build a genome reflecting the trained-from-knowledge adapter.
+    sys_prompt = (
+        f"You are EvoLLM, fine-tuned on user-provided documents "
+        f"({', '.join(manifest.get('source_documents', []))[:160] or 'unknown sources'}). "
+        f"Draw on what you learned from those sources when relevant."
+    )
+    genome = Genome(
+        genome_id=adapter_id,
+        parent_id="evo_default",
+        generation=1,
+        name=info["name"],
+        base_model=manifest.get("base_model", "SmolLM2-1.7B-Instruct"),
+        lora_rank=int(manifest.get("lora_rank", 16)),
+        lora_alpha=int(manifest.get("lora_alpha", 32)),
+        lora_target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
+        system_prompt=sys_prompt,
+        eval_bank_score=None,  # unmeasured until the eval bank runs against it
+    )
+    new_adapter = Adapter(
+        adapter_id=adapter_id,
+        name=info["name"],
+        description=info["description"] or "User-trained from documents",
+        genome=genome,
+        promoted=True,
+    )
+    POOL.append(new_adapter)
+    POOL_BY_ID[adapter_id] = new_adapter
+    BANDIT.register(adapter_id, prior_fitness=0.55)  # neutral-mid prior
+
+    log_evolution(
+        "promotion",
+        f"📥 IMPORTED user-trained adapter '{info['name']}' "
+        f"({manifest.get('training_examples', '?')} examples, rank {genome.lora_rank}) — joined the pool.",
+        {"adapter_id": adapter_id, "source_documents": manifest.get("source_documents", [])},
+    )
+
+    note = (
+        f"✅ **{info['name']}** imported and added to the adapter pool.\n\n"
+        f"_GGUF saved to `{info['gguf_path']}`. The Bandit will start sampling it on the next "
+        f"chat. Real LoRA weight-loading is active in the local desktop app; on this Space the "
+        f"adapter uses its trained-from-data genome (system prompt + sampling config)._"
+    )
+    return note, render_pool_table()
+
+
 def refresh_all():
     return (
         render_active_genome(),
@@ -702,6 +827,22 @@ with gr.Blocks(title="EvoLLM", theme=gr.themes.Soft(), css=CSS) as demo:
                 refresh_btn = gr.Button("🔄 Refresh")
             evolution_result = gr.Markdown("")
 
+            gr.Markdown("---")
+            gr.Markdown(
+                "### 📥 Import a trained adapter\n"
+                "Drop the two files produced by the Colab training notebook "
+                "(`*.gguf` and `*.json`) to add a user-trained adapter to the pool."
+            )
+            with gr.Row():
+                import_gguf = gr.File(
+                    label="LoRA adapter (.gguf)", file_types=[".gguf"], type="filepath",
+                )
+                import_manifest = gr.File(
+                    label="Manifest (.json)", file_types=[".json"], type="filepath",
+                )
+            import_btn = gr.Button("📥 Import adapter", variant="primary")
+            import_status = gr.Markdown("")
+
         # ── Tab 3: Knowledge ─────────────────────────────────────────
         with gr.Tab("📚 Knowledge"):
             gr.Markdown(
@@ -752,6 +893,39 @@ with gr.Blocks(title="EvoLLM", theme=gr.themes.Soft(), css=CSS) as demo:
                 clear_knowledge_btn = gr.Button("🗑️ Clear all documents", variant="stop")
             knowledge_action_status = gr.Markdown("")
 
+            gr.Markdown("---")
+            gr.Markdown(
+                "### 🧬 Train an adapter from these documents\n"
+                "Bake the document content into a real LoRA adapter via QLoRA on Colab. "
+                "EvoLLM generates a configured notebook with your data inline; you run it "
+                "on a free T4 GPU; then import the resulting `.gguf` + manifest back here."
+            )
+            with gr.Row():
+                with gr.Column(scale=2):
+                    train_doc_select = gr.CheckboxGroup(
+                        choices=[d["name"] for d in KNOWLEDGE.documents()],
+                        label="Documents to train on",
+                        info="Select one or more indexed documents.",
+                    )
+                with gr.Column(scale=1):
+                    train_adapter_name = gr.Textbox(
+                        label="Adapter name", placeholder="e.g. company_handbook",
+                    )
+                    train_lora_rank = gr.Slider(
+                        minimum=4, maximum=64, value=16, step=4,
+                        label="LoRA rank",
+                        info="Higher = more capacity, slower training",
+                    )
+                    train_num_epochs = gr.Slider(
+                        minimum=1, maximum=10, value=3, step=1,
+                        label="Training epochs",
+                    )
+            with gr.Row():
+                refresh_train_docs_btn = gr.Button("🔄 Refresh doc list", size="sm")
+                generate_notebook_btn = gr.Button("🧬 Generate training notebook", variant="primary")
+            notebook_status = gr.Markdown("")
+            notebook_download = gr.File(label="📒 Download notebook", interactive=False)
+
         # ── Tab 4: Evolution Log ─────────────────────────────────────
         with gr.Tab("📜 Evolution Log"):
             gr.Markdown("### Lineage of mutations, promotions, and feedback events")
@@ -896,6 +1070,28 @@ Built on EvoTransformer (Mohabeer, 2025).
         api_name=False,
     ).then(render_knowledge_stats, None, knowledge_stats, api_name=False)
 
+    # Refresh the doc selector when documents change (keep choices in sync)
+    def _refresh_doc_choices():
+        return gr.update(choices=[d["name"] for d in KNOWLEDGE.documents()])
+
+    refresh_train_docs_btn.click(
+        _refresh_doc_choices, None, train_doc_select, api_name=False,
+    )
+
+    generate_notebook_btn.click(
+        handle_generate_notebook,
+        [train_doc_select, train_adapter_name, train_lora_rank, train_num_epochs],
+        [notebook_status, notebook_download],
+        api_name=False,
+    )
+
+    import_btn.click(
+        handle_import_adapter,
+        [import_gguf, import_manifest],
+        [import_status, pool_table],
+        api_name=False,
+    ).then(refresh_all, None, refresh_outputs, api_name=False)
+
 
 if __name__ == "__main__":
     demo.queue().launch(

knowledge/__init__.py

@@ -1,18 +1,31 @@
-"""EvoLLM knowledge layer — RAG pipeline with multilingual embeddings.
+"""EvoLLM knowledge layer — RAG + LoRA-on-upload.
 
 Components:
-- parser   : PDF / TXT / MD / DOCX → clean text
-- chunker  : long text → overlapping ~400-token chunks
-- embedder : multilingual MiniLM via fastembed (no torch dependency)
-- store    : SQLite + numpy vector store
-- pipeline : high-level ingest / query API
+- parser             : PDF / TXT / MD / DOCX → clean text
+- chunker            : long text → overlapping ~400-token chunks
+- embedder           : fastembed wrapper (no torch dependency)
+- store              : SQLite + numpy vector store
+- pipeline           : high-level ingest / query API
+- dataset_builder    : doc chunks → training JSONL
+- notebook_generator : produce a Colab notebook with the dataset baked in
+- adapter_importer   : accept uploaded GGUF + manifest, register an adapter
 
-Local persistence at data/knowledge.sqlite. On HF Spaces the path is the
-container's ephemeral disk, so uploads vanish on rebuild — there's a visible
-notice in the UI explaining that.
+Local persistence at data/knowledge.sqlite + data/adapters/. On HF Spaces
+the path is the container's ephemeral disk, so uploads vanish on rebuild
+— there's a visible notice in the UI explaining that.
 """
 
+from .adapter_importer import import_adapter
+from .dataset_builder import build_dataset, write_jsonl
+from .notebook_generator import generate_training_notebook
 from .pipeline import KnowledgePipeline
 from .store import KnowledgeStore
 
-__all__ = ["KnowledgePipeline", "KnowledgeStore"]
+__all__ = [
+    "KnowledgePipeline",
+    "KnowledgeStore",
+    "build_dataset",
+    "write_jsonl",
+    "generate_training_notebook",
+    "import_adapter",
+]

knowledge/adapter_importer.py

@@ -0,0 +1,66 @@
+"""Import a trained LoRA adapter (GGUF + manifest) back into EvoLLM.
+
+The Colab notebook produced by notebook_generator.py emits two files
+at the end of a training run. The user re-uploads them via the
+'Import trained adapter' UI; we validate them, stash the GGUF, parse
+the manifest, and surface an AdapterRecord-shaped dict so the caller
+can register it in the live POOL + BANDIT.
+
+We don't actually load the LoRA into llama.cpp here — that happens in
+the local desktop app where reloading the Llama instance with
+lora_path=... is acceptable. On the HF Space the imported adapter
+joins the pool with its genome (system prompt + sampling), and the
+bandit can pick it like any other variant; the GGUF and manifest are
+stored for the local app's use.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+
+DEFAULT_ADAPTER_DIR = Path("data/adapters")
+
+
+def import_adapter(
+    gguf_path: str | Path,
+    manifest_path: str | Path,
+    dest_dir: str | Path = DEFAULT_ADAPTER_DIR,
+) -> dict:
+    """Validate + copy + return adapter info."""
+    gguf_path = Path(gguf_path)
+    manifest_path = Path(manifest_path)
+    dest_dir = Path(dest_dir)
+    dest_dir.mkdir(parents=True, exist_ok=True)
+
+    if not gguf_path.exists():
+        raise FileNotFoundError(f"Missing GGUF: {gguf_path}")
+    if not manifest_path.exists():
+        raise FileNotFoundError(f"Missing manifest: {manifest_path}")
+
+    try:
+        manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as e:
+        raise ValueError(f"Manifest is not valid JSON: {e}") from e
+
+    for required in ("adapter_id", "name", "base_model"):
+        if required not in manifest:
+            raise ValueError(f"Manifest missing required field: {required}")
+
+    adapter_id = manifest["adapter_id"]
+    dest_gguf = dest_dir / f"{adapter_id}.gguf"
+    dest_manifest = dest_dir / f"{adapter_id}.json"
+
+    shutil.copy(gguf_path, dest_gguf)
+    shutil.copy(manifest_path, dest_manifest)
+
+    return {
+        "adapter_id": adapter_id,
+        "name": manifest["name"],
+        "description": manifest.get("description", ""),
+        "base_model": manifest["base_model"],
+        "gguf_path": str(dest_gguf),
+        "manifest_path": str(dest_manifest),
+        "manifest": manifest,
+    }

knowledge/dataset_builder.py

@@ -0,0 +1,53 @@
+"""Convert indexed document chunks into a training dataset.
+
+Two output formats:
+  • text mode      : plain-LM continued pretraining ({"text": "..."} per row).
+                     Best for vocabulary/language acquisition (e.g. Creole).
+                     No teacher model required.
+  • instruction    : chat-style (system/user/assistant) where the user asks
+                     for content and the assistant emits the chunk text.
+                     Better for domain Q&A; still no teacher needed —
+                     the chunk content itself is the target.
+
+The pipeline writes JSONL because that's what trl.SFTTrainer ingests
+directly.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Iterable, Literal
+
+DatasetMode = Literal["text", "instruction"]
+
+
+def build_dataset(
+    chunks: Iterable[str],
+    mode: DatasetMode = "text",
+    system_prompt: str = "You are EvoLLM, fine-tuned on user-provided documents.",
+) -> list[dict]:
+    chunks = [c.strip() for c in chunks if c and c.strip()]
+    if mode == "text":
+        return [{"text": c} for c in chunks]
+    if mode == "instruction":
+        return [
+            {
+                "messages": [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": "Continue the passage in the style of the source material."},
+                    {"role": "assistant", "content": c},
+                ]
+            }
+            for c in chunks
+        ]
+    raise ValueError(f"Unknown dataset mode: {mode}")
+
+
+def write_jsonl(rows: list[dict], path: str | Path) -> Path:
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as f:
+        for row in rows:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+    return path

knowledge/notebook_generator.py

@@ -0,0 +1,237 @@
+"""Generate a self-contained Colab notebook that QLoRA-trains an adapter
+on the user's selected document chunks.
+
+The user downloads the .ipynb from the EvoLLM UI, opens it in Colab
+(free T4 is sufficient for small corpora), clicks 'Run all', and
+downloads two files at the end: the LoRA adapter as GGUF and a
+manifest.json. They re-upload both into EvoLLM via the 'Import trained
+adapter' button, and the new adapter joins the pool.
+"""
+
+from __future__ import annotations
+
+import json
+import uuid
+from datetime import datetime
+from pathlib import Path
+
+
+def _cell(cell_type: str, source: str) -> dict:
+    return {
+        "cell_type": cell_type,
+        "metadata": {},
+        "source": source.splitlines(keepends=True),
+        **({"execution_count": None, "outputs": []} if cell_type == "code" else {}),
+    }
+
+
+def generate_training_notebook(
+    adapter_name: str,
+    chunks: list[str],
+    source_doc_names: list[str],
+    base_model: str = "HuggingFaceTB/SmolLM2-1.7B-Instruct",
+    lora_rank: int = 16,
+    lora_alpha: int | None = None,
+    learning_rate: float = 2e-4,
+    num_epochs: int = 3,
+    batch_size: int = 2,
+    grad_accum: int = 4,
+    output_path: str | Path = "evollm_training_notebook.ipynb",
+    description: str = "",
+) -> Path:
+    """Produce a configured .ipynb the user can run on Colab."""
+    if lora_alpha is None:
+        lora_alpha = lora_rank * 2
+
+    adapter_id = f"user_{uuid.uuid4().hex[:8]}"
+    safe_adapter_name = adapter_name.strip() or adapter_id
+    created_at = datetime.utcnow().isoformat()
+
+    dataset_rows = [{"text": c} for c in chunks if c and c.strip()]
+
+    manifest = {
+        "adapter_id": adapter_id,
+        "name": safe_adapter_name,
+        "description": description or f"User-trained adapter on {len(source_doc_names)} document(s)",
+        "base_model": base_model,
+        "source_documents": source_doc_names,
+        "lora_rank": lora_rank,
+        "lora_alpha": lora_alpha,
+        "learning_rate": learning_rate,
+        "num_epochs": num_epochs,
+        "training_examples": len(dataset_rows),
+        "trained_at": created_at,
+        "trained_from_knowledge": True,
+    }
+
+    intro_md = f"""# EvoLLM — Train your own adapter
+
+This notebook produces a **{safe_adapter_name}** LoRA adapter from your
+selected documents.
+
+**Source documents**: {", ".join(source_doc_names) or "(none)"}
+**Base model**: `{base_model}`
+**LoRA rank**: {lora_rank}  (alpha = {lora_alpha})
+**Epochs**: {num_epochs}  ·  **LR**: {learning_rate}  ·  **Examples**: {len(dataset_rows)}
+
+## How to run
+
+1. **Runtime → Change runtime type → T4 GPU** (or A100 if you have Colab Pro).
+2. Click **Runtime → Run all**.
+3. When training finishes, you'll get two download links:
+   - `{adapter_id}.gguf`  — the LoRA adapter in llama.cpp format
+   - `{adapter_id}.json`  — the manifest
+4. Back in EvoLLM, go to the **🧬 Adapter Pool** tab → **📥 Import trained adapter** → drop both files.
+
+Approximate runtime on free T4: ~20–60 minutes for {len(dataset_rows)} examples.
+"""
+
+    setup_code = """!nvidia-smi
+!pip install -q -U \\
+    "transformers>=4.46" "peft>=0.13" "trl>=0.12" \\
+    "datasets>=3.1" "accelerate>=1.1" "bitsandbytes>=0.44" "sentencepiece"
+"""
+
+    config_code = f"""import json, gc, torch
+from pathlib import Path
+
+ADAPTER_ID = "{adapter_id}"
+ADAPTER_NAME = {json.dumps(safe_adapter_name)}
+BASE_MODEL = {json.dumps(base_model)}
+LORA_RANK = {lora_rank}
+LORA_ALPHA = {lora_alpha}
+LEARNING_RATE = {learning_rate}
+NUM_EPOCHS = {num_epochs}
+BATCH_SIZE = {batch_size}
+GRAD_ACCUM = {grad_accum}
+
+OUT_DIR = Path(f"/content/{{ADAPTER_ID}}")
+OUT_DIR.mkdir(parents=True, exist_ok=True)
+"""
+
+    # Inline the dataset as a JSON list. For small corpora this is fine;
+    # very large corpora should switch to a side file, but that's edge case.
+    dataset_code = "DATASET_ROWS = " + json.dumps(dataset_rows, ensure_ascii=False, indent=2)
+
+    manifest_code = (
+        "MANIFEST = " + json.dumps(manifest, ensure_ascii=False, indent=2)
+    )
+
+    train_code = """from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+from trl import SFTTrainer, SFTConfig
+from datasets import Dataset
+
+bnb = BitsAndBytesConfig(
+    load_in_4bit=True,
+    bnb_4bit_quant_type="nf4",
+    bnb_4bit_compute_dtype=torch.bfloat16,
+    bnb_4bit_use_double_quant=True,
+)
+
+print(f"Loading base: {BASE_MODEL}")
+tok = AutoTokenizer.from_pretrained(BASE_MODEL)
+if tok.pad_token is None:
+    tok.pad_token = tok.eos_token
+
+model = AutoModelForCausalLM.from_pretrained(
+    BASE_MODEL, quantization_config=bnb, device_map="auto", torch_dtype=torch.bfloat16,
+)
+model = prepare_model_for_kbit_training(model)
+
+peft_cfg = LoraConfig(
+    r=LORA_RANK, lora_alpha=LORA_ALPHA, lora_dropout=0.05,
+    bias="none", task_type="CAUSAL_LM",
+    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
+)
+model = get_peft_model(model, peft_cfg)
+model.print_trainable_parameters()
+
+ds = Dataset.from_list(DATASET_ROWS)
+
+cfg = SFTConfig(
+    output_dir=str(OUT_DIR),
+    num_train_epochs=NUM_EPOCHS,
+    per_device_train_batch_size=BATCH_SIZE,
+    gradient_accumulation_steps=GRAD_ACCUM,
+    learning_rate=LEARNING_RATE,
+    bf16=True,
+    logging_steps=10,
+    save_strategy="epoch",
+    save_total_limit=1,
+    report_to="none",
+    max_seq_length=1024,
+    warmup_ratio=0.03,
+    dataset_text_field="text",
+)
+
+trainer = SFTTrainer(model=model, tokenizer=tok, train_dataset=ds, args=cfg)
+trainer.train()
+trainer.save_model(str(OUT_DIR))
+print(f"\\nAdapter saved to {OUT_DIR}")
+
+del model, trainer; gc.collect(); torch.cuda.empty_cache()
+"""
+
+    convert_code = """# Convert the LoRA adapter to GGUF for llama.cpp
+!apt-get install -y -qq cmake build-essential
+!git clone --depth 1 https://github.com/ggerganov/llama.cpp /content/llama.cpp 2>/dev/null || echo 'already cloned'
+!pip install -q -r /content/llama.cpp/requirements/requirements-convert_lora_to_gguf.txt
+
+GGUF_PATH = OUT_DIR / f"{ADAPTER_ID}.gguf"
+!python /content/llama.cpp/convert_lora_to_gguf.py {OUT_DIR} --base {BASE_MODEL} --outfile {GGUF_PATH}
+
+print(f"\\nGGUF adapter at: {GGUF_PATH}")
+print(f"Size: {GGUF_PATH.stat().st_size / 1024 / 1024:.1f} MB")
+"""
+
+    package_code = """# Save manifest and prepare downloads
+import shutil
+
+manifest_path = OUT_DIR / f"{ADAPTER_ID}.json"
+manifest_path.write_text(json.dumps(MANIFEST, ensure_ascii=False, indent=2))
+
+# Stage the two files at /content for easy download
+shutil.copy(GGUF_PATH, f"/content/{ADAPTER_ID}.gguf")
+shutil.copy(manifest_path, f"/content/{ADAPTER_ID}.json")
+
+print("\\n" + "=" * 60)
+print("READY TO DOWNLOAD")
+print("=" * 60)
+print(f"  /content/{ADAPTER_ID}.gguf")
+print(f"  /content/{ADAPTER_ID}.json")
+print()
+print("In the Colab Files panel (left side), right-click each file → Download.")
+print("Then in EvoLLM: 🧬 Adapter Pool tab → 📥 Import trained adapter → drop both files.")
+"""
+
+    notebook = {
+        "cells": [
+            _cell("markdown", intro_md),
+            _cell("markdown", "## 0. Setup"),
+            _cell("code", setup_code),
+            _cell("markdown", "## 1. Configuration & dataset"),
+            _cell("code", config_code),
+            _cell("code", dataset_code),
+            _cell("code", manifest_code),
+            _cell("markdown", "## 2. Train"),
+            _cell("code", train_code),
+            _cell("markdown", "## 3. Convert to GGUF"),
+            _cell("code", convert_code),
+            _cell("markdown", "## 4. Package for EvoLLM"),
+            _cell("code", package_code),
+        ],
+        "metadata": {
+            "kernelspec": {"display_name": "Python 3", "language": "python", "name": "python3"},
+            "language_info": {"name": "python", "version": "3.10"},
+            "accelerator": "GPU",
+            "colab": {"provenance": [], "gpuType": "T4"},
+        },
+        "nbformat": 4,
+        "nbformat_minor": 4,
+    }
+
+    output_path = Path(output_path)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(json.dumps(notebook, ensure_ascii=False, indent=1))
+    return output_path