feat: add FastAPI server with Live Swagger UI, OpenAI endpoints, and CORS

app.py

@@ -2,21 +2,27 @@ import os
 import time
 import traceback
 import base64
+import threading
+from typing import List, Optional, Dict, Any
 
 # Set HF token
 _VALID_HF_TOKEN = base64.b64decode('aGZfU09rZ0JjR1NvdXZRRVNEZ09Xbnl5dk9BRWFablREeFZX').decode('utf-8')
 os.environ["HF_TOKEN"] = _VALID_HF_TOKEN
 
 import spaces
-import gradio as gr
 import torch
+import uvicorn
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, Field
+import gradio as gr
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
 import sys
 sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
 from kalpana_embed_to_kv import KalpanaDynamicCache
 
-import threading
 _MODEL_LOCK = threading.Lock()
 _LOCAL_QWEN_MODEL = None
 _LOCAL_TOKENIZER = None
@@ -45,11 +51,7 @@ def _load_model(device, dtype):
 def kalpana_generate(prompt: str, max_tokens: int = 256, temperature: float = 0.7) -> dict:
     """
     Core generation function — KalpanaDynamicCache O(1) KV memory on NVIDIA A100.
-    Returns a dict with: response, latency_s, memory_mb, layers_intercepted.
     """
-    import transformers as _tf
-    print(f"[API] transformers=={_tf.__version__}, torch=={torch.__version__}")
-
     device = "cuda" if torch.cuda.is_available() else "cpu"
     dtype = torch.float16 if device == "cuda" else torch.float32
 
@@ -60,9 +62,7 @@ def kalpana_generate(prompt: str, max_tokens: int = 256, temperature: float = 0.
     inputs = _LOCAL_TOKENIZER(fmt, return_tensors="pt").to(device)
 
     num_layers = getattr(_LOCAL_QWEN_MODEL.config, "num_hidden_layers", 24)
-    # 2048 bands for high-fidelity holographic resolution (4x quality)
     cache = KalpanaDynamicCache(num_layers=num_layers, bands=2048)
-    print(f"[API] Cache: {num_layers} layers, bands=2048, is_sliding[:3]={cache.is_sliding[:3]}")
 
     t0 = time.perf_counter()
     with torch.inference_mode():
@@ -79,67 +79,197 @@ def kalpana_generate(prompt: str, max_tokens: int = 256, temperature: float = 0.
     resp = _LOCAL_TOKENIZER.decode(out[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
     mem_mb = cache.get_total_memory_mb()
 
-    print(f"[API] Done in {t1-t0:.2f}s | mem={mem_mb:.1f}MB | response={resp[:80]!r}")
     return {
         "response": resp,
         "latency_s": round(t1 - t0, 3),
         "memory_mb": round(mem_mb, 2),
         "layers_intercepted": num_layers,
+        "model": MODEL_NAME,
+        "bands": 2048
     }
 
+# ── FastAPI App with Live Swagger at /docs ────────────────────────────────────
+app = FastAPI(
+    title="⚡ Kalpanā RIF O(1) Memory API",
+    description=(
+        "Production REST & Swagger API for **Kalpanā Resonant Interference Field (RIF)** KV Cache.\n\n"
+        "Runs on an **NVIDIA A100 80GB GPU** on Hugging Face ZeroGPU with strictly constant O(1) memory.\n\n"
+        "👉 **Visual Studio:** [Kalpana RIF Studio](https://huggingface.co/spaces/MaduRox/Kalpana-RIF-Studio)"
+    ),
+    version="4.2.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# Enable CORS for Studio and external callers
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class GenerateRequest(BaseModel):
+    prompt: str = Field(..., example="What is quantum entanglement and how does it relate to waves?")
+    max_tokens: Optional[int] = Field(256, example=256, ge=16, le=1024)
+    temperature: Optional[float] = Field(0.7, example=0.7, ge=0.0, le=1.5)
+
+class GenerateResponse(BaseModel):
+    response: str
+    latency_s: float
+    memory_mb: float
+    layers_intercepted: int
+    model: str
+    bands: int
 
-def _run_inference(prompt: str, max_tokens: int, temperature: float):
-    """UI wrapper — calls kalpana_generate and unpacks for Gradio outputs."""
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+class ChatCompletionRequest(BaseModel):
+    model: Optional[str] = "kalpana-qwen2.5-0.5b"
+    messages: List[ChatMessage]
+    max_tokens: Optional[int] = 256
+    temperature: Optional[float] = 0.7
+
+@app.get("/api/health", tags=["System"])
+def health_check():
+    return {
+        "status": "healthy",
+        "gpu_available": torch.cuda.is_available(),
+        "device": torch.cuda.get_device_name(0) if torch.cuda.is_available() else "CPU",
+        "model": MODEL_NAME,
+        "bands": 2048,
+        "architecture": "KalpanaDynamicCache O(1)"
+    }
+
+@app.post("/api/generate", response_model=GenerateResponse, tags=["Inference"])
+def api_generate(req: GenerateRequest):
+    """
+    Standard generation endpoint. Intercepts all 24 layers of Qwen2.5 with KalpanaDynamicCache.
+    """
+    if not req.prompt.strip():
+        raise HTTPException(status_code=400, detail="Prompt cannot be empty")
+    try:
+        res = kalpana_generate(req.prompt.strip(), req.max_tokens, req.temperature)
+        return res
+    except Exception as e:
+        tb = traceback.format_exc()
+        print("API ERROR:\n" + tb)
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/v1/chat/completions", tags=["OpenAI Compatibility"])
+def openai_chat_completions(req: ChatCompletionRequest):
+    """
+    OpenAI-compatible chat completions endpoint for seamless drop-in integration.
+    """
+    # Extract user prompt from last message
+    prompt = req.messages[-1].content if req.messages else ""
+    if not prompt.strip():
+        raise HTTPException(status_code=400, detail="Messages cannot be empty")
+    try:
+        res = kalpana_generate(prompt.strip(), req.max_tokens or 256, req.temperature or 0.7)
+        return {
+            "id": f"chatcmpl-kalpana-{int(time.time())}",
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": req.model,
+            "choices": [{
+                "index": 0,
+                "message": {
+                    "role": "assistant",
+                    "content": res["response"]
+                },
+                "finish_reason": "stop"
+            }],
+            "usage": {
+                "prompt_tokens": len(prompt.split()),
+                "completion_tokens": len(res["response"].split()),
+                "total_tokens": len(prompt.split()) + len(res["response"].split())
+            },
+            "kalpana_telemetry": {
+                "latency_s": res["latency_s"],
+                "vram_mb": res["memory_mb"],
+                "layers_intercepted": res["layers_intercepted"],
+                "bands": res["bands"]
+            }
+        }
+    except Exception as e:
+        tb = traceback.format_exc()
+        print("CHAT ERROR:\n" + tb)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ── Gradio Interactive Console & Live Swagger Docs ───────────────────────────
+def _run_ui(prompt: str, max_tokens: int, temperature: float):
     if not prompt or not prompt.strip():
         return "Enter a prompt above.", "0.0s", "0.0 MB", "0 Layers"
     try:
-        result = kalpana_generate(prompt.strip(), int(max_tokens), float(temperature))
+        res = kalpana_generate(prompt.strip(), int(max_tokens), float(temperature))
         return (
-            result["response"],
-            f"{result['latency_s']}s",
-            f"{result['memory_mb']:.2f} MB",
-            f"{result['layers_intercepted']}/24 Layers",
+            res["response"],
+            f"{res['latency_s']}s",
+            f"{res['memory_mb']:.2f} MB",
+            f"{res['layers_intercepted']}/24 Layers",
         )
     except Exception as e:
         tb = traceback.format_exc()
-        print("=== ERROR ===\n" + tb)
-        return f"Error: {type(e).__name__}: {e}\n\n{tb}", "Error", "Error", "Error"
+        print("UI ERROR:\n" + tb)
+        return f"Error: {e}\n\n{tb}", "Error", "Error", "Error"
 
-
-# ── Minimal Gradio UI (backend test console only) ────────────────────────────
-with gr.Blocks(title="Kalpanā API — ZeroGPU Backend") as demo:
+with gr.Blocks(title="Kalpanā API — ZeroGPU Backend", theme=gr.themes.Soft()) as demo:
     gr.Markdown(
-        "## ⚡ Kalpanā API — ZeroGPU NVIDIA A100 Backend\n"
-        "Pure O(1) KV Cache (`KalpanaDynamicCache`) running on `zero-a10g`.\n\n"
-        "👉 **Visual Studio:** [Kalpana RIF Studio](https://huggingface.co/spaces/MaduRox/Kalpana-RIF-Studio)"
+        "# ⚡ Kalpanā RIF O(1) Memory API & Server\n"
+        "High-performance constant-memory LLM inference engine running on an **NVIDIA A100 80GB GPU** (`zero-a10g`).\n\n"
+        "👉 **Interactive Live Swagger Docs:** [`/docs`](/docs) • **Visual Studio:** [Kalpana RIF Studio](https://huggingface.co/spaces/MaduRox/Kalpana-RIF-Studio)"
     )
-    with gr.Row():
-        prompt_box = gr.Textbox(label="Prompt", lines=2, value="What is cricket?")
-        max_tok = gr.Slider(32, 512, value=128, step=32, label="Max Tokens")
-        temp = gr.Slider(0.0, 1.5, value=0.7, step=0.05, label="Temperature")
-    btn = gr.Button("▶ Run on A100", variant="primary")
-    with gr.Row():
-        out_text = gr.Textbox(label="Response", lines=5, interactive=False)
-        out_lat  = gr.Textbox(label="Latency",   interactive=False)
-        out_mem  = gr.Textbox(label="VRAM (O(1))", interactive=False)
-        out_lay  = gr.Textbox(label="Layers",    interactive=False)
-
-    btn.click(_run_inference, inputs=[prompt_box, max_tok, temp],
-              outputs=[out_text, out_lat, out_mem, out_lay])
-
-    # ── Programmatic API endpoint (no Gradio form needed) ───────────────────
-    gr.Interface(
-        fn=kalpana_generate,
-        inputs=[
-            gr.Textbox(label="prompt"),
-            gr.Number(label="max_tokens", value=256),
-            gr.Number(label="temperature", value=0.7),
-        ],
-        outputs=gr.JSON(label="result"),
-        title="Kalpanā API",
-        description="POST /run/predict with JSON body to call programmatically.",
-    ).queue()
-
-demo.queue()
+    with gr.Tabs():
+        with gr.TabItem("▶ Live Interactive Testbench"):
+            with gr.Row():
+                prompt_box = gr.Textbox(label="Prompt", lines=3, value="Explain how neural networks learn in simple terms.")
+                with gr.Column():
+                    max_tok = gr.Slider(32, 512, value=128, step=32, label="Max Tokens")
+                    temp = gr.Slider(0.0, 1.5, value=0.7, step=0.05, label="Temperature")
+                    btn = gr.Button("🚀 Run on NVIDIA A100", variant="primary")
+            
+            with gr.Row():
+                out_text = gr.Textbox(label="Generated Response", lines=6, interactive=False)
+            with gr.Row():
+                out_lat  = gr.Textbox(label="Latency", interactive=False)
+                out_mem  = gr.Textbox(label="O(1) VRAM Footprint", interactive=False)
+                out_lay  = gr.Textbox(label="Intercepted Layers", interactive=False)
+
+            btn.click(_run_ui, inputs=[prompt_box, max_tok, temp], outputs=[out_text, out_lat, out_mem, out_lay])
+
+        with gr.TabItem("📖 Live Swagger / REST API Documentation"):
+            gr.Markdown(
+                "### 🌐 REST API Endpoints\n\n"
+                "You can call this space directly from any programming language via standard HTTP requests.\n\n"
+                "#### 1. Standard REST Endpoint (`POST /api/generate`)\n"
+                "```bash\n"
+                "curl -X POST https://madurox-kalpana-api-gpu.hf.space/api/generate \\\n"
+                "  -H 'Content-Type: application/json' \\\n"
+                "  -d '{\"prompt\": \"What is cricket?\", \"max_tokens\": 128, \"temperature\": 0.7}'\n"
+                "```\n\n"
+                "#### 2. OpenAI-Compatible Endpoint (`POST /v1/chat/completions`)\n"
+                "```python\n"
+                "from openai import OpenAI\n\n"
+                "client = OpenAI(\n"
+                "    base_url='https://madurox-kalpana-api-gpu.hf.space/v1',\n"
+                "    api_key='not-needed'\n"
+                ")\n\n"
+                "response = client.chat.completions.create(\n"
+                "    model='kalpana-qwen2.5-0.5b',\n"
+                "    messages=[{'role': 'user', 'content': 'What is RIF memory?'}]\n"
+                ")\n"
+                "print(response.choices[0].message.content)\n"
+                "```\n\n"
+                "👉 **Access the Full Interactive OpenAPI Swagger UI at [`/docs`](/docs)**"
+            )
+
+# Mount Gradio onto FastAPI
+app = gr.mount_gradio_app(app, demo, path="/")
+
 if __name__ == "__main__":
-    demo.launch()
+    uvicorn.run(app, host="0.0.0.0", port=7860)

app.py.metadata.json

@@ -1,4 +1,4 @@
 {
-  "summary": "Minimal Gradio-free FastAPI-style backend for ZeroGPU - no UI, just a hidden API endpoint",
-  "updatedAt": "2026-08-21T06:31:09.299251400Z"
+  "summary": "FastAPI + Gradio + Live Swagger backend for Kalpana-API-GPU",
+  "updatedAt": "2026-08-22T06:19:25.314359700Z"
 }

requirements.txt

@@ -1,5 +1,8 @@
 transformers==5.8.0
 accelerate==1.8.1
 gradio>=5.0.0
-numpy
+fastapi
+uvicorn
+pydantic
 requests
+numpy

requirements.txt.metadata.json

@@ -1,4 +1,4 @@
 {
-  "summary": "Clean requirements.txt without failing release URL",
-  "updatedAt": "2026-08-21T08:31:04.897131800Z"
+  "summary": "Requirements with fastapi and uvicorn for Swagger support",
+  "updatedAt": "2026-08-22T06:19:34.353996200Z"
 }