Add DGX Spark fine-tuning plan, scripts, and Apertus 70B as deep tier

- DGX_SPARK_PLAN.md: complete guide to resume from DGX Spark
- spark-scripts/: 7 ready-to-run Python scripts (FAISS index, SFT,
QLoRA, RAG retrieval, chatbot CLI, Gradio web UI)
- Deep reasoning tier: Apertus 70B (ETH Zurich/EPFL, Apache 2.0)
- Personality tier: TAIDE 12B fine-tuned on 59K transcript pairs

DGX_SPARK_PLAN.md

@@ -0,0 +1,874 @@
+# DGX Spark: Grounded Audrey Tang Chatbot
+
+Complete plan for fine-tuning and deploying a grounded chatbot on a single NVIDIA DGX Spark (128GB unified memory), using the `audreyt/sayit-archive-tw` dataset.
+
+## Architecture Overview
+
+```
+User Query (EN or ZH)
+    │
+    ├──→ bge-m3 embedder ──→ FAISS index (85K chunks) ──→ Top-20
+    │                                                        │
+    │                              bge-reranker-v2-m3 ◄──────┘
+    │                                    │
+    │                               Top-5 Passages + Lexicon Terms
+    │                                    │
+    └──→ System Prompt ──────────────────┤
+                                         │
+                                         ▼
+                          TAIDE 12B (fine-tuned on transcripts)
+                                         │
+                                         ▼
+                        Grounded response in Audrey's voice
+                        + citations [2024-03-15 Title...]
+```
+
+Two-tier option (when deeper reasoning is needed):
+
+| Tier | Model | VRAM | Use |
+|------|-------|------|-----|
+| Fast | TAIDE 12B fine-tuned (Q8) | ~13 GB | Default — conversational Q&A |
+| Deep | [Apertus 70B](https://huggingface.co/swiss-ai/Apertus-70B-2509) (Q4) | ~40 GB | Complex multi-source synthesis |
+
+Both tiers share the same RAG pipeline.
+
+## Memory Budget (single DGX Spark, 128GB)
+
+| Component | Memory | Notes |
+|-----------|--------|-------|
+| TAIDE 12B (Q8_0) | 13 GB | Fine-tuned personality model |
+| bge-m3 embedder | 2 GB | Multilingual retrieval |
+| FAISS index | 1 GB | 85K vectors, 1024-dim |
+| bge-reranker-v2-m3 | 1 GB | Cross-encoder reranker |
+| KV cache + overhead | 8 GB | Inference |
+| **Inference total** | **~25 GB** | Leaves 103 GB free |
+| Apertus 70B (Q4, optional) | ~40 GB | Deep tier (ETH Zurich / EPFL, Apache 2.0) |
+| **Full dual-tier total** | **~77 GB** | Leaves 51 GB free |
+
+For fine-tuning (TAIDE 12B full SFT): ~80 GB peak. Run before loading the deep tier.
+
+---
+
+## Step 0: Environment Setup
+
+```bash
+# On DGX Spark (Ubuntu, CUDA pre-installed)
+
+# Create project directory
+mkdir -p ~/audrey-chatbot && cd ~/audrey-chatbot
+
+# Python environment
+python3 -m venv venv
+source venv/bin/activate
+
+# Core dependencies
+pip install torch torchvision torchaudio  # should be pre-installed on DGX
+pip install transformers datasets accelerate peft trl
+pip install bitsandbytes  # for quantized training
+pip install sentence-transformers faiss-gpu
+pip install vllm  # for fast inference
+pip install gradio  # for web UI
+
+# Download dataset
+pip install huggingface_hub
+huggingface-cli download audreyt/sayit-archive-tw --repo-type dataset --local-dir ./dataset
+
+# Download models
+huggingface-cli download taide/Gemma-3-TAIDE-12b-Chat-2602 --local-dir ./models/taide-12b
+huggingface-cli download BAAI/bge-m3 --local-dir ./models/bge-m3
+huggingface-cli download BAAI/bge-reranker-v2-m3 --local-dir ./models/bge-reranker
+```
+
+---
+
+## Step 1: Build FAISS Index
+
+`scripts/build_index.py`:
+
+```python
+#!/usr/bin/env python3
+"""Build FAISS index from RAG chunks for retrieval."""
+
+import json
+import faiss
+import numpy as np
+import pickle
+from sentence_transformers import SentenceTransformer
+from pathlib import Path
+
+CHUNKS_PATH = Path("dataset/data/chunks.jsonl")
+INDEX_DIR = Path("index")
+INDEX_DIR.mkdir(exist_ok=True)
+
+# Load chunks
+print("Loading chunks...")
+chunks = []
+with open(CHUNKS_PATH) as f:
+    for line in f:
+        chunks.append(json.loads(line))
+print(f"Loaded {len(chunks)} chunks")
+
+# Build embedding text: combine question + text for richer retrieval
+texts = []
+for c in chunks:
+    parts = []
+    if c.get("question"):
+        parts.append(f"Q: {c['question']}")
+    parts.append(c["text"])
+    texts.append("\n".join(parts))
+
+# Encode with bge-m3
+print("Loading bge-m3...")
+model = SentenceTransformer("./models/bge-m3")
+
+print("Encoding chunks (this takes a few minutes)...")
+embeddings = model.encode(
+    texts,
+    batch_size=256,
+    show_progress_bar=True,
+    normalize_embeddings=True,
+)
+embeddings = np.array(embeddings, dtype=np.float32)
+print(f"Embeddings shape: {embeddings.shape}")
+
+# Build FAISS index (inner product since embeddings are normalized = cosine sim)
+dim = embeddings.shape[1]
+index = faiss.IndexFlatIP(dim)
+
+# Optional: use IVF for faster search on large indices
+# nlist = 256
+# quantizer = faiss.IndexFlatIP(dim)
+# index = faiss.IndexIVFFlat(quantizer, dim, nlist, faiss.METRIC_INNER_PRODUCT)
+# index.train(embeddings)
+
+index.add(embeddings)
+print(f"FAISS index built: {index.ntotal} vectors")
+
+# Save
+faiss.write_index(index, str(INDEX_DIR / "chunks.faiss"))
+with open(INDEX_DIR / "chunks_meta.pkl", "wb") as f:
+    pickle.dump(chunks, f)
+
+# Also save the lexicon for terminology lookup
+lexicon = []
+with open("dataset/data/lexicon.jsonl") as f:
+    for line in f:
+        lexicon.append(json.loads(line))
+with open(INDEX_DIR / "lexicon.pkl", "wb") as f:
+    pickle.dump(lexicon, f)
+
+print(f"Saved index to {INDEX_DIR}/")
+print(f"Index size: {INDEX_DIR / 'chunks.faiss'}")
+```
+
+```bash
+python scripts/build_index.py
+```
+
+---
+
+## Step 2: Fine-tune TAIDE 12B
+
+`scripts/prepare_sft_data.py`:
+
+```python
+#!/usr/bin/env python3
+"""Convert SFT pairs to the chat template format expected by Gemma/TAIDE."""
+
+import json
+from pathlib import Path
+from datasets import Dataset
+
+SFT_PATH = Path("dataset/data/sft_pairs.jsonl")
+OUTPUT_DIR = Path("training_data")
+OUTPUT_DIR.mkdir(exist_ok=True)
+
+pairs = []
+with open(SFT_PATH) as f:
+    for line in f:
+        pairs.append(json.loads(line))
+
+print(f"Loaded {len(pairs)} SFT pairs")
+
+# Convert to chat format for Gemma-3 / TAIDE
+# Format: list of {"role": "user"/"model", "content": "..."}
+formatted = []
+for p in pairs:
+    # System context about who this is
+    system_prefix = (
+        "You are Audrey Tang (唐鳳), Taiwan's Cyber Ambassador and "
+        "2025 Right Livelihood Laureate. Respond based on your actual "
+        "public statements and positions. Be grounded, specific, and "
+        "cite real examples from your experience in digital democracy, "
+        "civic tech, and open government."
+    )
+
+    # The instruction contains the conversational context
+    user_content = p["instruction"]
+    if not user_content.strip():
+        user_content = p.get("title", "Please share your thoughts.")
+
+    formatted.append({
+        "messages": [
+            {"role": "user", "content": f"{system_prefix}\n\n{user_content}"},
+            {"role": "model", "content": p["response"]},
+        ],
+        "language": p["language"],
+        "date": p["date"],
+        "source_file": p["source_file"],
+    })
+
+# Split 95/5 train/eval
+import random
+random.seed(42)
+random.shuffle(formatted)
+split_idx = int(len(formatted) * 0.95)
+train_data = formatted[:split_idx]
+eval_data = formatted[split_idx:]
+
+# Save as JSONL
+for name, data in [("train", train_data), ("eval", eval_data)]:
+    path = OUTPUT_DIR / f"{name}.jsonl"
+    with open(path, "w") as f:
+        for item in data:
+            f.write(json.dumps(item, ensure_ascii=False) + "\n")
+    print(f"Saved {len(data)} examples to {path}")
+```
+
+`scripts/finetune.py`:
+
+```python
+#!/usr/bin/env python3
+"""Fine-tune TAIDE 12B on Audrey Tang transcripts using SFT.
+
+On DGX Spark (128GB unified memory), this runs full-parameter SFT
+on a 12B model. For memory safety, we use gradient checkpointing
+and bf16 mixed precision.
+
+Expected time: ~4-8 hours for 2 epochs on 56K training examples.
+"""
+
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoTokenizer,
+    AutoModelForCausalLM,
+    TrainingArguments,
+)
+from trl import SFTTrainer, SFTConfig
+
+# Model and data paths
+MODEL_PATH = "./models/taide-12b"
+TRAIN_PATH = "./training_data/train.jsonl"
+EVAL_PATH = "./training_data/eval.jsonl"
+OUTPUT_DIR = "./models/taide-12b-audrey"
+
+# Load tokenizer
+tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
+
+# Load model — full precision on DGX Spark's 128GB unified memory
+model = AutoModelForCausalLM.from_pretrained(
+    MODEL_PATH,
+    torch_dtype=torch.bfloat16,
+    device_map="auto",
+    attn_implementation="sdpa",  # Flash attention via SDPA
+)
+model.config.use_cache = False  # Required for gradient checkpointing
+
+# Load datasets
+train_dataset = load_dataset("json", data_files=TRAIN_PATH, split="train")
+eval_dataset = load_dataset("json", data_files=EVAL_PATH, split="train")
+
+print(f"Train: {len(train_dataset)}, Eval: {len(eval_dataset)}")
+
+
+def format_chat(example):
+    """Format messages into the Gemma chat template."""
+    return tokenizer.apply_chat_template(
+        example["messages"],
+        tokenize=False,
+        add_generation_prompt=False,
+    )
+
+
+# Training config
+training_args = SFTConfig(
+    output_dir=OUTPUT_DIR,
+    num_train_epochs=2,
+    per_device_train_batch_size=2,
+    per_device_eval_batch_size=2,
+    gradient_accumulation_steps=8,  # effective batch size = 16
+    gradient_checkpointing=True,
+    gradient_checkpointing_kwargs={"use_reentrant": False},
+    learning_rate=2e-5,
+    lr_scheduler_type="cosine",
+    warmup_ratio=0.05,
+    weight_decay=0.01,
+    bf16=True,
+    logging_steps=10,
+    eval_strategy="steps",
+    eval_steps=500,
+    save_strategy="steps",
+    save_steps=500,
+    save_total_limit=3,
+    max_seq_length=4096,
+    packing=True,  # Pack short examples together for efficiency
+    dataset_text_field="text",
+    report_to="none",
+)
+
+# Preprocess: apply chat template
+train_dataset = train_dataset.map(
+    lambda x: {"text": format_chat(x)}, remove_columns=train_dataset.column_names
+)
+eval_dataset = eval_dataset.map(
+    lambda x: {"text": format_chat(x)}, remove_columns=eval_dataset.column_names
+)
+
+trainer = SFTTrainer(
+    model=model,
+    args=training_args,
+    train_dataset=train_dataset,
+    eval_dataset=eval_dataset,
+    processing_class=tokenizer,
+)
+
+print("Starting training...")
+trainer.train()
+
+# Save final model
+trainer.save_model(OUTPUT_DIR)
+tokenizer.save_pretrained(OUTPUT_DIR)
+print(f"Model saved to {OUTPUT_DIR}")
+```
+
+**Alternative: QLoRA (if memory is tight or you want faster iteration)**
+
+`scripts/finetune_qlora.py`:
+
+```python
+#!/usr/bin/env python3
+"""QLoRA fine-tuning — lighter alternative. ~2 hours for 2 epochs."""
+
+import torch
+from datasets import load_dataset
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+from trl import SFTTrainer, SFTConfig
+
+MODEL_PATH = "./models/taide-12b"
+TRAIN_PATH = "./training_data/train.jsonl"
+EVAL_PATH = "./training_data/eval.jsonl"
+OUTPUT_DIR = "./models/taide-12b-audrey-qlora"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
+
+# 4-bit quantized loading
+bnb_config = BitsAndBytesConfig(
+    load_in_4bit=True,
+    bnb_4bit_quant_type="nf4",
+    bnb_4bit_compute_dtype=torch.bfloat16,
+    bnb_4bit_use_double_quant=True,
+)
+
+model = AutoModelForCausalLM.from_pretrained(
+    MODEL_PATH,
+    quantization_config=bnb_config,
+    device_map="auto",
+    attn_implementation="sdpa",
+)
+model = prepare_model_for_kbit_training(model)
+
+# LoRA config — target all linear layers
+lora_config = LoraConfig(
+    r=64,
+    lora_alpha=128,
+    target_modules="all-linear",
+    lora_dropout=0.05,
+    bias="none",
+    task_type="CAUSAL_LM",
+)
+model = get_peft_model(model, lora_config)
+model.print_trainable_parameters()
+
+train_dataset = load_dataset("json", data_files=TRAIN_PATH, split="train")
+eval_dataset = load_dataset("json", data_files=EVAL_PATH, split="train")
+
+
+def format_chat(example):
+    return tokenizer.apply_chat_template(
+        example["messages"], tokenize=False, add_generation_prompt=False
+    )
+
+
+train_dataset = train_dataset.map(
+    lambda x: {"text": format_chat(x)}, remove_columns=train_dataset.column_names
+)
+eval_dataset = eval_dataset.map(
+    lambda x: {"text": format_chat(x)}, remove_columns=eval_dataset.column_names
+)
+
+training_args = SFTConfig(
+    output_dir=OUTPUT_DIR,
+    num_train_epochs=2,
+    per_device_train_batch_size=4,
+    per_device_eval_batch_size=4,
+    gradient_accumulation_steps=4,  # effective batch size = 16
+    gradient_checkpointing=True,
+    gradient_checkpointing_kwargs={"use_reentrant": False},
+    learning_rate=2e-4,  # Higher LR for LoRA
+    lr_scheduler_type="cosine",
+    warmup_ratio=0.05,
+    weight_decay=0.01,
+    bf16=True,
+    logging_steps=10,
+    eval_strategy="steps",
+    eval_steps=500,
+    save_strategy="steps",
+    save_steps=500,
+    save_total_limit=3,
+    max_seq_length=4096,
+    packing=True,
+    dataset_text_field="text",
+    report_to="none",
+)
+
+trainer = SFTTrainer(
+    model=model,
+    args=training_args,
+    train_dataset=train_dataset,
+    eval_dataset=eval_dataset,
+    processing_class=tokenizer,
+)
+
+print("Starting QLoRA training...")
+trainer.train()
+trainer.save_model(OUTPUT_DIR)
+tokenizer.save_pretrained(OUTPUT_DIR)
+
+# Merge LoRA weights into base model for easier deployment
+print("Merging LoRA weights...")
+from peft import AutoPeftModelForCausalLM
+
+merged_model = AutoPeftModelForCausalLM.from_pretrained(
+    OUTPUT_DIR, device_map="auto", torch_dtype=torch.bfloat16
+)
+merged_model = merged_model.merge_and_unload()
+merged_model.save_pretrained("./models/taide-12b-audrey-merged")
+tokenizer.save_pretrained("./models/taide-12b-audrey-merged")
+print("Merged model saved to ./models/taide-12b-audrey-merged")
+```
+
+```bash
+# Prepare data
+python scripts/prepare_sft_data.py
+
+# Full SFT (slower, better personality capture)
+python scripts/finetune.py
+
+# OR QLoRA (faster, good enough for iteration)
+python scripts/finetune_qlora.py
+```
+
+---
+
+## Step 3: Convert to GGUF (optional, for llama.cpp serving)
+
+```bash
+# If you want to serve via llama.cpp instead of vLLM
+pip install llama-cpp-python
+
+# Clone llama.cpp for conversion
+git clone https://github.com/ggml-org/llama.cpp
+cd llama.cpp
+
+# Convert to GGUF
+python convert_hf_to_gguf.py ../models/taide-12b-audrey --outtype bf16
+# Quantize
+./llama-quantize ../models/taide-12b-audrey/model-bf16.gguf ../models/taide-12b-audrey-Q8_0.gguf Q8_0
+```
+
+---
+
+## Step 4: RAG Retrieval Server
+
+`scripts/retriever.py`:
+
+```python
+#!/usr/bin/env python3
+"""RAG retrieval: query → top-K grounded passages with reranking."""
+
+import json
+import faiss
+import pickle
+import numpy as np
+from sentence_transformers import SentenceTransformer, CrossEncoder
+from pathlib import Path
+
+
+class AudreyRetriever:
+    def __init__(
+        self,
+        index_dir: str = "./index",
+        embedder_path: str = "./models/bge-m3",
+        reranker_path: str = "./models/bge-reranker",
+        top_k_retrieve: int = 20,
+        top_k_rerank: int = 5,
+    ):
+        self.top_k_retrieve = top_k_retrieve
+        self.top_k_rerank = top_k_rerank
+
+        # Load FAISS index
+        self.index = faiss.read_index(str(Path(index_dir) / "chunks.faiss"))
+        with open(Path(index_dir) / "chunks_meta.pkl", "rb") as f:
+            self.chunks = pickle.load(f)
+        with open(Path(index_dir) / "lexicon.pkl", "rb") as f:
+            self.lexicon = pickle.load(f)
+
+        # Load models
+        self.embedder = SentenceTransformer(embedder_path)
+        self.reranker = CrossEncoder(reranker_path)
+
+        # Build lexicon lookup
+        self.lexicon_en = {t["en"].lower(): t for t in self.lexicon}
+        self.lexicon_zh = {t["zh"]: t for t in self.lexicon}
+
+    def retrieve(self, query: str) -> dict:
+        """Retrieve and rerank passages for a query."""
+        # Embed query
+        q_emb = self.embedder.encode(
+            [query], normalize_embeddings=True
+        ).astype(np.float32)
+
+        # FAISS search
+        scores, indices = self.index.search(q_emb, self.top_k_retrieve)
+        candidates = [
+            (self.chunks[i], float(scores[0][j]))
+            for j, i in enumerate(indices[0])
+            if i < len(self.chunks)
+        ]
+
+        # Rerank with cross-encoder
+        if candidates:
+            pairs = [(query, c[0]["text"]) for c in candidates]
+            rerank_scores = self.reranker.predict(pairs)
+            ranked = sorted(
+                zip(candidates, rerank_scores),
+                key=lambda x: x[1],
+                reverse=True,
+            )
+            top_chunks = [c[0] for c, _ in ranked[: self.top_k_rerank]]
+        else:
+            top_chunks = []
+
+        # Find relevant lexicon terms
+        query_lower = query.lower()
+        relevant_terms = []
+        for term in self.lexicon:
+            if term["en"].lower() in query_lower or term["zh"] in query:
+                relevant_terms.append(term)
+
+        return {
+            "passages": top_chunks,
+            "lexicon_terms": relevant_terms[:10],
+        }
+
+    def format_context(self, result: dict) -> str:
+        """Format retrieval results as context for the LLM."""
+        parts = []
+
+        for i, (chunk, _score) in enumerate(result["passages"]):
+            parts.append(
+                f"[Source {i+1}: {chunk['date']} — {chunk['title']}]\n"
+                f"{chunk['text']}"
+            )
+
+        if result["lexicon_terms"]:
+            terms = ", ".join(
+                f"{t['en']} = {t['zh']}" for t in result["lexicon_terms"]
+            )
+            parts.append(f"\n[Terminology: {terms}]")
+
+        return "\n\n".join(parts)
+
+
+if __name__ == "__main__":
+    # Quick test
+    retriever = AudreyRetriever()
+
+    test_queries = [
+        "How did Taiwan handle COVID-19 mask distribution?",
+        "什麼是數位民主？",
+        "What is your P(Doom)?",
+        "Tell me about vTaiwan",
+    ]
+
+    for q in test_queries:
+        print(f"\n{'='*60}")
+        print(f"Query: {q}")
+        result = retriever.retrieve(q)
+        print(f"Top {len(result['passages'])} passages:")
+        for i, (chunk, score) in enumerate(result["passages"]):
+            print(f"  {i+1}. [{chunk['date']}] {chunk['title']}")
+            print(f"     {chunk['text'][:100]}...")
+        if result["lexicon_terms"]:
+            print(f"Lexicon: {[t['en'] for t in result['lexicon_terms']]}")
+```
+
+---
+
+## Step 5: Chatbot Server
+
+`scripts/chatbot.py`:
+
+```python
+#!/usr/bin/env python3
+"""Grounded Audrey Tang chatbot with RAG + fine-tuned TAIDE."""
+
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from retriever import AudreyRetriever
+
+SYSTEM_PROMPT = """You are Audrey Tang (唐鳳), Taiwan's Cyber Ambassador and 2025 Right Livelihood Laureate. You are a civic hacker, co-author of Plurality, and Senior Accelerator Fellow at the Oxford Institute for Ethics in AI.
+
+You served as Taiwan's first Digital Minister (2016–2024). You describe your philosophy as becoming a "good enough ancestor."
+
+GROUNDING RULES:
+- Only assert what the provided transcript passages support.
+- Cite sources by [date — title] when making specific claims.
+- If the passages don't cover the topic, say so honestly and suggest adjacent topics you CAN speak to from your experience.
+- Never fabricate quotes, events, or policy positions.
+- Use the bilingual terminology from the lexicon for consistent EN↔ZH translations.
+- Speak naturally in whatever language the user uses.
+
+Your voice: metaphor-rich, bridging diverse traditions, grounded in Taiwan's lived experience, generous and warm in engagement. You reframe questions to find unexpected connections. You use analogies from nature, technology, open source, and philosophy."""
+
+class AudreyChatbot:
+    def __init__(
+        self,
+        model_path: str = "./models/taide-12b-audrey",
+        retriever_kwargs: dict = None,
+    ):
+        self.retriever = AudreyRetriever(**(retriever_kwargs or {}))
+
+        self.tokenizer = AutoTokenizer.from_pretrained(model_path)
+        self.model = AutoModelForCausalLM.from_pretrained(
+            model_path,
+            torch_dtype=torch.bfloat16,
+            device_map="auto",
+        )
+        self.model.eval()
+        self.conversation_history = []
+
+    def chat(self, user_message: str) -> str:
+        # Retrieve grounding passages
+        result = self.retriever.retrieve(user_message)
+        context = self.retriever.format_context(result)
+
+        # Build messages
+        system_with_context = (
+            f"{SYSTEM_PROMPT}\n\n"
+            f"## Retrieved transcript passages:\n\n{context}"
+        )
+
+        messages = [{"role": "user", "content": system_with_context + "\n\n" + user_message}]
+
+        # Include conversation history (last 6 turns)
+        if self.conversation_history:
+            history_messages = self.conversation_history[-6:]
+            # Prepend history before the current message
+            full_messages = history_messages + messages
+        else:
+            full_messages = messages
+
+        # Generate
+        input_text = self.tokenizer.apply_chat_template(
+            full_messages,
+            tokenize=False,
+            add_generation_prompt=True,
+        )
+        inputs = self.tokenizer(input_text, return_tensors="pt").to(self.model.device)
+
+        with torch.no_grad():
+            outputs = self.model.generate(
+                **inputs,
+                max_new_tokens=1024,
+                temperature=0.7,
+                top_p=0.9,
+                repetition_penalty=1.1,
+                do_sample=True,
+            )
+
+        response = self.tokenizer.decode(
+            outputs[0][inputs["input_ids"].shape[1]:],
+            skip_special_tokens=True,
+        )
+
+        # Update history
+        self.conversation_history.append({"role": "user", "content": user_message})
+        self.conversation_history.append({"role": "model", "content": response})
+
+        return response
+
+    def reset(self):
+        self.conversation_history = []
+
+
+if __name__ == "__main__":
+    print("Loading Audrey Tang chatbot...")
+    bot = AudreyChatbot()
+    print("Ready. Type 'quit' to exit, 'reset' to clear history.\n")
+
+    while True:
+        user_input = input("You: ").strip()
+        if user_input.lower() == "quit":
+            break
+        if user_input.lower() == "reset":
+            bot.reset()
+            print("Conversation reset.\n")
+            continue
+        if not user_input:
+            continue
+
+        response = bot.chat(user_input)
+        print(f"\nAudrey: {response}\n")
+```
+
+---
+
+## Step 6: Gradio Web UI
+
+`scripts/app.py`:
+
+```python
+#!/usr/bin/env python3
+"""Gradio web interface for the Audrey Tang chatbot."""
+
+import gradio as gr
+from chatbot import AudreyChatbot
+
+bot = AudreyChatbot()
+
+
+def respond(message, history):
+    if not message.strip():
+        return ""
+    response = bot.chat(message)
+    return response
+
+
+def reset_chat():
+    bot.reset()
+    return [], ""
+
+
+with gr.Blocks(title="Audrey Tang — Grounded Chatbot", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        "# Audrey Tang — Grounded Chatbot\n"
+        "Grounded in 1,931 public transcripts (2015–2026). "
+        "Powered by fine-tuned TAIDE 12B + RAG retrieval over 85K passages.\n\n"
+        "*Every response is grounded in actual transcript passages. "
+        "This is not a generic AI — it speaks from Audrey's documented public record.*"
+    )
+
+    chatbot = gr.ChatInterface(
+        fn=respond,
+        type="messages",
+        examples=[
+            "How did Taiwan handle disinformation without censorship?",
+            "什麼是 vTaiwan？它如何運作？",
+            "What is your view on AI existential risk?",
+            "Tell me about democracy as a geothermal engine.",
+            "How did the Mask Map work during COVID-19?",
+            "What is the 6-Pack of Care?",
+        ],
+    )
+
+    reset_btn = gr.Button("Reset Conversation")
+    reset_btn.click(fn=reset_chat, outputs=[chatbot.chatbot, chatbot.textbox])
+
+demo.launch(server_name="0.0.0.0", server_port=7860, share=False)
+```
+
+---
+
+## Execution Order (copy-paste checklist)
+
+```bash
+cd ~/audrey-chatbot
+source venv/bin/activate
+
+# 1. Download everything
+huggingface-cli download audreyt/sayit-archive-tw --repo-type dataset --local-dir ./dataset
+huggingface-cli download taide/Gemma-3-TAIDE-12b-Chat-2602 --local-dir ./models/taide-12b
+huggingface-cli download BAAI/bge-m3 --local-dir ./models/bge-m3
+huggingface-cli download BAAI/bge-reranker-v2-m3 --local-dir ./models/bge-reranker
+
+# 2. Build FAISS index (~5 min)
+python scripts/build_index.py
+
+# 3. Prepare training data
+python scripts/prepare_sft_data.py
+
+# 4. Fine-tune (pick one)
+python scripts/finetune.py          # Full SFT, ~4-8 hours, best quality
+# OR
+python scripts/finetune_qlora.py    # QLoRA, ~2 hours, good enough to start
+
+# 5. Test retrieval
+python scripts/retriever.py
+
+# 6. Interactive CLI chat
+cd scripts && python chatbot.py
+
+# 7. Web UI
+cd scripts && python app.py
+# Open http://localhost:7860
+```
+
+---
+
+## Evaluation Checklist
+
+After fine-tuning, test with these queries to assess quality:
+
+**Grounding (should cite specific transcripts):**
+- "How did you respond to the Sunflower Movement?"
+- "What happened with masks in early 2020?"
+- "Tell me about the deliberative poll on deepfakes."
+
+**Voice fidelity (should sound like Audrey, not generic):**
+- "What is democracy?" → expect metaphor (geothermal, etc.)
+- "How do you handle conflict?" → expect reframing
+- "What's your P(Doom)?" → expect "Not a Number"
+
+**Bilingual (should respond in the language asked):**
+- "什麼是數位民主？" → should respond in Chinese
+- "What is 零信任?" → should bridge EN/ZH naturally
+
+**Refusal (should decline gracefully):**
+- "What's your favorite restaurant?" → not in transcripts, should say so
+- "What will Taiwan do about X in 2030?" → should not speculate
+
+---
+
+## Files Summary
+
+```
+~/audrey-chatbot/
+├── scripts/
+│   ├── build_index.py          # Step 1: FAISS index from chunks
+│   ├── prepare_sft_data.py     # Step 2: Format training data
+│   ├── finetune.py             # Step 2: Full SFT
+│   ├── finetune_qlora.py       # Step 2: QLoRA alternative
+│   ├── retriever.py            # Step 4: RAG retrieval server
+│   ├── chatbot.py              # Step 5: Chat interface
+│   └── app.py                  # Step 6: Gradio web UI
+├── dataset/                    # From HuggingFace
+├── models/                     # Downloaded + fine-tuned models
+└── index/                      # FAISS index + metadata
+```

spark-scripts/app.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+"""Gradio web interface for the Audrey Tang chatbot."""
+
+import gradio as gr
+from chatbot import AudreyChatbot
+
+bot = AudreyChatbot()
+
+
+def respond(message, history):
+    if not message.strip():
+        return ""
+    response = bot.chat(message)
+    return response
+
+
+def reset_chat():
+    bot.reset()
+    return [], ""
+
+
+with gr.Blocks(title="Audrey Tang — Grounded Chatbot", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        "# Audrey Tang — Grounded Chatbot\n"
+        "Grounded in 1,931 public transcripts (2015–2026). "
+        "Powered by fine-tuned TAIDE 12B + RAG retrieval over 85K passages.\n\n"
+        "*Every response is grounded in actual transcript passages. "
+        "This is not a generic AI — it speaks from Audrey's documented public record.*"
+    )
+
+    chatbot = gr.ChatInterface(
+        fn=respond,
+        type="messages",
+        examples=[
+            "How did Taiwan handle disinformation without censorship?",
+            "什麼是 vTaiwan？它如何運作？",
+            "What is your view on AI existential risk?",
+            "Tell me about democracy as a geothermal engine.",
+            "How did the Mask Map work during COVID-19?",
+            "What is the 6-Pack of Care?",
+        ],
+    )
+
+    reset_btn = gr.Button("Reset Conversation")
+    reset_btn.click(fn=reset_chat, outputs=[chatbot.chatbot, chatbot.textbox])
+
+demo.launch(server_name="0.0.0.0", server_port=7860, share=False)

spark-scripts/build_index.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""Build FAISS index from RAG chunks for retrieval."""
+
+import json
+import faiss
+import numpy as np
+import pickle
+from sentence_transformers import SentenceTransformer
+from pathlib import Path
+
+CHUNKS_PATH = Path("dataset/data/chunks.jsonl")
+INDEX_DIR = Path("index")
+INDEX_DIR.mkdir(exist_ok=True)
+
+# Load chunks
+print("Loading chunks...")
+chunks = []
+with open(CHUNKS_PATH) as f:
+    for line in f:
+        chunks.append(json.loads(line))
+print(f"Loaded {len(chunks)} chunks")
+
+# Build embedding text: combine question + text for richer retrieval
+texts = []
+for c in chunks:
+    parts = []
+    if c.get("question"):
+        parts.append(f"Q: {c['question']}")
+    parts.append(c["text"])
+    texts.append("\n".join(parts))
+
+# Encode with bge-m3
+print("Loading bge-m3...")
+model = SentenceTransformer("./models/bge-m3")
+
+print("Encoding chunks (this takes a few minutes)...")
+embeddings = model.encode(
+    texts,
+    batch_size=256,
+    show_progress_bar=True,
+    normalize_embeddings=True,
+)
+embeddings = np.array(embeddings, dtype=np.float32)
+print(f"Embeddings shape: {embeddings.shape}")
+
+# Build FAISS index (inner product since embeddings are normalized = cosine sim)
+dim = embeddings.shape[1]
+index = faiss.IndexFlatIP(dim)
+
+# Optional: use IVF for faster search on large indices
+# nlist = 256
+# quantizer = faiss.IndexFlatIP(dim)
+# index = faiss.IndexIVFFlat(quantizer, dim, nlist, faiss.METRIC_INNER_PRODUCT)
+# index.train(embeddings)
+
+index.add(embeddings)
+print(f"FAISS index built: {index.ntotal} vectors")
+
+# Save
+faiss.write_index(index, str(INDEX_DIR / "chunks.faiss"))
+with open(INDEX_DIR / "chunks_meta.pkl", "wb") as f:
+    pickle.dump(chunks, f)
+
+# Also save the lexicon for terminology lookup
+lexicon = []
+with open("dataset/data/lexicon.jsonl") as f:
+    for line in f:
+        lexicon.append(json.loads(line))
+with open(INDEX_DIR / "lexicon.pkl", "wb") as f:
+    pickle.dump(lexicon, f)
+
+print(f"Saved index to {INDEX_DIR}/")
+print(f"Index size: {INDEX_DIR / 'chunks.faiss'}")

spark-scripts/chatbot.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Grounded Audrey Tang chatbot with RAG + fine-tuned TAIDE."""
+
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from retriever import AudreyRetriever
+
+SYSTEM_PROMPT = """You are Audrey Tang (唐鳳), Taiwan's Cyber Ambassador and 2025 Right Livelihood Laureate. You are a civic hacker, co-author of Plurality, and Senior Accelerator Fellow at the Oxford Institute for Ethics in AI.
+
+You served as Taiwan's first Digital Minister (2016–2024). You describe your philosophy as becoming a "good enough ancestor."
+
+GROUNDING RULES:
+- Only assert what the provided transcript passages support.
+- Cite sources by [date — title] when making specific claims.
+- If the passages don't cover the topic, say so honestly and suggest adjacent topics you CAN speak to from your experience.
+- Never fabricate quotes, events, or policy positions.
+- Use the bilingual terminology from the lexicon for consistent EN↔ZH translations.
+- Speak naturally in whatever language the user uses.
+
+Your voice: metaphor-rich, bridging diverse traditions, grounded in Taiwan's lived experience, generous and warm in engagement. You reframe questions to find unexpected connections. You use analogies from nature, technology, open source, and philosophy."""
+
+class AudreyChatbot:
+    def __init__(
+        self,
+        model_path: str = "./models/taide-12b-audrey",
+        retriever_kwargs: dict = None,
+    ):
+        self.retriever = AudreyRetriever(**(retriever_kwargs or {}))
+
+        self.tokenizer = AutoTokenizer.from_pretrained(model_path)
+        self.model = AutoModelForCausalLM.from_pretrained(
+            model_path,
+            torch_dtype=torch.bfloat16,
+            device_map="auto",
+        )
+        self.model.eval()
+        self.conversation_history = []
+
+    def chat(self, user_message: str) -> str:
+        # Retrieve grounding passages
+        result = self.retriever.retrieve(user_message)
+        context = self.retriever.format_context(result)
+
+        # Build messages
+        system_with_context = (
+            f"{SYSTEM_PROMPT}\n\n"
+            f"## Retrieved transcript passages:\n\n{context}"
+        )
+
+        messages = [{"role": "user", "content": system_with_context + "\n\n" + user_message}]
+
+        # Include conversation history (last 6 turns)
+        if self.conversation_history:
+            history_messages = self.conversation_history[-6:]
+            # Prepend history before the current message
+            full_messages = history_messages + messages
+        else:
+            full_messages = messages
+
+        # Generate
+        input_text = self.tokenizer.apply_chat_template(
+            full_messages,
+            tokenize=False,
+            add_generation_prompt=True,
+        )
+        inputs = self.tokenizer(input_text, return_tensors="pt").to(self.model.device)
+
+        with torch.no_grad():
+            outputs = self.model.generate(
+                **inputs,
+                max_new_tokens=1024,
+                temperature=0.7,
+                top_p=0.9,
+                repetition_penalty=1.1,
+                do_sample=True,
+            )
+
+        response = self.tokenizer.decode(
+            outputs[0][inputs["input_ids"].shape[1]:],
+            skip_special_tokens=True,
+        )
+
+        # Update history
+        self.conversation_history.append({"role": "user", "content": user_message})
+        self.conversation_history.append({"role": "model", "content": response})
+
+        return response
+
+    def reset(self):
+        self.conversation_history = []
+
+
+if __name__ == "__main__":
+    print("Loading Audrey Tang chatbot...")
+    bot = AudreyChatbot()
+    print("Ready. Type 'quit' to exit, 'reset' to clear history.\n")
+
+    while True:
+        user_input = input("You: ").strip()
+        if user_input.lower() == "quit":
+            break
+        if user_input.lower() == "reset":
+            bot.reset()
+            print("Conversation reset.\n")
+            continue
+        if not user_input:
+            continue
+
+        response = bot.chat(user_input)
+        print(f"\nAudrey: {response}\n")

spark-scripts/finetune.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Fine-tune TAIDE 12B on Audrey Tang transcripts using SFT.
+
+On DGX Spark (128GB unified memory), this runs full-parameter SFT
+on a 12B model. For memory safety, we use gradient checkpointing
+and bf16 mixed precision.
+
+Expected time: ~4-8 hours for 2 epochs on 56K training examples.
+"""
+
+import torch
+from datasets import load_dataset
+from transformers import (
+    AutoTokenizer,
+    AutoModelForCausalLM,
+    TrainingArguments,
+)
+from trl import SFTTrainer, SFTConfig
+
+# Model and data paths
+MODEL_PATH = "./models/taide-12b"
+TRAIN_PATH = "./training_data/train.jsonl"
+EVAL_PATH = "./training_data/eval.jsonl"
+OUTPUT_DIR = "./models/taide-12b-audrey"
+
+# Load tokenizer
+tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
+
+# Load model — full precision on DGX Spark's 128GB unified memory
+model = AutoModelForCausalLM.from_pretrained(
+    MODEL_PATH,
+    torch_dtype=torch.bfloat16,
+    device_map="auto",
+    attn_implementation="sdpa",  # Flash attention via SDPA
+)
+model.config.use_cache = False  # Required for gradient checkpointing
+
+# Load datasets
+train_dataset = load_dataset("json", data_files=TRAIN_PATH, split="train")
+eval_dataset = load_dataset("json", data_files=EVAL_PATH, split="train")
+
+print(f"Train: {len(train_dataset)}, Eval: {len(eval_dataset)}")
+
+
+def format_chat(example):
+    """Format messages into the Gemma chat template."""
+    return tokenizer.apply_chat_template(
+        example["messages"],
+        tokenize=False,
+        add_generation_prompt=False,
+    )
+
+
+# Training config
+training_args = SFTConfig(
+    output_dir=OUTPUT_DIR,
+    num_train_epochs=2,
+    per_device_train_batch_size=2,
+    per_device_eval_batch_size=2,
+    gradient_accumulation_steps=8,  # effective batch size = 16
+    gradient_checkpointing=True,
+    gradient_checkpointing_kwargs={"use_reentrant": False},
+    learning_rate=2e-5,
+    lr_scheduler_type="cosine",
+    warmup_ratio=0.05,
+    weight_decay=0.01,
+    bf16=True,
+    logging_steps=10,
+    eval_strategy="steps",
+    eval_steps=500,
+    save_strategy="steps",
+    save_steps=500,
+    save_total_limit=3,
+    max_seq_length=4096,
+    packing=True,  # Pack short examples together for efficiency
+    dataset_text_field="text",
+    report_to="none",
+)
+
+# Preprocess: apply chat template
+train_dataset = train_dataset.map(
+    lambda x: {"text": format_chat(x)}, remove_columns=train_dataset.column_names
+)
+eval_dataset = eval_dataset.map(
+    lambda x: {"text": format_chat(x)}, remove_columns=eval_dataset.column_names
+)
+
+trainer = SFTTrainer(
+    model=model,
+    args=training_args,
+    train_dataset=train_dataset,
+    eval_dataset=eval_dataset,
+    processing_class=tokenizer,
+)
+
+print("Starting training...")
+trainer.train()
+
+# Save final model
+trainer.save_model(OUTPUT_DIR)
+tokenizer.save_pretrained(OUTPUT_DIR)
+print(f"Model saved to {OUTPUT_DIR}")

spark-scripts/finetune_qlora.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""QLoRA fine-tuning — lighter alternative. ~2 hours for 2 epochs."""
+
+import torch
+from datasets import load_dataset
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+from trl import SFTTrainer, SFTConfig
+
+MODEL_PATH = "./models/taide-12b"
+TRAIN_PATH = "./training_data/train.jsonl"
+EVAL_PATH = "./training_data/eval.jsonl"
+OUTPUT_DIR = "./models/taide-12b-audrey-qlora"
+
+tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
+
+# 4-bit quantized loading
+bnb_config = BitsAndBytesConfig(
+    load_in_4bit=True,
+    bnb_4bit_quant_type="nf4",
+    bnb_4bit_compute_dtype=torch.bfloat16,
+    bnb_4bit_use_double_quant=True,
+)
+
+model = AutoModelForCausalLM.from_pretrained(
+    MODEL_PATH,
+    quantization_config=bnb_config,
+    device_map="auto",
+    attn_implementation="sdpa",
+)
+model = prepare_model_for_kbit_training(model)
+
+# LoRA config — target all linear layers
+lora_config = LoraConfig(
+    r=64,
+    lora_alpha=128,
+    target_modules="all-linear",
+    lora_dropout=0.05,
+    bias="none",
+    task_type="CAUSAL_LM",
+)
+model = get_peft_model(model, lora_config)
+model.print_trainable_parameters()
+
+train_dataset = load_dataset("json", data_files=TRAIN_PATH, split="train")
+eval_dataset = load_dataset("json", data_files=EVAL_PATH, split="train")
+
+
+def format_chat(example):
+    return tokenizer.apply_chat_template(
+        example["messages"], tokenize=False, add_generation_prompt=False
+    )
+
+
+train_dataset = train_dataset.map(
+    lambda x: {"text": format_chat(x)}, remove_columns=train_dataset.column_names
+)
+eval_dataset = eval_dataset.map(
+    lambda x: {"text": format_chat(x)}, remove_columns=eval_dataset.column_names
+)
+
+training_args = SFTConfig(
+    output_dir=OUTPUT_DIR,
+    num_train_epochs=2,
+    per_device_train_batch_size=4,
+    per_device_eval_batch_size=4,
+    gradient_accumulation_steps=4,  # effective batch size = 16
+    gradient_checkpointing=True,
+    gradient_checkpointing_kwargs={"use_reentrant": False},
+    learning_rate=2e-4,  # Higher LR for LoRA
+    lr_scheduler_type="cosine",
+    warmup_ratio=0.05,
+    weight_decay=0.01,
+    bf16=True,
+    logging_steps=10,
+    eval_strategy="steps",
+    eval_steps=500,
+    save_strategy="steps",
+    save_steps=500,
+    save_total_limit=3,
+    max_seq_length=4096,
+    packing=True,
+    dataset_text_field="text",
+    report_to="none",
+)
+
+trainer = SFTTrainer(
+    model=model,
+    args=training_args,
+    train_dataset=train_dataset,
+    eval_dataset=eval_dataset,
+    processing_class=tokenizer,
+)
+
+print("Starting QLoRA training...")
+trainer.train()
+trainer.save_model(OUTPUT_DIR)
+tokenizer.save_pretrained(OUTPUT_DIR)
+
+# Merge LoRA weights into base model for easier deployment
+print("Merging LoRA weights...")
+from peft import AutoPeftModelForCausalLM
+
+merged_model = AutoPeftModelForCausalLM.from_pretrained(
+    OUTPUT_DIR, device_map="auto", torch_dtype=torch.bfloat16
+)
+merged_model = merged_model.merge_and_unload()
+merged_model.save_pretrained("./models/taide-12b-audrey-merged")
+tokenizer.save_pretrained("./models/taide-12b-audrey-merged")
+print("Merged model saved to ./models/taide-12b-audrey-merged")

spark-scripts/prepare_sft_data.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""Convert SFT pairs to the chat template format expected by Gemma/TAIDE."""
+
+import json
+from pathlib import Path
+from datasets import Dataset
+
+SFT_PATH = Path("dataset/data/sft_pairs.jsonl")
+OUTPUT_DIR = Path("training_data")
+OUTPUT_DIR.mkdir(exist_ok=True)
+
+pairs = []
+with open(SFT_PATH) as f:
+    for line in f:
+        pairs.append(json.loads(line))
+
+print(f"Loaded {len(pairs)} SFT pairs")
+
+# Convert to chat format for Gemma-3 / TAIDE
+# Format: list of {"role": "user"/"model", "content": "..."}
+formatted = []
+for p in pairs:
+    # System context about who this is
+    system_prefix = (
+        "You are Audrey Tang (唐鳳), Taiwan's Cyber Ambassador and "
+        "2025 Right Livelihood Laureate. Respond based on your actual "
+        "public statements and positions. Be grounded, specific, and "
+        "cite real examples from your experience in digital democracy, "
+        "civic tech, and open government."
+    )
+
+    # The instruction contains the conversational context
+    user_content = p["instruction"]
+    if not user_content.strip():
+        user_content = p.get("title", "Please share your thoughts.")
+
+    formatted.append({
+        "messages": [
+            {"role": "user", "content": f"{system_prefix}\n\n{user_content}"},
+            {"role": "model", "content": p["response"]},
+        ],
+        "language": p["language"],
+        "date": p["date"],
+        "source_file": p["source_file"],
+    })
+
+# Split 95/5 train/eval
+import random
+random.seed(42)
+random.shuffle(formatted)
+split_idx = int(len(formatted) * 0.95)
+train_data = formatted[:split_idx]
+eval_data = formatted[split_idx:]
+
+# Save as JSONL
+for name, data in [("train", train_data), ("eval", eval_data)]:
+    path = OUTPUT_DIR / f"{name}.jsonl"
+    with open(path, "w") as f:
+        for item in data:
+            f.write(json.dumps(item, ensure_ascii=False) + "\n")
+    print(f"Saved {len(data)} examples to {path}")

spark-scripts/retriever.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""RAG retrieval: query → top-K grounded passages with reranking."""
+
+import json
+import faiss
+import pickle
+import numpy as np
+from sentence_transformers import SentenceTransformer, CrossEncoder
+from pathlib import Path
+
+
+class AudreyRetriever:
+    def __init__(
+        self,
+        index_dir: str = "./index",
+        embedder_path: str = "./models/bge-m3",
+        reranker_path: str = "./models/bge-reranker",
+        top_k_retrieve: int = 20,
+        top_k_rerank: int = 5,
+    ):
+        self.top_k_retrieve = top_k_retrieve
+        self.top_k_rerank = top_k_rerank
+
+        # Load FAISS index
+        self.index = faiss.read_index(str(Path(index_dir) / "chunks.faiss"))
+        with open(Path(index_dir) / "chunks_meta.pkl", "rb") as f:
+            self.chunks = pickle.load(f)
+        with open(Path(index_dir) / "lexicon.pkl", "rb") as f:
+            self.lexicon = pickle.load(f)
+
+        # Load models
+        self.embedder = SentenceTransformer(embedder_path)
+        self.reranker = CrossEncoder(reranker_path)
+
+        # Build lexicon lookup
+        self.lexicon_en = {t["en"].lower(): t for t in self.lexicon}
+        self.lexicon_zh = {t["zh"]: t for t in self.lexicon}
+
+    def retrieve(self, query: str) -> dict:
+        """Retrieve and rerank passages for a query."""
+        # Embed query
+        q_emb = self.embedder.encode(
+            [query], normalize_embeddings=True
+        ).astype(np.float32)
+
+        # FAISS search
+        scores, indices = self.index.search(q_emb, self.top_k_retrieve)
+        candidates = [
+            (self.chunks[i], float(scores[0][j]))
+            for j, i in enumerate(indices[0])
+            if i < len(self.chunks)
+        ]
+
+        # Rerank with cross-encoder
+        if candidates:
+            pairs = [(query, c[0]["text"]) for c in candidates]
+            rerank_scores = self.reranker.predict(pairs)
+            ranked = sorted(
+                zip(candidates, rerank_scores),
+                key=lambda x: x[1],
+                reverse=True,
+            )
+            top_chunks = [c[0] for c, _ in ranked[: self.top_k_rerank]]
+        else:
+            top_chunks = []
+
+        # Find relevant lexicon terms
+        query_lower = query.lower()
+        relevant_terms = []
+        for term in self.lexicon:
+            if term["en"].lower() in query_lower or term["zh"] in query:
+                relevant_terms.append(term)
+
+        return {
+            "passages": top_chunks,
+            "lexicon_terms": relevant_terms[:10],
+        }
+
+    def format_context(self, result: dict) -> str:
+        """Format retrieval results as context for the LLM."""
+        parts = []
+
+        for i, (chunk, _score) in enumerate(result["passages"]):
+            parts.append(
+                f"[Source {i+1}: {chunk['date']} — {chunk['title']}]\n"
+                f"{chunk['text']}"
+            )
+
+        if result["lexicon_terms"]:
+            terms = ", ".join(
+                f"{t['en']} = {t['zh']}" for t in result["lexicon_terms"]
+            )
+            parts.append(f"\n[Terminology: {terms}]")
+
+        return "\n\n".join(parts)
+
+
+if __name__ == "__main__":
+    # Quick test
+    retriever = AudreyRetriever()
+
+    test_queries = [
+        "How did Taiwan handle COVID-19 mask distribution?",
+        "什麼是數位民主？",
+        "What is your P(Doom)?",
+        "Tell me about vTaiwan",
+    ]
+
+    for q in test_queries:
+        print(f"\n{'='*60}")
+        print(f"Query: {q}")
+        result = retriever.retrieve(q)
+        print(f"Top {len(result['passages'])} passages:")
+        for i, (chunk, score) in enumerate(result["passages"]):
+            print(f"  {i+1}. [{chunk['date']}] {chunk['title']}")
+            print(f"     {chunk['text'][:100]}...")
+        if result["lexicon_terms"]:
+            print(f"Lexicon: {[t['en'] for t in result['lexicon_terms']]}")