Add Qwen3.8-27B Uncensored MLX demo Space

README.md

@@ -1,13 +1,47 @@
 ---
-title: Qwen38 27b Uncensored Mlx Demo
-emoji: 👀
-colorFrom: red
-colorTo: red
+title: Qwen3.8-27B Uncensored MLX
+emoji: 🍎
+colorFrom: blue
+colorTo: indigo
 sdk: gradio
 sdk_version: 6.25.0
-python_version: '3.12'
 app_file: app.py
-pinned: false
+python_version: "3.12"
+short_description: Chat demo + MLX guide for Qwen3.8-27B
+hf_oauth: true
+hf_oauth_scopes:
+  - inference-api
+models:
+  - orcarouter/Qwen3.8-27B-Uncensored-MLX
+  - Qwen/Qwen3.8-27B
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Qwen3.8-27B Uncensored MLX
+
+Demo Space for [`orcarouter/Qwen3.8-27B-Uncensored-MLX`](https://huggingface.co/orcarouter/Qwen3.8-27B-Uncensored-MLX) — an abliterated Qwen3.8-27B quantized for Apple Silicon (2 / 4 / 6 / 8-bit).
+
+**Live chat cannot load MLX weights on Space hardware.** This app talks to hosted **Qwen/Qwen3.8-27B** (same 27B vision-language architecture, 262K context, thinking + tools). To run the uncensored MLX build, use a Mac and `mlx-vlm` as in the model card.
+
+## Local MLX (Apple Silicon)
+
+```bash
+pip install -U mlx-vlm    # mlx-vlm >= 0.6.13, mlx >= 0.32
+
+hf download orcarouter/Qwen3.8-27B-Uncensored-MLX --include "4-bit/*" \
+    --local-dir ./Qwen3.8-27B-Uncensored-MLX
+
+python -m mlx_vlm generate \
+    --model ./Qwen3.8-27B-Uncensored-MLX/4-bit \
+    --prompt "Explain quantum entanglement in one sentence." --max-tokens 256
+```
+
+4-bit is the default (~15 GB, 24 GB unified memory). Prefer 6-bit or 8-bit when you have the RAM. Do not use 2-bit for real work.
+
+## Disclaimer
+
+The MLX repo has had refusal behavior substantially removed. It is intended for research, interpretability, and red-teaming — not unmoderated production. You are responsible for how you use it and for what it generates. Apache 2.0, inherited from `Qwen/Qwen3.8-27B`.
+
+## Similar Spaces
+
+- [akhaliq/Qwen3.8-27B](https://huggingface.co/spaces/akhaliq/Qwen3.8-27B) — official-style ZeroGPU workflow
+- [Yinhaoc/qwen3.8-27b-demo](https://huggingface.co/spaces/Yinhaoc/qwen3.8-27b-demo) — Featherless chat + vision

app.py

@@ -0,0 +1,217 @@
+import base64
+import mimetypes
+import os
+from pathlib import Path
+
+import gradio as gr
+import spaces
+from gradio import ChatMessage
+from huggingface_hub import InferenceClient
+from openai import OpenAI
+
+MLX_REPO = "orcarouter/Qwen3.8-27B-Uncensored-MLX"
+HOSTED_MODEL = "Qwen/Qwen3.8-27B"
+ORCA_MODEL = "qwen/qwen3.8-27b-free"
+ORCA_BASE = "https://api.orcarouter.ai/v1"
+HF_PROVIDER = "featherless-ai"
+
+ORCA_KEY = os.environ.get("ORCAROUTER_API_KEY") or os.environ.get("ORCA_API_KEY") or ""
+HF_KEY = os.environ.get("HF_TOKEN") or ""
+
+CSS = """
+#col-container { max-width: 1100px; margin: 0 auto; }
+.dark .gradio-container { color: var(--body-text-color); }
+"""
+
+
+@spaces.GPU(duration=1)
+def _noop():
+    """ZeroGPU requires at least one decorated function; never called."""
+    pass
+
+
+def _file_to_data_url(path: str) -> str:
+    mime = mimetypes.guess_type(path)[0] or "image/jpeg"
+    data = base64.b64encode(Path(path).read_bytes()).decode()
+    return f"data:{mime};base64,{data}"
+
+
+def _to_parts(content) -> list[dict]:
+    """Convert a Gradio multimodal message to OpenAI content parts."""
+    parts = []
+    if isinstance(content, str):
+        if content.strip():
+            parts.append({"type": "text", "text": content})
+        return parts or [{"type": "text", "text": "..."}]
+    text = (content or {}).get("text", "") or ""
+    if text.strip():
+        parts.append({"type": "text", "text": text})
+    for item in (content or {}).get("files", []) or []:
+        path = item.get("path", item) if isinstance(item, dict) else item
+        parts.append({"type": "image_url", "image_url": {"url": _file_to_data_url(str(path))}})
+    return parts or [{"type": "text", "text": "..."}]
+
+
+def _history_to_messages(history: list[dict]) -> list[dict]:
+    messages = []
+    for turn in history or []:
+        content = turn.get("content")
+        role = turn.get("role", "user")
+        if turn.get("metadata"):
+            continue
+        if isinstance(content, str):
+            messages.append({"role": role, "content": content})
+        else:
+            messages.append({"role": role, "content": _to_parts(content)})
+    return messages
+
+
+def _extra_body(enable_thinking: bool, reasoning_effort: str) -> dict:
+    return {
+        "chat_template_kwargs": {"enable_thinking": bool(enable_thinking)},
+        "include_reasoning": bool(enable_thinking),
+        "reasoning_effort": reasoning_effort,
+        "temperature": 1.0 if enable_thinking else 0.7,
+        "top_p": 0.95 if enable_thinking else 0.8,
+        "top_k": 20,
+    }
+
+
+def _stream_orca(messages: list[dict], extra_body: dict, max_tokens: int):
+    client = OpenAI(base_url=ORCA_BASE, api_key=ORCA_KEY)
+    return client.chat.completions.create(
+        model=ORCA_MODEL,
+        messages=messages,
+        max_tokens=max_tokens,
+        stream=True,
+        extra_body=extra_body,
+    ), "OrcaRouter"
+
+
+def _stream_hf(messages: list[dict], extra_body: dict, max_tokens: int, token: str):
+    client = InferenceClient(api_key=token, provider=HF_PROVIDER)
+    return client.chat_completion(
+        model=HOSTED_MODEL,
+        messages=messages,
+        max_tokens=max_tokens,
+        stream=True,
+        extra_body=extra_body,
+    ), "Featherless"
+
+
+def _delta_text(delta) -> tuple[str, str]:
+    reasoning = getattr(delta, "reasoning", None) or getattr(delta, "reasoning_content", None) or ""
+    content = getattr(delta, "content", None) or ""
+    if not reasoning and isinstance(delta, dict):
+        reasoning = delta.get("reasoning") or delta.get("reasoning_content") or ""
+        content = delta.get("content") or ""
+    return reasoning or "", content or ""
+
+
+def chat(
+    message: dict,
+    history: list[dict],
+    enable_thinking: bool = True,
+    reasoning_effort: str = "medium",
+    max_tokens: int = 2048,
+    oauth_token: gr.OAuthToken | None = None,
+):
+    """Chat with hosted Qwen3.8-27B (text + image). Documents the MLX uncensored build.
+
+    Args:
+        message: Gradio multimodal payload with text and optional image files.
+        history: prior turns as OpenAI-style chat messages.
+        enable_thinking: let the model reason before answering.
+        reasoning_effort: xhigh, medium, or low.
+        max_tokens: cap for thinking + answer tokens.
+        oauth_token: Hugging Face login token used if no OrcaRouter key is set.
+    """
+    hf_token = (oauth_token.token if oauth_token is not None else None) or HF_KEY
+    if not ORCA_KEY and not hf_token:
+        yield ChatMessage(
+            content=(
+                "Sign in with Hugging Face (sidebar) to run this demo, "
+                "or add an `ORCAROUTER_API_KEY` Space secret."
+            )
+        )
+        return
+
+    messages = _history_to_messages(history) + [{"role": "user", "content": _to_parts(message)}]
+    extra = _extra_body(enable_thinking, reasoning_effort)
+
+    try:
+        if ORCA_KEY:
+            stream, _backend = _stream_orca(messages, extra, int(max_tokens))
+        else:
+            stream, _backend = _stream_hf(messages, extra, int(max_tokens), hf_token)
+    except Exception as exc:
+        yield ChatMessage(content=f"Could not start generation: {exc}")
+        return
+
+    thinking = ChatMessage(role="assistant", content="", metadata={"title": "Thinking", "status": "pending"})
+    answer = ChatMessage(role="assistant", content="")
+    if enable_thinking:
+        yield [thinking, answer]
+
+    try:
+        for chunk in stream:
+            if not getattr(chunk, "choices", None):
+                continue
+            delta = chunk.choices[0].delta
+            reason_bit, content_bit = _delta_text(delta)
+            if reason_bit:
+                thinking.content += reason_bit
+            if content_bit:
+                answer.content += content_bit
+            if enable_thinking:
+                yield [thinking, answer]
+            else:
+                yield answer
+    except Exception as exc:
+        answer.content = (answer.content or "") + f"\n\nGeneration stopped: {exc}"
+        yield [thinking, answer] if enable_thinking else answer
+        return
+
+    if enable_thinking:
+        thinking.metadata["status"] = "done"
+        if not (answer.content or "").strip() and (thinking.content or "").strip():
+            answer.content = thinking.content
+        yield [thinking, answer]
+    else:
+        yield answer
+
+
+EXAMPLES = [
+    [{"text": "Explain quantum entanglement in one sentence.", "files": []}, True, "medium", 1024],
+    [{"text": "Describe this image: colors, objects, and any text.", "files": ["examples/scene.jpg"]}, True, "low", 1024],
+    [{"text": "Write a Python function that merges two sorted lists.", "files": []}, False, "medium", 2048],
+]
+
+demo = gr.ChatInterface(
+    chat,
+    multimodal=True,
+    type="messages",
+    title="Qwen3.8-27B Uncensored MLX",
+    description=(
+        "Demo for "
+        f"[`{MLX_REPO}`](https://huggingface.co/{MLX_REPO}) — "
+        "abliterated Qwen3.8-27B in 2/4/6/8-bit **MLX** for Apple Silicon. "
+        "Live chat uses hosted "
+        f"[`{HOSTED_MODEL}`](https://huggingface.co/{HOSTED_MODEL}) "
+        "(Spaces cannot run MLX). "
+        "Run the uncensored weights locally with `mlx-vlm` — see the "
+        "[model card](https://huggingface.co/orcarouter/Qwen3.8-27B-Uncensored-MLX). "
+        "Abliterated weights have refusals removed; research use only."
+    ),
+    examples=EXAMPLES,
+    additional_inputs=[
+        gr.Checkbox(label="Thinking", value=True),
+        gr.Dropdown(choices=["xhigh", "medium", "low"], value="medium", label="Reasoning effort"),
+        gr.Slider(512, 8192, value=2048, step=256, label="Max tokens"),
+    ],
+    theme=gr.themes.Citrus(),
+    css=CSS,
+)
+
+if __name__ == "__main__":
+    demo.launch(mcp_server=True)

requirements.txt

@@ -0,0 +1 @@
+openai