Upload 4 files

README.md

@@ -1,14 +1,97 @@
 ---
-title: Rfab Historic Gpt 1900
-emoji: 🔥
-colorFrom: indigo
-colorTo: indigo
+title: RFAB Historic Chat Space
+emoji: 🕰️
+colorFrom: blue
+colorTo: purple
 sdk: gradio
-sdk_version: 6.14.0
-python_version: '3.13'
+sdk_version: 5.49.1
 app_file: app.py
 pinned: false
-license: mit
+models:
+  - Pclanglais/MonadGPT
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# RFAB Historic Chat Gradio Space Template
+
+This template exposes the same Gradio API shape used by Talkie-1930:
+
+- `POST /gradio_api/call/v2/_bot_reply`
+- `GET /gradio_api/call/_bot_reply/{event_id}`
+
+The Reality Fabricator backend expects `_bot_reply` to accept named params:
+
+- `history`
+- `system_prompt`
+- `temperature`
+- `max_tokens`
+- `top_p`
+- `top_k`
+
+## Required Variables
+
+Set these in the Space settings:
+
+```bash
+RFAB_HISTORIC_MODEL_ID=Pclanglais/MonadGPT
+RFAB_HISTORIC_ADAPTER=transformers
+DRY_RUN=true
+```
+
+For real model inference, set `DRY_RUN=false` and choose suitable hardware.
+
+## Model Presets
+
+MonadGPT:
+
+```bash
+RFAB_HISTORIC_MODEL_ID=Pclanglais/MonadGPT
+RFAB_HISTORIC_ADAPTER=transformers
+RFAB_HISTORIC_MODEL_KWARGS={"torch_dtype":"auto","device_map":"auto"}
+```
+
+TimeCapsule:
+
+```bash
+RFAB_HISTORIC_MODEL_ID=haykgrigorian/TimeCapsuleLLM-v2-llama-1.2B
+RFAB_HISTORIC_ADAPTER=transformers
+```
+
+GPT-1900:
+
+```bash
+RFAB_HISTORIC_MODEL_ID=mhla/gpt1900-instruct-v3-sft
+RFAB_HISTORIC_ADAPTER=transformers
+```
+
+Mr. Chatterbox:
+
+```bash
+RFAB_HISTORIC_MODEL_ID=tventurella/mr_chatterbox_model
+RFAB_HISTORIC_ADAPTER=nanochat
+RFAB_NANOCHAT_MODEL_TAG=d18
+RFAB_NANOCHAT_SOURCE=sft
+```
+
+The `nanochat` adapter is scaffolded for the Mr. Chatterbox code path. The Space must include the same nanochat package/checkpoint layout as `tventurella/mr_chatterbox` before `DRY_RUN=false`.
+
+## Hardware
+
+- CPU Basic is free and good for build/API contract testing.
+- ZeroGPU requires a personal PRO account or qualifying Team/organization setup.
+- The same Space can be upgraded later in Settings or through `huggingface_hub`; hardware changes restart the Space.
+- Keep `@spaces.GPU` in `app.py`; it is effect-free outside ZeroGPU and required once ZeroGPU is selected.
+
+## Backend Activation
+
+After the Space is live:
+
+```bash
+curl https://<space>.hf.space/gradio_api/info
+npm run smoke:historic-hf -- --model <model>
+```
+
+Copy the smoke JSON into `HISTORIC_HF_SMOKE_RESULTS_JSON` and set the matching backend URL env var, for example:
+
+```bash
+HISTORIC_HF_SPACE_URL_MONAD_GPT=https://rfab-historic-monad-gpt.hf.space
+```

app.py

@@ -0,0 +1,124 @@
+import os
+
+import gradio as gr
+
+try:
+    import spaces
+except Exception:
+    spaces = None
+
+from model_adapters import create_adapter
+
+
+MODEL_LABEL = os.getenv("RFAB_HISTORIC_MODEL_LABEL", os.getenv("RFAB_HISTORIC_MODEL_ID", "RFAB Historic Model"))
+GPU_DURATION_SECONDS = int(os.getenv("RFAB_GPU_DURATION_SECONDS", "60"))
+
+adapter = create_adapter()
+
+
+def gpu(fn):
+    if spaces is None:
+        return fn
+    return spaces.GPU(duration=GPU_DURATION_SECONDS)(fn)
+
+
+def normalize_history(history):
+    if not isinstance(history, list):
+        return []
+
+    normalized = []
+    for message in history:
+        if not isinstance(message, dict):
+            continue
+        role = message.get("role")
+        if role not in {"user", "assistant"}:
+            continue
+        content = message.get("content") or []
+        if isinstance(content, str):
+            content = [{"type": "text", "text": content}]
+        normalized.append({
+            "role": role,
+            "metadata": message.get("metadata"),
+            "content": content,
+            "options": message.get("options")
+        })
+    return normalized
+
+
+@gpu
+def _bot_reply(history, system_prompt="", temperature=0.7, max_tokens=256, top_p=1.0, top_k=0):
+    history = normalize_history(history)
+    answer = adapter.generate(
+        history=history,
+        system_prompt=system_prompt or "",
+        temperature=float(temperature),
+        max_tokens=int(max_tokens),
+        top_p=float(top_p),
+        top_k=int(top_k),
+    )
+    history.append({
+        "role": "assistant",
+        "metadata": None,
+        "content": [{"type": "text", "text": answer}],
+        "options": None
+    })
+    return history
+
+
+def preview_reply(message, system_prompt, temperature, max_tokens):
+    history = [{
+        "role": "user",
+        "metadata": None,
+        "content": [{"type": "text", "text": message}],
+        "options": None
+    }]
+    result = _bot_reply(history, system_prompt, temperature, max_tokens, 1.0, 0)
+    return result[-1]["content"][0]["text"] if result else ""
+
+
+with gr.Blocks(title=MODEL_LABEL) as demo:
+    gr.Markdown(f"# {MODEL_LABEL}")
+    gr.Markdown("Reality Fabricator Historic Chat Space. The backend uses the `_bot_reply` API endpoint.")
+
+    with gr.Row():
+        user_message = gr.Textbox(label="Message", value="What is electricity?")
+    with gr.Row():
+        system_prompt_box = gr.Textbox(label="System prompt", value="")
+    with gr.Row():
+        temperature_slider = gr.Slider(0.0, 2.0, value=0.7, step=0.05, label="Temperature")
+        max_tokens_slider = gr.Slider(16, 1024, value=256, step=1, label="Max tokens")
+    preview_button = gr.Button("Generate")
+    preview_output = gr.Textbox(label="Response")
+
+    preview_button.click(
+        preview_reply,
+        inputs=[user_message, system_prompt_box, temperature_slider, max_tokens_slider],
+        outputs=preview_output,
+        api_name=False,
+    )
+
+    history_input = gr.JSON(visible=False)
+    system_prompt_input = gr.Textbox(visible=False)
+    temperature_input = gr.Number(visible=False)
+    max_tokens_input = gr.Number(visible=False)
+    top_p_input = gr.Number(visible=False)
+    top_k_input = gr.Number(visible=False)
+    history_output = gr.JSON(visible=False)
+
+    gr.Button("API", visible=False).click(
+        _bot_reply,
+        inputs=[
+            history_input,
+            system_prompt_input,
+            temperature_input,
+            max_tokens_input,
+            top_p_input,
+            top_k_input,
+        ],
+        outputs=history_output,
+        api_name="_bot_reply",
+    )
+
+
+if __name__ == "__main__":
+    demo.queue().launch()

model_adapters.py

@@ -0,0 +1,132 @@
+import json
+import os
+from typing import Any, Dict, List
+
+
+def env_bool(name: str, default: bool = False) -> bool:
+    value = os.getenv(name)
+    if value is None:
+        return default
+    return value.strip().lower() in {"1", "true", "yes", "on"}
+
+
+def messages_to_prompt(history: List[Dict[str, Any]], system_prompt: str = "") -> str:
+    parts = []
+    if system_prompt:
+        parts.append(system_prompt.strip())
+
+    for message in history or []:
+        role = message.get("role", "user")
+        text = extract_text(message)
+        if text:
+            parts.append(f"{role}: {text}")
+
+    parts.append("assistant:")
+    return "\n".join(parts)
+
+
+def extract_text(message: Dict[str, Any]) -> str:
+    content = message.get("content") or ""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        return "".join(
+            item.get("text", "")
+            for item in content
+            if isinstance(item, dict) and item.get("type") == "text"
+        )
+    return str(content)
+
+
+class DryRunAdapter:
+    def __init__(self, model_id: str):
+        self.model_id = model_id
+
+    def generate(self, history, system_prompt, temperature, max_tokens, top_p, top_k):
+        last_user = ""
+        for message in reversed(history or []):
+            if message.get("role") == "user":
+                last_user = extract_text(message)
+                break
+        return (
+            f"[DRY_RUN:{self.model_id}] Historic Chat Space contract is working. "
+            f"Last user message: {last_user or 'none'}"
+        )
+
+
+class TransformersAdapter:
+    def __init__(self, model_id: str):
+        import torch
+        from transformers import AutoModelForCausalLM, AutoTokenizer
+
+        kwargs = parse_json_env("RFAB_HISTORIC_MODEL_KWARGS", {})
+        if "torch_dtype" in kwargs and kwargs["torch_dtype"] == "auto":
+            kwargs["torch_dtype"] = "auto"
+        elif "torch_dtype" not in kwargs and torch.cuda.is_available():
+            kwargs["torch_dtype"] = torch.float16
+
+        if "device_map" not in kwargs:
+            kwargs["device_map"] = "auto" if torch.cuda.is_available() else None
+
+        kwargs = {key: value for key, value in kwargs.items() if value is not None}
+
+        self.model_id = model_id
+        self.tokenizer = AutoTokenizer.from_pretrained(model_id)
+        self.model = AutoModelForCausalLM.from_pretrained(model_id, **kwargs)
+        if not torch.cuda.is_available() and kwargs.get("device_map") is None:
+            self.model.to("cpu")
+
+    def generate(self, history, system_prompt, temperature, max_tokens, top_p, top_k):
+        import torch
+
+        prompt = messages_to_prompt(history, system_prompt)
+        inputs = self.tokenizer(prompt, return_tensors="pt", return_token_type_ids=False)
+        device = next(self.model.parameters()).device
+        inputs = {key: value.to(device) for key, value in inputs.items()}
+
+        with torch.no_grad():
+            generate_kwargs = {
+                **inputs,
+                "max_new_tokens": int(max_tokens),
+                "temperature": float(temperature),
+                "top_p": float(top_p),
+                "do_sample": float(temperature) > 0,
+                "pad_token_id": self.tokenizer.eos_token_id,
+            }
+            if int(top_k) > 0:
+                generate_kwargs["top_k"] = int(top_k)
+            output = self.model.generate(**generate_kwargs)
+
+        generated = self.tokenizer.decode(output[0], skip_special_tokens=True)
+        if generated.startswith(prompt):
+            generated = generated[len(prompt):]
+        return generated.strip()
+
+
+class NanochatAdapter:
+    def __init__(self, model_id: str):
+        raise RuntimeError(
+            "RFAB_HISTORIC_ADAPTER=nanochat is a scaffold. Copy the nanochat runtime "
+            "from tventurella/mr_chatterbox into this Space and replace NanochatAdapter "
+            "with that loader before setting DRY_RUN=false."
+        )
+
+
+def parse_json_env(name: str, default):
+    raw = os.getenv(name)
+    if not raw:
+        return default
+    return json.loads(raw)
+
+
+def create_adapter():
+    model_id = os.getenv("RFAB_HISTORIC_MODEL_ID", "dry-run-model")
+    if env_bool("DRY_RUN", True):
+        return DryRunAdapter(model_id)
+
+    adapter = os.getenv("RFAB_HISTORIC_ADAPTER", "transformers").strip().lower()
+    if adapter == "transformers":
+        return TransformersAdapter(model_id)
+    if adapter == "nanochat":
+        return NanochatAdapter(model_id)
+    raise ValueError(f"Unsupported RFAB_HISTORIC_ADAPTER: {adapter}")

requirements.txt

@@ -0,0 +1,7 @@
+gradio>=5.0,<6
+transformers>=4.46
+accelerate>=1.0
+torch
+sentencepiece
+huggingface_hub
+spaces