Add MiniCPM5-1B inference space with Gradio UI and OpenAI-compatible API

.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+*.pyc
+.DS_Store

README.md

@@ -0,0 +1,59 @@
+---
+title: MiniCPM5-1B
+emoji: 🧠
+colorFrom: blue
+colorTo: purple
+sdk: custom
+sdk_custom_command: uvicorn app:app --host 0.0.0.0 --port 7860
+pinned: false
+license: mit
+short_description: MiniCPM5-1B inference with OpenAI-compatible API
+---
+
+# MiniCPM5-1B Chat
+
+MiniCPM5-1B inference service on Hugging Face Spaces.
+
+## Environment Variables (set in Space Secrets)
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `MODEL_ID` | `GnLOLot/MiniCPM5-1B-Claude-Opus-Fable5-V2-Thinking` | Hugging Face model ID |
+| `API_KEY` | `wsh101007` | API key for OpenAI-compatible endpoints |
+| `MAX_TOKENS` | `2048` | Maximum generation tokens |
+
+## API Usage
+
+### List Models
+```bash
+curl -H "Authorization: Bearer wsh101007" https://{your-space}.hf.space/v1/models
+```
+
+### Chat Completion
+```bash
+curl -X POST https://{your-space}.hf.space/v1/chat/completions \
+  -H "Authorization: Bearer wsh101007" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "minicpm5-1b",
+    "messages": [{"role": "user", "content": "Hello!"}],
+    "temperature": 0.7,
+    "max_tokens": 512
+  }'
+```
+
+### Python (OpenAI SDK)
+```python
+from openai import OpenAI
+
+client = OpenAI(
+    base_url="https://{your-space}.hf.space/v1",
+    api_key="wsh101007"
+)
+
+response = client.chat.completions.create(
+    model="minicpm5-1b",
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+print(response.choices[0].message.content)
+```

app.py

@@ -0,0 +1,158 @@
+import os
+import time
+import json
+import torch
+from typing import Optional, List, AsyncGenerator
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import JSONResponse, StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from contextlib import asynccontextmanager
+import gradio as gr
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+MODEL_ID = os.getenv("MODEL_ID", "GnLOLot/MiniCPM5-1B-Claude-Opus-Fable5-V2-Thinking")
+API_KEY = os.getenv("API_KEY", "wsh101007")
+MAX_TOKENS = int(os.getenv("MAX_TOKENS", "2048"))
+
+model = None
+tokenizer = None
+
+def load_model():
+    global model, tokenizer
+    if model is not None:
+        return model, tokenizer
+    print(f"Loading model: {MODEL_ID}")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True)
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_ID,
+        torch_dtype=torch.bfloat16,
+        device_map="auto",
+        trust_remote_code=True
+    )
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+    print("Model loaded successfully")
+    return model, tokenizer
+
+def verify_auth(request: Request):
+    auth = request.headers.get("Authorization", "")
+    if not auth.startswith("Bearer ") or auth[7:] != API_KEY:
+        raise HTTPException(status_code=401, detail="Invalid API key")
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    load_model()
+    yield
+
+app = FastAPI(lifespan=lifespan, docs_url=None, redoc_url=None)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+class ChatCompletionRequest(BaseModel):
+    model: str = "minicpm5-1b"
+    messages: List[ChatMessage]
+    temperature: Optional[float] = 0.7
+    top_p: Optional[float] = 0.9
+    max_tokens: Optional[int] = None
+    stream: Optional[bool] = False
+
+@app.get("/")
+async def root():
+    return {"message": "MiniCPM5-1B API is running", "model": MODEL_ID}
+
+@app.get("/v1/models")
+async def list_models(request: Request):
+    verify_auth(request)
+    return {
+        "object": "list",
+        "data": [{
+            "id": "minicpm5-1b",
+            "object": "model",
+            "created": int(time.time()),
+            "owned_by": "user"
+        }]
+    }
+
+@app.post("/v1/chat/completions")
+async def chat_completions(request: Request, body: ChatCompletionRequest):
+    verify_auth(request)
+    m, tok = load_model()
+
+    messages = [{"role": msg.role, "content": msg.content} for msg in body.messages]
+    prompt = tok.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    inputs = tok(prompt, return_tensors="pt").to(m.device)
+    prompt_len = inputs.input_ids.shape[1]
+
+    max_new_tokens = min(body.max_tokens or MAX_TOKENS, MAX_TOKENS)
+
+    with torch.no_grad():
+        outputs = m.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            temperature=body.temperature,
+            top_p=body.top_p,
+            do_sample=body.temperature > 0,
+            pad_token_id=tok.pad_token_id,
+        )
+
+    response = tok.decode(outputs[0][prompt_len:], skip_special_tokens=True)
+
+    return {
+        "id": f"chatcmpl-{int(time.time())}",
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": body.model,
+        "choices": [{
+            "index": 0,
+            "message": {"role": "assistant", "content": response.strip()},
+            "finish_reason": "stop"
+        }],
+        "usage": {
+            "prompt_tokens": prompt_len,
+            "completion_tokens": outputs.shape[1] - prompt_len,
+            "total_tokens": outputs.shape[1]
+        }
+    }
+
+def chat_fn(message, history):
+    m, tok = load_model()
+    messages = []
+    for h in history:
+        messages.append({"role": "user", "content": h[0]})
+        messages.append({"role": "assistant", "content": h[1]})
+    messages.append({"role": "user", "content": message})
+
+    prompt = tok.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    inputs = tok(prompt, return_tensors="pt").to(m.device)
+
+    with torch.no_grad():
+        outputs = m.generate(
+            **inputs,
+            max_new_tokens=512,
+            temperature=0.7,
+            top_p=0.9,
+            do_sample=True,
+            pad_token_id=tok.pad_token_id
+        )
+
+    return tok.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True).strip()
+
+with gr.Blocks(title="MiniCPM5-1B Chat", theme=gr.themes.Soft()) as demo_ui:
+    gr.Markdown(f"# MiniCPM5-1B Chat\n**Model:** `{MODEL_ID}`")
+    gr.ChatInterface(
+        fn=chat_fn,
+        title=None,
+        description="Chat with the model. API available at `/v1/chat/completions` (requires Bearer token)."
+    )
+
+app = gr.mount_gradio_app(app, demo_ui, path="/")

requirements.txt

@@ -0,0 +1,7 @@
+gradio>=4.21.0,<5.0
+fastapi>=0.100.0
+uvicorn>=0.23.0
+transformers>=4.36.0
+accelerate>=0.25.0
+torch>=2.1.0
+sentencepiece>=0.1.99