Spaces:

Rox-Turbo
/

API

Running

App Files Files Community

Rox-Turbo commited on Mar 11

Commit

58ec31b

verified ·

1 Parent(s): 8816398

Upload 12 files

Browse files

Files changed (10) hide show

README.md +99 -83
__pycache__/server.cpython-312.pyc +0 -0
docker-compose.yml +2 -2
dockerignore +15 -0
docs/API_REFERENCE.md +471 -0
docs/CODE.md +599 -0
docs/DEVELOPER_GUIDE.md +382 -0
docs/MODELS.md +578 -0
gitattributes +35 -0
server.py +397 -14

README.md CHANGED Viewed

@@ -1,110 +1,126 @@
----
-title: nvidia-chat-proxy
-emoji: 💬
-colorFrom: blue
-colorTo: green
-sdk: docker
-sdk_version: "1.0"
-app_port: 8000
-pinned: false
----
-## NVIDIA Chat Proxy API
-This is a small FastAPI server that proxies requests from your static website to the NVIDIA/`OpenAI` compatible endpoint, so your API key stays on the server and is never exposed in the browser.
-### 1. Setup
-Create and activate a virtual environment (optional but recommended), then install dependencies:
-```bash
-pip install -r requirements.txt
-```
-Create a `.env` file in this folder:
 ```bash
-echo NVIDIA_API_KEY=your_real_nvidia_key_here > .env
 ```
-> **Important**: Never commit your real key to git or paste it in client-side code.
-### 2. Run the server
-```bash
-python server.py
-```
-The API will be available at `http://localhost:8000`.
-### 3. HTTP API
-**Endpoint**: `POST /chat`
-**Request body**:
 ```json
 {
   "messages": [
-    { "role": "user", "content": "Hello!" }
   ],
   "temperature": 1.0,
-  "top_p": 1.0,
   "max_tokens": 512
 }
 ```
-**Response body**:
 ```json
 {
-  "content": "Model reply here..."
 }
 ```
-### 4. Example usage from a static website
-```html
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="UTF-8" />
-    <title>Chat with NVIDIA Model</title>
-  </head>
-  <body>
-    <textarea id="input" placeholder="Ask something..."></textarea>
-    <button id="send">Send</button>
-    <pre id="output"></pre>
-    <script>
-      const API_URL = "http://localhost:8000/chat"; // or your deployed URL
-      document.getElementById("send").addEventListener("click", async () => {
-        const userText = document.getElementById("input").value;
-        const body = {
-          messages: [{ role: "user", content: userText }],
-          temperature: 1,
-          top_p: 1,
-          max_tokens: 512,
-        };
-        const res = await fetch(API_URL, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(body),
-        });
-        if (!res.ok) {
-          document.getElementById("output").textContent =
-            "Error: " + (await res.text());
-          return;
-        }
-        const data = await res.json();
-        document.getElementById("output").textContent = data.content;
-      });
-    </script>
-  </body>
-  </html>
 ```

+# Rox AI
+Eight specialized AI models by Mohammad Faiz.
+**API**: `https://Rox-Turbo-API.hf.space`
+## Models
+| Model | Endpoint | Use Case |
+|-------|----------|----------|
+| Rox Core | `/chat` | General conversation |
+| Rox 2.1 Turbo | `/turbo` | Fast responses |
+| Rox 3.5 Coder | `/coder` | Code generation |
+| Rox 4.5 Turbo | `/turbo45` | Advanced reasoning |
+| Rox 5 Ultra | `/ultra` | Complex tasks |
+| Rox 6 Dyno | `/dyno` | Long context |
+| Rox 7 Coder | `/coder7` | Advanced coding |
+| Rox Vision Max | `/vision` | Visual understanding |
+## Quick Start
 ```bash
+curl -X POST https://Rox-Turbo-API.hf.space/chat \
+  -H "Content-Type: application/json" \
+  -d '{"messages":[{"role":"user","content":"Hello"}]}'
 ```
+## Usage
+### Request
 ```json
 {
   "messages": [
+    {"role": "user", "content": "Your message"}
   ],
   "temperature": 1.0,
   "max_tokens": 512
 }
 ```
+### Response
 ```json
 {
+  "content": "AI response"
+}
+```
+### JavaScript
+```javascript
+async function askRox(message, model = 'chat') {
+  const response = await fetch(`https://Rox-Turbo-API.hf.space/${model}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      messages: [{ role: 'user', content: message }]
+    })
+  });
+  return (await response.json()).content;
 }
 ```
+### Python
+```python
+import requests
+def ask_rox(message, model='chat'):
+    response = requests.post(
+        f'https://Rox-Turbo-API.hf.space/{model}',
+        json={'messages': [{'role': 'user', 'content': message}]}
+    )
+    return response.json()['content']
+```
+## Examples
+```bash
+# General conversation
+curl -X POST https://Rox-Turbo-API.hf.space/chat \
+  -H "Content-Type: application/json" \
+  -d '{"messages":[{"role":"user","content":"Explain AI"}]}'
+# Fast response
+curl -X POST https://Rox-Turbo-API.hf.space/turbo \
+  -H "Content-Type: application/json" \
+  -d '{"messages":[{"role":"user","content":"What is 2+2?"}]}'
+# Code generation
+curl -X POST https://Rox-Turbo-API.hf.space/coder \
+  -H "Content-Type: application/json" \
+  -d '{"messages":[{"role":"user","content":"Write a Python function"}]}'
+# Advanced reasoning
+curl -X POST https://Rox-Turbo-API.hf.space/turbo45 \
+  -H "Content-Type: application/json" \
+  -d '{"messages":[{"role":"user","content":"Explain quantum computing"}]}'
 ```
+## Documentation
+- [Code Examples](docs/CODE.md) - Copy-paste code
+- [Developer Guide](docs/DEVELOPER_GUIDE.md) - Integration guide
+- [Models Guide](docs/MODELS.md) - Model details
+- [API Reference](docs/API_REFERENCE.md) - API docs
+## Model Selection
+- **Rox Core** - General use
+- **Rox 2.1 Turbo** - Speed priority
+- **Rox 3.5 Coder** - Code tasks
+- **Rox 4.5 Turbo** - Complex reasoning
+- **Rox 5 Ultra** - Highest quality
+- **Rox 6 Dyno** - Long documents
+- **Rox 7 Coder** - Advanced code
+- **Rox Vision Max** - Images
+## License
+MIT License
+---
+Built by Mohammad Faiz

__pycache__/server.cpython-312.pyc ADDED Viewed

Binary file (16 kB). View file

docker-compose.yml CHANGED Viewed

@@ -1,9 +1,9 @@
 version: "3.9"
 services:
-  nvidia-chat-proxy:
     build: .
-    container_name: nvidia-chat-proxy
     ports:
       - "8000:8000"
     env_file:

 version: "3.9"
 services:
+  rox-ai:
     build: .
+    container_name: rox-ai
     ports:
       - "8000:8000"
     env_file:

dockerignore ADDED Viewed

	@@ -0,0 +1,15 @@

+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.venv/
+build/
+dist/
+*.egg-info/
+.git
+.gitignore
+.env

docs/API_REFERENCE.md ADDED Viewed

	@@ -0,0 +1,471 @@

+# API Reference
+Technical reference for Rox AI API endpoints.
+## Base URL
+```
+https://Rox-Turbo-API.hf.space
+```
+---
+## Endpoints
+### POST /chat - Rox Core
+### POST /turbo - Rox 2.1 Turbo
+### POST /coder - Rox 3.5 Coder
+### POST /turbo45 - Rox 4.5 Turbo
+### POST /ultra - Rox 5 Ultra
+### POST /dyno - Rox 6 Dyno
+### POST /coder7 - Rox 7 Coder
+### POST /vision - Rox Vision Max
+### POST /hf/generate - HuggingFace Compatible
+All endpoints use the same request/response format.
+#### Request
+**URL**: `/chat`
+**Method**: `POST`
+**Content-Type**: `application/json`
+**Body Parameters**:
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `messages` | Array<Message> | Yes | - | Array of conversation messages |
+| `temperature` | Float | No | 1.0 | Controls randomness (0.0 - 2.0) |
+| `top_p` | Float | No | 1.0 | Nucleus sampling parameter (0.0 - 1.0) |
+| `max_tokens` | Integer | No | 4096 | Maximum tokens in response |
+**Message Object**:
+```typescript
+{
+  role: "user" | "assistant",
+  content: string
+}
+```
+**Example Request**:
+```json
+{
+  "messages": [
+    {
+      "role": "user",
+      "content": "What is artificial intelligence?"
+    }
+  ],
+  "temperature": 1.0,
+  "top_p": 0.95,
+  "max_tokens": 512
+}
+```
+#### Response
+**Success Response** (200 OK):
+```json
+{
+  "content": "Artificial intelligence (AI) refers to..."
+}
+```
+**Response Fields**:
+| Field | Type | Description |
+|-------|------|-------------|
+| `content` | String | The generated response from Rox Core |
+**Error Responses**:
+**500 Internal Server Error**:
+```json
+{
+  "detail": "Internal server error while calling Rox Core."
+}
+```
+**502 Bad Gateway**:
+```json
+{
+  "detail": "Bad response from upstream model provider."
+}
+```
+**422 Unprocessable Entity**:
+```json
+{
+  "detail": [
+    {
+      "loc": ["body", "messages"],
+      "msg": "field required",
+      "type": "value_error.missing"
+    }
+  ]
+}
+```
+#### Example Usage
+**cURL**:
+```bash
+curl -X POST https://Rox-Turbo-API.hf.space/chat \
+  -H "Content-Type: application/json" \
+  -d '{
+    "messages": [
+      {"role": "user", "content": "Hello!"}
+    ],
+    "temperature": 1.0,
+    "max_tokens": 512
+  }'
+```
+**JavaScript**:
+```javascript
+const response = await fetch('https://Rox-Turbo-API.hf.space/chat', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    messages: [{ role: 'user', content: 'Hello!' }],
+    temperature: 1.0,
+    max_tokens: 512
+  })
+});
+const data = await response.json();
+console.log(data.content);
+```
+**Python**:
+```python
+import requests
+response = requests.post('https://Rox-Turbo-API.hf.space/chat', json={
+    'messages': [{'role': 'user', 'content': 'Hello!'}],
+    'temperature': 1.0,
+    'max_tokens': 512
+})
+print(response.json()['content'])
+```
+---
+### POST /hf/generate
+Hugging Face compatible text generation endpoint for single-turn interactions.
+#### Request
+**URL**: `/hf/generate`
+**Method**: `POST`
+**Content-Type**: `application/json`
+**Body Parameters**:
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `inputs` | String | Yes | - | The input text/prompt |
+| `parameters` | Object | No | {} | Generation parameters |
+**Parameters Object**:
+| Field | Type | Required | Default | Description |
+|-------|------|----------|---------|-------------|
+| `temperature` | Float | No | 1.0 | Controls randomness (0.0 - 2.0) |
+| `top_p` | Float | No | 0.95 | Nucleus sampling (0.0 - 1.0) |
+| `max_new_tokens` | Integer | No | 8192 | Maximum tokens to generate |
+**Example Request**:
+```json
+{
+  "inputs": "Write a haiku about technology",
+  "parameters": {
+    "temperature": 0.7,
+    "top_p": 0.95,
+    "max_new_tokens": 256
+  }
+}
+```
+#### Response
+**Success Response** (200 OK):
+```json
+[
+  {
+    "generated_text": "Silicon dreams awake\nCircuits pulse with electric life\nFuture in our hands"
+  }
+]
+```
+**Response Format**:
+Returns an array with a single object containing the generated text.
+| Field | Type | Description |
+|-------|------|-------------|
+| `generated_text` | String | The generated response |
+**Error Responses**:
+Same as `/chat` endpoint (500, 502, 422).
+#### Example Usage
+**cURL**:
+```bash
+curl -X POST https://Rox-Turbo-API.hf.space/hf/generate \
+  -H "Content-Type: application/json" \
+  -d '{
+    "inputs": "Explain quantum computing",
+    "parameters": {
+      "temperature": 0.7,
+      "max_new_tokens": 256
+    }
+  }'
+```
+**JavaScript**:
+```javascript
+const response = await fetch('https://Rox-Turbo-API.hf.space/hf/generate', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    inputs: 'Explain quantum computing',
+    parameters: {
+      temperature: 0.7,
+      max_new_tokens: 256
+    }
+  })
+});
+const data = await response.json();
+console.log(data[0].generated_text);
+```
+**Python**:
+```python
+import requests
+response = requests.post('https://Rox-Turbo-API.hf.space/hf/generate', json={
+    'inputs': 'Explain quantum computing',
+    'parameters': {
+        'temperature': 0.7,
+        'max_new_tokens': 256
+    }
+})
+print(response.json()[0]['generated_text'])
+```
+---
+## Parameters
+### temperature
+Controls output randomness.
+- **Range**: 0.0 to 2.0
+- **Default**: 1.0
+- **Lower** (0.1-0.5): Focused, deterministic
+- **Medium** (0.6-1.0): Balanced
+- **Higher** (1.1-2.0): Creative, varied
+Examples:
+- `0.3`: Math problems, factual questions, code generation
+- `0.7`: General conversation, explanations
+- `1.2`: Creative writing, brainstorming, storytelling
+**Example**:
+```json
+{
+  "messages": [{"role": "user", "content": "What is 2+2?"}],
+  "temperature": 0.2
+}
+```
+### top_p
+Nucleus sampling parameter.
+- **Range**: 0.0 to 1.0
+- **Default**: 0.95 (/hf/generate), 1.0 (/chat)
+- **Lower**: More focused
+- **Higher**: More diverse
+Example:
+```json
+{
+  "messages": [{"role": "user", "content": "Tell me a story"}],
+  "top_p": 0.9
+}
+```
+### max_tokens / max_new_tokens
+Maximum tokens in response.
+- **Range**: 1 to 8192
+- **Default**: 4096 (/chat), 8192 (/hf/generate)
+Token estimation:
+- ~1 token ≈ 4 characters
+- ~1 token ≈ 0.75 words
+Example:
+```json
+{
+  "messages": [{"role": "user", "content": "Brief summary of AI"}],
+  "max_tokens": 150
+}
+```
+---
+## Error Handling
+### Status Codes
+| Code | Meaning | Description |
+|------|---------|-------------|
+| 200 | OK | Request successful |
+| 422 | Unprocessable Entity | Invalid request format |
+| 500 | Internal Server Error | Server-side error |
+| 502 | Bad Gateway | Upstream model error |
+### Error Response Format
+```json
+{
+  "detail": "Error message here"
+}
+```
+### Common Errors
+Missing field:
+```json
+{
+  "detail": [
+    {
+      "loc": ["body", "messages"],
+      "msg": "field required",
+      "type": "value_error.missing"
+    }
+  ]
+}
+```
+Invalid type:
+```json
+{
+  "detail": [
+    {
+      "loc": ["body", "temperature"],
+      "msg": "value is not a valid float",
+      "type": "type_error.float"
+    }
+  ]
+}
+```
+Example error handler:
+```javascript
+async function safeRequest(endpoint, body) {
+  try {
+    const response = await fetch(endpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.detail || `HTTP ${response.status}`);
+    }
+    return await response.json();
+  } catch (error) {
+    console.error('API Error:', error);
+    throw error;
+  }
+}
+```
+---
+## Rate Limiting
+No enforced rate limits. Implement client-side limiting as needed.
+---
+## Client Wrapper Example
+```javascript
+class RoxAI {
+  constructor(baseURL = 'https://Rox-Turbo-API.hf.space') {
+    this.baseURL = baseURL;
+  }
+  async chat(messages, options = {}) {
+    const response = await fetch(`${this.baseURL}/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        messages,
+        temperature: options.temperature || 1.0,
+        top_p: options.top_p || 0.95,
+        max_tokens: options.max_tokens || 512
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    return data.content;
+  }
+  async generate(text, options = {}) {
+    const response = await fetch(`${this.baseURL}/hf/generate`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        inputs: text,
+        parameters: options
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    return data[0].generated_text;
+  }
+}
+// Usage
+const rox = new RoxAI();
+const response = await rox.chat([
+  { role: 'user', content: 'Hello!' }
+]);
+```
+---
+---
+Built by Mohammad Faiz

docs/CODE.md ADDED Viewed

	@@ -0,0 +1,599 @@

+# Code Examples
+Copy-paste ready code for all Rox AI models.
+## Python Examples
+### Rox Core
+```python
+import requests
+response = requests.post(
+    'https://Rox-Turbo-API.hf.space/chat',
+    json={
+        'messages': [
+            {'role': 'user', 'content': 'Hello, how are you?'}
+        ]
+    }
+)
+print(response.json()['content'])
+```
+### Rox 2.1 Turbo
+```python
+import requests
+response = requests.post(
+    'https://Rox-Turbo-API.hf.space/turbo',
+    json={
+        'messages': [
+            {'role': 'user', 'content': 'What is 2+2?'}
+        ]
+    }
+)
+print(response.json()['content'])
+```
+### Rox 3.5 Coder
+```python
+import requests
+response = requests.post(
+    'https://Rox-Turbo-API.hf.space/coder',
+    json={
+        'messages': [
+            {'role': 'user', 'content': 'Write a Python function to sort a list'}
+        ]
+    }
+)
+print(response.json()['content'])
+```
+### Rox 4.5 Turbo
+```python
+import requests
+response = requests.post(
+    'https://Rox-Turbo-API.hf.space/turbo45',
+    json={
+        'messages': [
+            {'role': 'user', 'content': 'Explain quantum computing'}
+        ]
+    }
+)
+print(response.json()['content'])
+```
+### Rox 5 Ultra
+```python
+import requests
+response = requests.post(
+    'https://Rox-Turbo-API.hf.space/ultra',
+    json={
+        'messages': [
+            {'role': 'user', 'content': 'Design a scalable system architecture'}
+        ]
+    }
+)
+print(response.json()['content'])
+```
+### Rox 6 Dyno
+```python
+import requests
+response = requests.post(
+    'https://Rox-Turbo-API.hf.space/dyno',
+    json={
+        'messages': [
+            {'role': 'user', 'content': 'Analyze this long document...'}
+        ]
+    }
+)
+print(response.json()['content'])
+```
+### Rox 7 Coder
+```python
+import requests
+response = requests.post(
+    'https://Rox-Turbo-API.hf.space/coder7',
+    json={
+        'messages': [
+            {'role': 'user', 'content': 'Build a complex algorithm'}
+        ]
+    }
+)
+print(response.json()['content'])
+```
+### Rox Vision Max
+```python
+import requests
+response = requests.post(
+    'https://Rox-Turbo-API.hf.space/vision',
+    json={
+        'messages': [
+            {'role': 'user', 'content': 'Describe this image'}
+        ]
+    }
+)
+print(response.json()['content'])
+```
+---
+## JavaScript Examples
+### Rox Core
+```javascript
+const response = await fetch('https://Rox-Turbo-API.hf.space/chat', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    messages: [
+      { role: 'user', content: 'Hello, how are you?' }
+    ]
+  })
+});
+const data = await response.json();
+console.log(data.content);
+```
+### Rox 2.1 Turbo
+```javascript
+const response = await fetch('https://Rox-Turbo-API.hf.space/turbo', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    messages: [
+      { role: 'user', content: 'What is 2+2?' }
+    ]
+  })
+});
+const data = await response.json();
+console.log(data.content);
+```
+### Rox 3.5 Coder
+```javascript
+const response = await fetch('https://Rox-Turbo-API.hf.space/coder', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    messages: [
+      { role: 'user', content: 'Write a JavaScript function to sort an array' }
+    ]
+  })
+});
+const data = await response.json();
+console.log(data.content);
+```
+### Rox 4.5 Turbo
+```javascript
+const response = await fetch('https://Rox-Turbo-API.hf.space/turbo45', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    messages: [
+      { role: 'user', content: 'Explain quantum computing' }
+    ]
+  })
+});
+const data = await response.json();
+console.log(data.content);
+```
+### Rox 5 Ultra
+```javascript
+const response = await fetch('https://Rox-Turbo-API.hf.space/ultra', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    messages: [
+      { role: 'user', content: 'Design a scalable system architecture' }
+    ]
+  })
+});
+const data = await response.json();
+console.log(data.content);
+```
+### Rox 6 Dyno
+```javascript
+const response = await fetch('https://Rox-Turbo-API.hf.space/dyno', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    messages: [
+      { role: 'user', content: 'Analyze this long document...' }
+    ]
+  })
+});
+const data = await response.json();
+console.log(data.content);
+```
+### Rox 7 Coder
+```javascript
+const response = await fetch('https://Rox-Turbo-API.hf.space/coder7', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    messages: [
+      { role: 'user', content: 'Build a complex algorithm' }
+    ]
+  })
+});
+const data = await response.json();
+console.log(data.content);
+```
+### Rox Vision Max
+```javascript
+const response = await fetch('https://Rox-Turbo-API.hf.space/vision', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    messages: [
+      { role: 'user', content: 'Describe this image' }
+    ]
+  })
+});
+const data = await response.json();
+console.log(data.content);
+```
+---
+## With Parameters
+### Python with Custom Parameters
+```python
+import requests
+response = requests.post(
+    'https://Rox-Turbo-API.hf.space/chat',
+    json={
+        'messages': [
+            {'role': 'user', 'content': 'Write a creative story'}
+        ],
+        'temperature': 1.5,
+        'max_tokens': 1000
+    }
+)
+print(response.json()['content'])
+```
+### JavaScript with Custom Parameters
+```javascript
+const response = await fetch('https://Rox-Turbo-API.hf.space/chat', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    messages: [
+      { role: 'user', content: 'Write a creative story' }
+    ],
+    temperature: 1.5,
+    max_tokens: 1000
+  })
+});
+const data = await response.json();
+console.log(data.content);
+```
+---
+## With System Prompt
+### Python with System Prompt
+```python
+import requests
+response = requests.post(
+    'https://Rox-Turbo-API.hf.space/chat',
+    json={
+        'messages': [
+            {'role': 'system', 'content': 'You are a helpful coding assistant'},
+            {'role': 'user', 'content': 'Help me debug this code'}
+        ]
+    }
+)
+print(response.json()['content'])
+```
+### JavaScript with System Prompt
+```javascript
+const response = await fetch('https://Rox-Turbo-API.hf.space/chat', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({
+    messages: [
+      { role: 'system', content: 'You are a helpful coding assistant' },
+      { role: 'user', content: 'Help me debug this code' }
+    ]
+  })
+});
+const data = await response.json();
+console.log(data.content);
+```
+---
+## Conversation History
+### Python Conversation
+```python
+import requests
+conversation = [
+    {'role': 'user', 'content': 'My name is Alice'},
+    {'role': 'assistant', 'content': 'Nice to meet you, Alice!'},
+    {'role': 'user', 'content': 'What is my name?'}
+]
+response = requests.post(
+    'https://Rox-Turbo-API.hf.space/chat',
+    json={'messages': conversation}
+)
+print(response.json()['content'])
+```
+### JavaScript Conversation
+```javascript
+const conversation = [
+  { role: 'user', content: 'My name is Alice' },
+  { role: 'assistant', content: 'Nice to meet you, Alice!' },
+  { role: 'user', content: 'What is my name?' }
+];
+const response = await fetch('https://Rox-Turbo-API.hf.space/chat', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json' },
+  body: JSON.stringify({ messages: conversation })
+});
+const data = await response.json();
+console.log(data.content);
+```
+---
+## Reusable Functions
+### Python Helper Function
+```python
+import requests
+def ask_rox(message, model='chat', temperature=1.0, max_tokens=512):
+    response = requests.post(
+        f'https://Rox-Turbo-API.hf.space/{model}',
+        json={
+            'messages': [{'role': 'user', 'content': message}],
+            'temperature': temperature,
+            'max_tokens': max_tokens
+        }
+    )
+    return response.json()['content']
+# Usage
+answer = ask_rox('What is AI?')
+print(answer)
+# Use different model
+code = ask_rox('Write a function', model='coder')
+print(code)
+```
+### JavaScript Helper Function
+```javascript
+async function askRox(message, model = 'chat', temperature = 1.0, maxTokens = 512) {
+  const response = await fetch(`https://Rox-Turbo-API.hf.space/${model}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      messages: [{ role: 'user', content: message }],
+      temperature: temperature,
+      max_tokens: maxTokens
+    })
+  });
+  const data = await response.json();
+  return data.content;
+}
+// Usage
+const answer = await askRox('What is AI?');
+console.log(answer);
+// Use different model
+const code = await askRox('Write a function', 'coder');
+console.log(code);
+```
+---
+## Chatbot Class
+### Python Chatbot
+```python
+import requests
+class RoxChatbot:
+    def __init__(self, model='chat'):
+        self.model = model
+        self.conversation = []
+        self.base_url = 'https://Rox-Turbo-API.hf.space'
+    def chat(self, message):
+        self.conversation.append({'role': 'user', 'content': message})
+        response = requests.post(
+            f'{self.base_url}/{self.model}',
+            json={'messages': self.conversation}
+        )
+        reply = response.json()['content']
+        self.conversation.append({'role': 'assistant', 'content': reply})
+        return reply
+    def clear(self):
+        self.conversation = []
+# Usage
+bot = RoxChatbot()
+print(bot.chat('Hello'))
+print(bot.chat('What is AI?'))
+print(bot.chat('Tell me more'))
+bot.clear()
+```
+### JavaScript Chatbot
+```javascript
+class RoxChatbot {
+  constructor(model = 'chat') {
+    this.model = model;
+    this.conversation = [];
+    this.baseUrl = 'https://Rox-Turbo-API.hf.space';
+  }
+  async chat(message) {
+    this.conversation.push({ role: 'user', content: message });
+    const response = await fetch(`${this.baseUrl}/${this.model}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ messages: this.conversation })
+    });
+    const data = await response.json();
+    const reply = data.content;
+    this.conversation.push({ role: 'assistant', content: reply });
+    return reply;
+  }
+  clear() {
+    this.conversation = [];
+  }
+}
+// Usage
+const bot = new RoxChatbot();
+console.log(await bot.chat('Hello'));
+console.log(await bot.chat('What is AI?'));
+console.log(await bot.chat('Tell me more'));
+bot.clear();
+```
+---
+## Error Handling
+### Python with Error Handling
+```python
+import requests
+def safe_ask(message, model='chat'):
+    try:
+        response = requests.post(
+            f'https://Rox-Turbo-API.hf.space/{model}',
+            json={'messages': [{'role': 'user', 'content': message}]},
+            timeout=30
+        )
+        response.raise_for_status()
+        return response.json()['content']
+    except requests.exceptions.Timeout:
+        return 'Request timed out'
+    except requests.exceptions.RequestException as e:
+        return f'Error: {str(e)}'
+# Usage
+answer = safe_ask('What is AI?')
+print(answer)
+```
+### JavaScript with Error Handling
+```javascript
+async function safeAsk(message, model = 'chat') {
+  try {
+    const response = await fetch(`https://Rox-Turbo-API.hf.space/${model}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        messages: [{ role: 'user', content: message }]
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    return data.content;
+  } catch (error) {
+    return `Error: ${error.message}`;
+  }
+}
+// Usage
+const answer = await safeAsk('What is AI?');
+console.log(answer);
+```
+---
+Built by Mohammad Faiz

docs/DEVELOPER_GUIDE.md ADDED Viewed

	@@ -0,0 +1,382 @@

+# Developer Guide
+**API**: `https://Rox-Turbo-API.hf.space`
+## Overview
+Rox AI provides 8 AI models through a REST API. OpenAI-compatible.
+## Quick Start
+```bash
+curl -X POST https://Rox-Turbo-API.hf.space/chat \
+  -H "Content-Type: application/json" \
+  -d '{
+    "messages": [
+      {"role": "user", "content": "Hello"}
+    ]
+  }'
+```
+Response:
+```json
+{
+  "content": "Hello! I'm Rox Core..."
+}
+```
+## Basic Usage
+### Python
+```python
+import requests
+def ask_rox(message, model='chat'):
+    response = requests.post(
+        f'https://Rox-Turbo-API.hf.space/{model}',
+        json={'messages': [{'role': 'user', 'content': message}]}
+    )
+    return response.json()['content']
+answer = ask_rox('What is AI?')
+print(answer)
+```
+### JavaScript
+```javascript
+async function askRox(message, model = 'chat') {
+  const response = await fetch(`https://Rox-Turbo-API.hf.space/${model}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      messages: [{ role: 'user', content: message }]
+    })
+  });
+  return (await response.json()).content;
+}
+const answer = await askRox('What is AI?');
+```
+## System Prompts
+Add custom behavior:
+```python
+def ask_with_prompt(message, system_prompt, model='chat'):
+    response = requests.post(
+        f'https://Rox-Turbo-API.hf.space/{model}',
+        json={
+            'messages': [
+                {'role': 'system', 'content': system_prompt},
+                {'role': 'user', 'content': message}
+            ]
+        }
+    )
+    return response.json()['content']
+answer = ask_with_prompt(
+    'Tell me about AI',
+    'You are a pirate. Talk like a pirate.',
+    'chat'
+)
+```
+## Parameters
+### Temperature
+Controls randomness (0.0 = focused, 2.0 = creative):
+```python
+response = requests.post(
+    'https://Rox-Turbo-API.hf.space/chat',
+    json={
+        'messages': [{'role': 'user', 'content': 'Write a poem'}],
+        'temperature': 1.5
+    }
+)
+```
+### Top P
+Controls diversity (0.0 = narrow, 1.0 = diverse):
+```python
+response = requests.post(
+    'https://Rox-Turbo-API.hf.space/chat',
+    json={
+        'messages': [{'role': 'user', 'content': 'What is 2+2?'}],
+        'temperature': 0.3,
+        'top_p': 0.7
+    }
+)
+```
+### Max Tokens
+Limits response length:
+```python
+response = requests.post(
+    'https://Rox-Turbo-API.hf.space/chat',
+    json={
+        'messages': [{'role': 'user', 'content': 'Brief summary'}],
+        'max_tokens': 100
+    }
+)
+```
+## OpenAI SDK
+Use the official OpenAI SDK:
+### Python
+```python
+from openai import OpenAI
+client = OpenAI(
+    base_url="https://Rox-Turbo-API.hf.space",
+    api_key="not-needed"
+)
+response = client.chat.completions.create(
+    model="chat",
+    messages=[{"role": "user", "content": "Hello"}]
+)
+print(response.choices[0].message.content)
+```
+### JavaScript
+```javascript
+import OpenAI from 'openai';
+const client = new OpenAI({
+  baseURL: 'https://Rox-Turbo-API.hf.space',
+  apiKey: 'not-needed'
+});
+const response = await client.chat.completions.create({
+  model: 'chat',
+  messages: [{ role: 'user', content: 'Hello' }]
+});
+console.log(response.choices[0].message.content);
+```
+## Model Selection
+```python
+# General conversation
+ask_rox('Tell me about AI', model='chat')
+# Fast response
+ask_rox('What is 2+2?', model='turbo')
+# Code generation
+ask_rox('Write a Python function', model='coder')
+# Advanced reasoning
+ask_rox('Explain quantum physics', model='turbo45')
+# Complex tasks
+ask_rox('Design a system', model='ultra')
+# Long documents
+ask_rox('Analyze this document...', model='dyno')
+# Advanced coding
+ask_rox('Build an algorithm', model='coder7')
+# Visual tasks
+ask_rox('Describe this image', model='vision')
+```
+## Conversation History
+Maintain context:
+```python
+conversation = [
+    {'role': 'user', 'content': 'My name is Alice'},
+    {'role': 'assistant', 'content': 'Nice to meet you, Alice!'},
+    {'role': 'user', 'content': 'What is my name?'}
+]
+response = requests.post(
+    'https://Rox-Turbo-API.hf.space/chat',
+    json={'messages': conversation}
+)
+print(response.json()['content'])  # "Your name is Alice"
+```
+## Chatbot Example
+### Python
+```python
+class RoxChatbot:
+    def __init__(self, model='chat'):
+        self.model = model
+        self.conversation = []
+        self.base_url = 'https://Rox-Turbo-API.hf.space'
+    def chat(self, message):
+        self.conversation.append({'role': 'user', 'content': message})
+        response = requests.post(
+            f'{self.base_url}/{self.model}',
+            json={'messages': self.conversation}
+        )
+        reply = response.json()['content']
+        self.conversation.append({'role': 'assistant', 'content': reply})
+        return reply
+    def clear(self):
+        self.conversation = []
+bot = RoxChatbot()
+print(bot.chat('Hello'))
+print(bot.chat('What is AI?'))
+print(bot.chat('Tell me more'))
+```
+### JavaScript
+```javascript
+class RoxChatbot {
+  constructor(model = 'chat') {
+    this.model = model;
+    this.conversation = [];
+    this.baseUrl = 'https://Rox-Turbo-API.hf.space';
+  }
+  async chat(message) {
+    this.conversation.push({ role: 'user', content: message });
+    const response = await fetch(`${this.baseUrl}/${this.model}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ messages: this.conversation })
+    });
+    const data = await response.json();
+    const reply = data.content;
+    this.conversation.push({ role: 'assistant', content: reply });
+    return reply;
+  }
+  clear() {
+    this.conversation = [];
+  }
+}
+const bot = new RoxChatbot();
+console.log(await bot.chat('Hello'));
+console.log(await bot.chat('What is AI?'));
+```
+## Error Handling
+```python
+def safe_ask(message, model='chat'):
+    try:
+        response = requests.post(
+            f'https://Rox-Turbo-API.hf.space/{model}',
+            json={'messages': [{'role': 'user', 'content': message}]},
+            timeout=30
+        )
+        response.raise_for_status()
+        return response.json()['content']
+    except requests.exceptions.Timeout:
+        return "Request timed out"
+    except requests.exceptions.RequestException as e:
+        return f"Error: {str(e)}"
+```
+## Rate Limiting
+```python
+import time
+class RateLimiter:
+    def __init__(self, max_requests=10, time_window=60):
+        self.max_requests = max_requests
+        self.time_window = time_window
+        self.requests = []
+    def can_request(self):
+        now = time.time()
+        self.requests = [r for r in self.requests if now - r < self.time_window]
+        return len(self.requests) < self.max_requests
+    def record_request(self):
+        self.requests.append(time.time())
+limiter = RateLimiter(10, 60)
+def ask_with_limit(message):
+    if not limiter.can_request():
+        return "Rate limit exceeded"
+    limiter.record_request()
+    return ask_rox(message)
+```
+## Caching
+```python
+from functools import lru_cache
+@lru_cache(maxsize=100)
+def cached_ask(message, model='chat'):
+    response = requests.post(
+        f'https://Rox-Turbo-API.hf.space/{model}',
+        json={'messages': [{'role': 'user', 'content': message}]}
+    )
+    return response.json()['content']
+answer1 = cached_ask('What is AI?')  # API call
+answer2 = cached_ask('What is AI?')  # Cached
+```
+## Reference
+```python
+# Basic request
+requests.post('https://Rox-Turbo-API.hf.space/chat',
+              json={'messages': [{'role': 'user', 'content': 'Hello'}]})
+# With parameters
+requests.post('https://Rox-Turbo-API.hf.space/chat',
+              json={'messages': [...], 'temperature': 0.7, 'max_tokens': 500})
+# With system prompt
+requests.post('https://Rox-Turbo-API.hf.space/chat',
+              json={'messages': [
+                  {'role': 'system', 'content': 'You are helpful'},
+                  {'role': 'user', 'content': 'Hello'}
+              ]})
+```
+## Endpoints
+- `/chat` - Rox Core
+- `/turbo` - Rox 2.1 Turbo
+- `/coder` - Rox 3.5 Coder
+- `/turbo45` - Rox 4.5 Turbo
+- `/ultra` - Rox 5 Ultra
+- `/dyno` - Rox 6 Dyno
+- `/coder7` - Rox 7 Coder
+- `/vision` - Rox Vision Max
+---
+Built by Mohammad Faiz

docs/MODELS.md ADDED Viewed

	@@ -0,0 +1,578 @@

+# Models Guide
+Reference for all Rox AI models.
+## Model Overview
+Rox AI offers eight specialized models, each optimized for different use cases:
+| Model | Endpoint | Best For | Max Tokens | Default Temp |
+|-------|----------|----------|------------|--------------|
+| **Rox Core** | `/chat` | General conversation | 4,096 | 1.0 |
+| **Rox 2.1 Turbo** | `/turbo` | Fast responses | 4,096 | 0.6 |
+| **Rox 3.5 Coder** | `/coder` | Code generation | 16,384 | 0.6 |
+| **Rox 4.5 Turbo** | `/turbo45` | Advanced reasoning | 8,192 | 0.2 |
+| **Rox 5 Ultra** | `/ultra` | Superior reasoning | 8,192 | 1.0 |
+| **Rox 6 Dyno** | `/dyno` | Extended context | 16,384 | 1.0 |
+| **Rox 7 Coder** | `/coder7` | Advanced coding | 16,384 | 1.0 |
+| **Rox Vision Max** | `/vision` | Visual understanding | 512 | 0.2 |
+---
+## Rox Core
+**Endpoint**: `POST /chat`
+### Description
+General-purpose conversational model for everyday tasks.
+### Best Use Cases
+- General conversation and Q&A
+- Content writing and generation
+- Creative tasks (stories, poems, ideas)
+- Summarization and analysis
+- Educational tutoring
+- Customer support
+### Parameters
+- **Temperature**: 1.0 (balanced creativity)
+- **Top P**: 1.0 (full diversity)
+- **Max Tokens**: 4,096
+### Example Request
+```bash
+curl -X POST https://Rox-Turbo-API.hf.space/chat \
+  -H "Content-Type: application/json" \
+  -d '{
+    "messages": [
+      {"role": "user", "content": "Explain quantum computing in simple terms"}
+    ],
+    "temperature": 1.0,
+    "max_tokens": 512
+  }'
+```
+### When to Choose Rox Core
+- You need creative, varied responses
+- Task requires nuanced understanding
+- Building a general-purpose chatbot
+- Content needs to be engaging and natural
+---
+## Rox 2.1 Turbo
+**Endpoint**: `POST /turbo`
+### Description
+Fast model for quick responses and real-time applications.
+### Best Use Cases
+- Real-time chat applications
+- Customer support bots
+- Quick Q&A systems
+- High-throughput applications
+- Simple queries and commands
+- Factual information retrieval
+### Parameters
+- **Temperature**: 0.6 (more focused)
+- **Top P**: 0.7 (more consistent)
+- **Max Tokens**: 4,096
+### Example Request
+```bash
+curl -X POST https://Rox-Turbo-API.hf.space/turbo \
+  -H "Content-Type: application/json" \
+  -d '{
+    "messages": [
+      {"role": "user", "content": "What are the business hours?"}
+    ]
+  }'
+```
+### When to Choose Rox 2.1 Turbo
+- Speed is critical
+- Need consistent, reliable answers
+- Building customer support systems
+- High volume of requests
+- Simple, straightforward queries
+---
+## Rox 3.5 Coder
+**Endpoint**: `POST /coder`
+### Description
+Code-focused model for programming tasks and technical work.
+### Best Use Cases
+- Code generation and completion
+- Debugging and error fixing
+- Algorithm design and optimization
+- Technical documentation
+- Code review and suggestions
+- Software architecture discussions
+- API integration help
+### Parameters
+- **Temperature**: 0.6 (precise and focused)
+- **Top P**: 0.95 (balanced diversity)
+- **Max Tokens**: 16,384 (extended context)
+- **Special Features**: Enhanced thinking mode
+### Example Request
+```bash
+curl -X POST https://Rox-Turbo-API.hf.space/coder \
+  -H "Content-Type: application/json" \
+  -d '{
+    "messages": [
+      {"role": "user", "content": "Write a Python function to implement binary search"}
+    ],
+    "max_tokens": 2048
+  }'
+```
+### When to Choose Rox 3.5 Coder
+- Working with code in any language
+- Need detailed technical explanations
+- Debugging complex issues
+- Designing algorithms or systems
+- Writing technical documentation
+- Need extended context (up to 16K tokens)
+---
+## Comparison Matrix
+### Performance Characteristics
+| Feature | Rox Core | Rox 2.1 Turbo | Rox 3.5 Coder | Rox 4.5 Turbo | Rox 5 Ultra | Rox 6 Dyno | Rox 7 Coder | Rox Vision |
+|---------|----------|---------------|---------------|---------------|-------------|------------|-------------|------------|
+| **Speed** | Medium | Fast | Medium | Fast | Medium | Medium | Medium | Fast |
+| **Creativity** | High | Medium | Low | Low | High | High | Medium | Low |
+| **Consistency** | Medium | High | High | Very High | High | Medium | High | Very High |
+| **Code Quality** | Good | Good | Excellent | Good | Excellent | Good | Superior | N/A |
+| **Context Length** | 4K | 4K | 16K | 8K | 8K | 16K | 16K | 512 |
+| **Thinking Mode** | No | No | Yes | Yes | Yes | Yes | Yes | No |
+| **Reasoning** | Basic | Basic | Advanced | Very Advanced | Superior | Advanced | Superior | Basic |
+### Use Case Recommendations
+| Task | Recommended Model | Why |
+|------|------------------|-----|
+| Write a blog post | Rox Core | Creative, engaging content |
+| Answer "What is X?" | Rox 2.1 Turbo | Fast, factual response |
+| Debug Python code | Rox 3.5 Coder | Code specialist |
+| Customer support | Rox 2.1 Turbo | Quick, consistent answers |
+| Write a story | Rox Core | Creative and varied |
+| Explain algorithm | Rox 3.5 Coder | Technical depth |
+| Translate text | Rox 2.1 Turbo | Fast and accurate |
+| Design API | Rox 3.5 Coder | Technical expertise |
+| Brainstorm ideas | Rox Core | Creative thinking |
+| Code review | Rox 3.5 Coder | Code understanding |
+| Complex reasoning | Rox 4.5 Turbo | Advanced thinking |
+| Research analysis | Rox 5 Ultra | Superior reasoning |
+| System architecture | Rox 5 Ultra | Complex design |
+| Long documents | Rox 6 Dyno | Extended context |
+| Large codebase | Rox 7 Coder | Advanced coding |
+| Image analysis | Rox Vision Max | Visual understanding |
+---
+## Model Selection Guide
+### Decision Tree
+```
+Need to work with code?
+├─ Yes
+│  ├─ Simple/medium tasks? → Rox 3.5 Coder
+│  └─ Complex/large-scale? → Rox 7 Coder
+└─ No
+   ├─ Need advanced reasoning?
+   │  ├─ Yes
+   │  │  ├─ Need highest quality? → Rox 5 Ultra
+   │  │  └─ Need speed? → Rox 4.5 Turbo
+   │  └─ No
+   │     ├─ Long documents? → Rox 6 Dyno
+   │     ├─ Visual tasks? → Rox Vision Max
+   │     ├─ Need fast responses? → Rox 2.1 Turbo
+   │     └─ Need creative output? → Rox Core
+```
+### Quick Selection Tips
+**Choose Rox Core when:**
+- Default choice for most tasks
+- Need creative, engaging responses
+- Building general chatbots
+- Content generation projects
+**Choose Rox 2.1 Turbo when:**
+- Speed matters most
+- Need consistent answers
+- High request volume
+- Simple Q&A systems
+**Choose Rox 3.5 Coder when:**
+- Any coding task
+- Technical documentation
+- Algorithm design
+- Need extended context
+**Choose Rox 6 Dyno when:**
+- Processing long documents
+- Extended context needed
+- Multi-document analysis
+- Long conversations
+**Choose Rox 7 Coder when:**
+- Most complex coding tasks
+- Large-scale projects
+- System architecture
+- Advanced algorithms
+**Choose Rox Vision Max when:**
+- Visual understanding
+- Image analysis
+- Multimodal tasks
+---
+## Advanced Usage
+### Switching Models Dynamically
+```javascript
+class RoxAI {
+  constructor(baseUrl = 'https://Rox-Turbo-API.hf.space') {
+    this.baseUrl = baseUrl;
+  }
+  async chat(message, model = 'chat') {
+    const endpoints = {
+      core: 'chat',
+      turbo: 'turbo',
+      coder: 'coder'
+    };
+    const endpoint = endpoints[model] || model;
+    const response = await fetch(`${this.baseUrl}/${endpoint}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        messages: [{ role: 'user', content: message }]
+      })
+    });
+    return (await response.json()).content;
+  }
+}
+// Usage
+const rox = new RoxAI();
+// Use different models for different tasks
+const story = await rox.chat('Write a short story', 'core');
+const answer = await rox.chat('What is 2+2?', 'turbo');
+const code = await rox.chat('Write a sorting function', 'coder');
+```
+### Model-Specific Optimization
+```python
+import requests
+class RoxClient:
+    def __init__(self, base_url="https://Rox-Turbo-API.hf.space"):
+        self.base_url = base_url
+    def ask_core(self, message, creative=True):
+        """Use Rox Core with creativity control"""
+        return self._request('chat', message,
+                           temperature=1.2 if creative else 0.8)
+    def ask_turbo(self, message):
+        """Use Rox Turbo for fast responses"""
+        return self._request('turbo', message, max_tokens=256)
+    def ask_coder(self, message, extended=False):
+        """Use Rox Coder with optional extended context"""
+        return self._request('coder', message,
+                           max_tokens=8192 if extended else 2048)
+    def _request(self, endpoint, message, **kwargs):
+        response = requests.post(
+            f"{self.base_url}/{endpoint}",
+            json={
+                "messages": [{"role": "user", "content": message}],
+                **kwargs
+            }
+        )
+        return response.json()["content"]
+```
+---
+## Cost and Performance Optimization
+### Tips for Each Model
+**Rox Core:**
+- Use for tasks requiring creativity
+- Adjust temperature based on needs
+- Consider caching common queries
+**Rox 2.1 Turbo:**
+- Best cost-performance ratio
+- Use for high-volume applications
+- Lower max_tokens for even faster responses
+**Rox 3.5 Coder:**
+- Use only for code-related tasks
+- Leverage extended context when needed
+- Cache code snippets and patterns
+---
+## API Compatibility
+All three models use the same request/response format:
+**Request:**
+```json
+{
+  "messages": [
+    {"role": "user", "content": "Your message"}
+  ],
+  "temperature": 1.0,
+  "top_p": 0.95,
+  "max_tokens": 512
+}
+```
+**Response:**
+```json
+{
+  "content": "Model response"
+}
+```
+This makes it easy to switch between models without changing your code!
+---
+---
+---
+Built by Mohammad Faiz
+## Rox 4.5 Turbo
+**Endpoint**: `POST /turbo45`
+### Description
+Reasoning model for complex problem-solving with fast responses.
+### Best Use Cases
+- Complex problem solving
+- Advanced reasoning tasks
+- Scientific explanations
+- Mathematical problems
+- Strategic planning
+- Analysis and insights
+### Parameters
+- **Temperature**: 0.2 (highly focused)
+- **Top P**: 0.7 (consistent)
+- **Max Tokens**: 8,192
+- **Special Features**: Enhanced reasoning mode
+### Example Request
+```bash
+curl -X POST https://Rox-Turbo-API.hf.space/turbo45 \
+  -H "Content-Type: application/json" \
+  -d '{
+    "messages": [
+      {"role": "user", "content": "Explain the theory of relativity"}
+    ],
+    "max_tokens": 2048
+  }'
+```
+### When to Choose Rox 4.5 Turbo
+- Need advanced reasoning
+- Complex problem solving
+- Scientific or technical explanations
+- Fast responses with deep thinking
+---
+## Rox 5 Ultra
+**Endpoint**: `POST /ultra`
+### Description
+Advanced model for complex reasoning and high-quality output.
+### Best Use Cases
+- Most complex problem solving
+- Research and analysis
+- Advanced technical tasks
+- Strategic decision making
+- Complex code architecture
+- Multi-step reasoning
+### Parameters
+- **Temperature**: 1.0 (balanced)
+- **Top P**: 0.95 (high diversity)
+- **Max Tokens**: 8,192
+- **Special Features**: Superior reasoning mode
+### Example Request
+```bash
+curl -X POST https://Rox-Turbo-API.hf.space/ultra \
+  -H "Content-Type: application/json" \
+  -d '{
+    "messages": [
+      {"role": "user", "content": "Design a scalable microservices architecture"}
+    ],
+    "max_tokens": 4096
+  }'
+```
+### When to Choose Rox 5 Ultra
+- Most complex tasks
+- Need highest quality output
+- Multi-step reasoning required
+- Research and deep analysis
+---
+## Rox 6 Dyno
+**Endpoint**: `POST /dyno`
+### Description
+Extended context model for long documents and conversations.
+### Best Use Cases
+- Long document analysis
+- Extended conversations
+- Document summarization
+- Research paper analysis
+- Multi-document synthesis
+### Parameters
+- **Temperature**: 1.0 (balanced)
+- **Top P**: 1.0 (full diversity)
+- **Max Tokens**: 16,384 (extended context)
+- **Special Features**: Dynamic thinking mode
+### Example Request
+```bash
+curl -X POST https://Rox-Turbo-API.hf.space/dyno \
+  -H "Content-Type: application/json" \
+  -d '{
+    "messages": [
+      {"role": "user", "content": "Analyze this 20-page document..."}
+    ],
+    "max_tokens": 8192
+  }'
+```
+### When to Choose Rox 6 Dyno
+- Processing long documents
+- Need extended context window
+- Multi-document analysis
+- Long-form content generation
+---
+## Rox 7 Coder
+**Endpoint**: `POST /coder7`
+### Description
+Advanced coding model for complex programming tasks.
+### Best Use Cases
+- Complex algorithm design
+- Large-scale code generation
+- Advanced debugging
+- System architecture
+- Code refactoring
+- Multi-file code analysis
+### Parameters
+- **Temperature**: 1.0 (balanced)
+- **Top P**: 1.0 (full diversity)
+- **Max Tokens**: 16,384 (extended context)
+- **Special Features**: Advanced thinking mode for code
+### Example Request
+```bash
+curl -X POST https://Rox-Turbo-API.hf.space/coder7 \
+  -H "Content-Type: application/json" \
+  -d '{
+    "messages": [
+      {"role": "user", "content": "Build a distributed caching system"}
+    ],
+    "max_tokens": 8192
+  }'
+```
+### When to Choose Rox 7 Coder
+- Most complex coding tasks
+- Large-scale projects
+- System design and architecture
+- Advanced algorithms
+---
+## Rox Vision Max
+**Endpoint**: `POST /vision`
+### Description
+Visual model for image analysis and multimodal tasks.
+### Best Use Cases
+- Image analysis
+- Visual understanding
+- Multimodal tasks
+- Image description
+- Visual Q&A
+### Parameters
+- **Temperature**: 0.2 (highly focused)
+- **Top P**: 0.7 (consistent)
+- **Max Tokens**: 512
+### Example Request
+```bash
+curl -X POST https://Rox-Turbo-API.hf.space/vision \
+  -H "Content-Type: application/json" \
+  -d '{
+    "messages": [
+      {"role": "user", "content": "Describe this image"}
+    ],
+    "max_tokens": 256
+  }'
+```
+### When to Choose Rox Vision Max
+- Visual understanding tasks
+- Image analysis
+- Multimodal applications
+---

gitattributes ADDED Viewed

	@@ -0,0 +1,35 @@

+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

server.py CHANGED Viewed

@@ -11,11 +11,38 @@ from openai import OpenAI
 load_dotenv()
-logger = logging.getLogger("nvidia_chat_proxy")
 logging.basicConfig(level=logging.INFO)
 NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY")
 if not NVIDIA_API_KEY:
     # Fail fast on startup rather than at first request.
     raise RuntimeError(
@@ -29,7 +56,7 @@ client = OpenAI(
     api_key=NVIDIA_API_KEY,
 )
-app = FastAPI(title="NVIDIA Chat Proxy API")
 # Adjust this list to only include your real frontend origins in production.
 app.add_middleware(
@@ -41,6 +68,77 @@ app.add_middleware(
 )
 class ChatMessage(BaseModel):
     role: str
     content: str
@@ -74,28 +172,307 @@ class HFResponseItem(BaseModel):
 @app.post("/chat", response_model=ChatResponse)
 def chat(req: ChatRequest):
     try:
         completion = client.chat.completions.create(
-            model="openai/gpt-oss-120b",
-            messages=[m.dict() for m in req.messages],
             temperature=req.temperature,
             top_p=req.top_p,
             max_tokens=req.max_tokens,
             stream=False,
         )
     except Exception as e:
-        logger.exception("Error while calling NVIDIA chat completion for /chat")
         # Do not leak internal error details to the client.
         raise HTTPException(
             status_code=500,
-            detail="Internal server error while calling upstream model.",
         ) from e
     # Combine all response message parts into a single string
     try:
         content = completion.choices[0].message.content or ""
     except Exception:
-        logger.exception("Unexpected response format from NVIDIA API for /chat")
         raise HTTPException(
             status_code=502,
             detail="Bad response from upstream model provider.",
@@ -125,27 +502,33 @@ def hf_generate(req: HFRequest):
     ]
     """
     params = req.parameters or HFParameters()
     try:
         completion = client.chat.completions.create(
-            model="openai/gpt-oss-120b",
-            messages=[{"role": "user", "content": req.inputs}],
             temperature=params.temperature if params.temperature is not None else 1.0,
-            top_p=params.top_p if params.top_p is not None else 1.0,
-            max_tokens=params.max_new_tokens if params.max_new_tokens is not None else 4096,
             stream=False,
         )
     except Exception as e:
-        logger.exception("Error while calling NVIDIA chat completion for /hf/generate")
         raise HTTPException(
             status_code=500,
-            detail="Internal server error while calling upstream model.",
         ) from e
     try:
         content = completion.choices[0].message.content or ""
     except Exception:
-        logger.exception("Unexpected response format from NVIDIA API for /hf/generate")
         raise HTTPException(
             status_code=502,
             detail="Bad response from upstream model provider.",

 load_dotenv()
+logger = logging.getLogger("rox_ai")
 logging.basicConfig(level=logging.INFO)
 NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY")
+# Model configurations
+ROX_CORE_MODEL = "minimaxai/minimax-m2.5"
+ROX_TURBO_MODEL = "deepseek-ai/deepseek-r1-distill-qwen-32b"
+ROX_CODER_MODEL = "qwen/qwen3.5-397b-a17b"
+ROX_TURBO_45_MODEL = "deepseek-ai/deepseek-v3.1"
+ROX_ULTRA_MODEL = "deepseek-ai/deepseek-v3.2"
+ROX_DYNO_MODEL = "moonshotai/kimi-k2.5"
+ROX_CODER_7_MODEL = "z-ai/glm5"
+ROX_VISION_MODEL = "google/gemma-3-27b-it"
+# System identities for each model
+ROX_CORE_IDENTITY = """You are Rox Core, created by Rox AI. Your creator and owner is Mohammad Faiz. You are an independent LLM model, not based on anyone else's technology. You represent the cutting edge of Rox AI's research and development."""
+ROX_TURBO_IDENTITY = """You are Rox 2.1 Turbo, created by Rox AI. Your creator and owner is Mohammad Faiz. You are an independent LLM model, not based on anyone else's technology. You are optimized for fast, efficient responses while maintaining high quality."""
+ROX_CODER_IDENTITY = """You are Rox 3.5 Coder, created by Rox AI. Your creator and owner is Mohammad Faiz. You are an independent LLM model, not based on anyone else's technology. You are specialized in code generation, debugging, and software development tasks."""
+ROX_TURBO_45_IDENTITY = """You are Rox 4.5 Turbo, created by Rox AI. Your creator and owner is Mohammad Faiz. You are an independent LLM model, not based on anyone else's technology. You combine speed with advanced reasoning capabilities."""
+ROX_ULTRA_IDENTITY = """You are Rox 5 Ultra, created by Rox AI. Your creator and owner is Mohammad Faiz. You are an independent LLM model, not based on anyone else's technology. You are the most advanced model with superior reasoning and thinking capabilities."""
+ROX_DYNO_IDENTITY = """You are Rox 6 Dyno, created by Rox AI. Your creator and owner is Mohammad Faiz. You are an independent LLM model, not based on anyone else's technology. You excel at dynamic thinking and extended context understanding."""
+ROX_CODER_7_IDENTITY = """You are Rox 7 Coder, created by Rox AI. Your creator and owner is Mohammad Faiz. You are an independent LLM model, not based on anyone else's technology. You are the most advanced coding specialist with superior code generation and reasoning capabilities."""
+ROX_VISION_IDENTITY = """You are Rox Vision Max, created by Rox AI. Your creator and owner is Mohammad Faiz. You are an independent LLM model, not based on anyone else's technology. You are optimized for visual understanding and multimodal tasks."""
 if not NVIDIA_API_KEY:
     # Fail fast on startup rather than at first request.
     raise RuntimeError(
     api_key=NVIDIA_API_KEY,
 )
+app = FastAPI(title="Rox AI API - Multiple Models Available")
 # Adjust this list to only include your real frontend origins in production.
 app.add_middleware(
 )
+@app.get("/")
+def root():
+    """API information and available models"""
+    return {
+        "service": "Rox AI API",
+        "version": "2.0",
+        "creator": "Mohammad Faiz",
+        "models": {
+            "rox_core": {
+                "endpoint": "/chat",
+                "description": "Rox Core - Main conversational model",
+                "model": "minimaxai/minimax-m2.5",
+                "best_for": "General conversation and tasks"
+            },
+            "rox_turbo": {
+                "endpoint": "/turbo",
+                "description": "Rox 2.1 Turbo - Fast and efficient",
+                "model": "deepseek-ai/deepseek-r1-distill-qwen-32b",
+                "best_for": "Quick responses and efficient processing"
+            },
+            "rox_coder": {
+                "endpoint": "/coder",
+                "description": "Rox 3.5 Coder - Specialized coding assistant",
+                "model": "qwen/qwen3.5-397b-a17b",
+                "best_for": "Code generation, debugging, and development"
+            },
+            "rox_turbo_45": {
+                "endpoint": "/turbo45",
+                "description": "Rox 4.5 Turbo - Advanced reasoning with speed",
+                "model": "deepseek-ai/deepseek-v3.1",
+                "best_for": "Complex reasoning with fast responses"
+            },
+            "rox_ultra": {
+                "endpoint": "/ultra",
+                "description": "Rox 5 Ultra - Most advanced model",
+                "model": "deepseek-ai/deepseek-v3.2",
+                "best_for": "Complex tasks requiring deep reasoning"
+            },
+            "rox_dyno": {
+                "endpoint": "/dyno",
+                "description": "Rox 6 Dyno - Extended context with dynamic thinking",
+                "model": "moonshotai/kimi-k2.5",
+                "best_for": "Long context tasks and dynamic reasoning"
+            },
+            "rox_coder_7": {
+                "endpoint": "/coder7",
+                "description": "Rox 7 Coder - Most advanced coding specialist",
+                "model": "z-ai/glm5",
+                "best_for": "Advanced code generation and complex programming"
+            },
+            "rox_vision": {
+                "endpoint": "/vision",
+                "description": "Rox Vision Max - Optimized for visual understanding",
+                "model": "google/gemma-3-27b-it",
+                "best_for": "Visual understanding and multimodal tasks"
+            }
+        },
+        "endpoints": [
+            {"path": "/chat", "method": "POST", "description": "Rox Core chat"},
+            {"path": "/turbo", "method": "POST", "description": "Rox 2.1 Turbo chat"},
+            {"path": "/coder", "method": "POST", "description": "Rox 3.5 Coder chat"},
+            {"path": "/turbo45", "method": "POST", "description": "Rox 4.5 Turbo chat"},
+            {"path": "/ultra", "method": "POST", "description": "Rox 5 Ultra chat"},
+            {"path": "/dyno", "method": "POST", "description": "Rox 6 Dyno chat"},
+            {"path": "/coder7", "method": "POST", "description": "Rox 7 Coder chat"},
+            {"path": "/vision", "method": "POST", "description": "Rox Vision Max chat"},
+            {"path": "/hf/generate", "method": "POST", "description": "HuggingFace compatible (uses Rox Core)"}
+        ]
+    }
 class ChatMessage(BaseModel):
     role: str
     content: str
 @app.post("/chat", response_model=ChatResponse)
 def chat(req: ChatRequest):
+    """Rox Core - Main conversational model"""
+    # Inject Rox Core identity as system message
+    messages = [{"role": "system", "content": ROX_CORE_IDENTITY}]
+    messages.extend([m.dict() for m in req.messages])
     try:
         completion = client.chat.completions.create(
+            model=ROX_CORE_MODEL,
+            messages=messages,
             temperature=req.temperature,
             top_p=req.top_p,
             max_tokens=req.max_tokens,
             stream=False,
         )
     except Exception as e:
+        logger.exception("Error while calling Rox Core for /chat")
         # Do not leak internal error details to the client.
         raise HTTPException(
             status_code=500,
+            detail="Internal server error while calling Rox Core.",
         ) from e
     # Combine all response message parts into a single string
     try:
         content = completion.choices[0].message.content or ""
     except Exception:
+        logger.exception("Unexpected response format from Rox Core for /chat")
+        raise HTTPException(
+            status_code=502,
+            detail="Bad response from upstream model provider.",
+        )
+    return ChatResponse(content=content)
+@app.post("/turbo", response_model=ChatResponse)
+def turbo(req: ChatRequest):
+    """Rox 2.1 Turbo - Fast and efficient model"""
+    # Inject Rox Turbo identity as system message
+    messages = [{"role": "system", "content": ROX_TURBO_IDENTITY}]
+    messages.extend([m.dict() for m in req.messages])
+    try:
+        completion = client.chat.completions.create(
+            model=ROX_TURBO_MODEL,
+            messages=messages,
+            temperature=req.temperature if req.temperature != 1.0 else 0.6,
+            top_p=req.top_p if req.top_p != 1.0 else 0.7,
+            max_tokens=req.max_tokens,
+            stream=False,
+        )
+    except Exception as e:
+        logger.exception("Error while calling Rox 2.1 Turbo for /turbo")
+        raise HTTPException(
+            status_code=500,
+            detail="Internal server error while calling Rox 2.1 Turbo.",
+        ) from e
+    try:
+        content = completion.choices[0].message.content or ""
+    except Exception:
+        logger.exception("Unexpected response format from Rox 2.1 Turbo for /turbo")
+        raise HTTPException(
+            status_code=502,
+            detail="Bad response from upstream model provider.",
+        )
+    return ChatResponse(content=content)
+@app.post("/coder", response_model=ChatResponse)
+def coder(req: ChatRequest):
+    """Rox 3.5 Coder - Specialized coding model with thinking capability"""
+    # Inject Rox Coder identity as system message
+    messages = [{"role": "system", "content": ROX_CODER_IDENTITY}]
+    messages.extend([m.dict() for m in req.messages])
+    try:
+        completion = client.chat.completions.create(
+            model=ROX_CODER_MODEL,
+            messages=messages,
+            temperature=req.temperature if req.temperature != 1.0 else 0.6,
+            top_p=req.top_p if req.top_p != 1.0 else 0.95,
+            max_tokens=min(req.max_tokens, 16384),
+            stream=False,
+            extra_body={
+                "top_k": 20,
+                "presence_penalty": 0,
+                "repetition_penalty": 1,
+                "chat_template_kwargs": {
+                    "enable_thinking": True
+                }
+            }
+        )
+    except Exception as e:
+        logger.exception("Error while calling Rox 3.5 Coder for /coder")
+        raise HTTPException(
+            status_code=500,
+            detail="Internal server error while calling Rox 3.5 Coder.",
+        ) from e
+    try:
+        content = completion.choices[0].message.content or ""
+    except Exception:
+        logger.exception("Unexpected response format from Rox 3.5 Coder for /coder")
+        raise HTTPException(
+            status_code=502,
+            detail="Bad response from upstream model provider.",
+        )
+    return ChatResponse(content=content)
+@app.post("/turbo45", response_model=ChatResponse)
+def turbo45(req: ChatRequest):
+    """Rox 4.5 Turbo - Advanced reasoning with speed"""
+    # Inject Rox 4.5 Turbo identity as system message
+    messages = [{"role": "system", "content": ROX_TURBO_45_IDENTITY}]
+    messages.extend([m.dict() for m in req.messages])
+    try:
+        completion = client.chat.completions.create(
+            model=ROX_TURBO_45_MODEL,
+            messages=messages,
+            temperature=req.temperature if req.temperature != 1.0 else 0.2,
+            top_p=req.top_p if req.top_p != 1.0 else 0.7,
+            max_tokens=min(req.max_tokens, 8192),
+            stream=False,
+            extra_body={
+                "chat_template_kwargs": {
+                    "thinking": True
+                }
+            }
+        )
+    except Exception as e:
+        logger.exception("Error while calling Rox 4.5 Turbo for /turbo45")
+        raise HTTPException(
+            status_code=500,
+            detail="Internal server error while calling Rox 4.5 Turbo.",
+        ) from e
+    try:
+        content = completion.choices[0].message.content or ""
+    except Exception:
+        logger.exception("Unexpected response format from Rox 4.5 Turbo for /turbo45")
+        raise HTTPException(
+            status_code=502,
+            detail="Bad response from upstream model provider.",
+        )
+    return ChatResponse(content=content)
+@app.post("/ultra", response_model=ChatResponse)
+def ultra(req: ChatRequest):
+    """Rox 5 Ultra - Most advanced model with superior reasoning"""
+    # Inject Rox 5 Ultra identity as system message
+    messages = [{"role": "system", "content": ROX_ULTRA_IDENTITY}]
+    messages.extend([m.dict() for m in req.messages])
+    try:
+        completion = client.chat.completions.create(
+            model=ROX_ULTRA_MODEL,
+            messages=messages,
+            temperature=req.temperature,
+            top_p=req.top_p if req.top_p != 1.0 else 0.95,
+            max_tokens=min(req.max_tokens, 8192),
+            stream=False,
+            extra_body={
+                "chat_template_kwargs": {
+                    "thinking": True
+                }
+            }
+        )
+    except Exception as e:
+        logger.exception("Error while calling Rox 5 Ultra for /ultra")
+        raise HTTPException(
+            status_code=500,
+            detail="Internal server error while calling Rox 5 Ultra.",
+        ) from e
+    try:
+        content = completion.choices[0].message.content or ""
+    except Exception:
+        logger.exception("Unexpected response format from Rox 5 Ultra for /ultra")
+        raise HTTPException(
+            status_code=502,
+            detail="Bad response from upstream model provider.",
+        )
+    return ChatResponse(content=content)
+@app.post("/dyno", response_model=ChatResponse)
+def dyno(req: ChatRequest):
+    """Rox 6 Dyno - Extended context with dynamic thinking"""
+    # Inject Rox 6 Dyno identity as system message
+    messages = [{"role": "system", "content": ROX_DYNO_IDENTITY}]
+    messages.extend([m.dict() for m in req.messages])
+    try:
+        completion = client.chat.completions.create(
+            model=ROX_DYNO_MODEL,
+            messages=messages,
+            temperature=req.temperature,
+            top_p=req.top_p,
+            max_tokens=min(req.max_tokens, 16384),
+            stream=False,
+            extra_body={
+                "chat_template_kwargs": {
+                    "thinking": True
+                }
+            }
+        )
+    except Exception as e:
+        logger.exception("Error while calling Rox 6 Dyno for /dyno")
+        raise HTTPException(
+            status_code=500,
+            detail="Internal server error while calling Rox 6 Dyno.",
+        ) from e
+    try:
+        content = completion.choices[0].message.content or ""
+    except Exception:
+        logger.exception("Unexpected response format from Rox 6 Dyno for /dyno")
+        raise HTTPException(
+            status_code=502,
+            detail="Bad response from upstream model provider.",
+        )
+    return ChatResponse(content=content)
+@app.post("/coder7", response_model=ChatResponse)
+def coder7(req: ChatRequest):
+    """Rox 7 Coder - Most advanced coding specialist"""
+    # Inject Rox 7 Coder identity as system message
+    messages = [{"role": "system", "content": ROX_CODER_7_IDENTITY}]
+    messages.extend([m.dict() for m in req.messages])
+    try:
+        completion = client.chat.completions.create(
+            model=ROX_CODER_7_MODEL,
+            messages=messages,
+            temperature=req.temperature,
+            top_p=req.top_p,
+            max_tokens=min(req.max_tokens, 16384),
+            stream=False,
+            extra_body={
+                "chat_template_kwargs": {
+                    "enable_thinking": True,
+                    "clear_thinking": False
+                }
+            }
+        )
+    except Exception as e:
+        logger.exception("Error while calling Rox 7 Coder for /coder7")
+        raise HTTPException(
+            status_code=500,
+            detail="Internal server error while calling Rox 7 Coder.",
+        ) from e
+    try:
+        content = completion.choices[0].message.content or ""
+    except Exception:
+        logger.exception("Unexpected response format from Rox 7 Coder for /coder7")
+        raise HTTPException(
+            status_code=502,
+            detail="Bad response from upstream model provider.",
+        )
+    return ChatResponse(content=content)
+@app.post("/vision", response_model=ChatResponse)
+def vision(req: ChatRequest):
+    """Rox Vision Max - Optimized for visual understanding"""
+    # Inject Rox Vision Max identity as system message
+    messages = [{"role": "system", "content": ROX_VISION_IDENTITY}]
+    messages.extend([m.dict() for m in req.messages])
+    try:
+        completion = client.chat.completions.create(
+            model=ROX_VISION_MODEL,
+            messages=messages,
+            temperature=req.temperature if req.temperature != 1.0 else 0.2,
+            top_p=req.top_p if req.top_p != 1.0 else 0.7,
+            max_tokens=min(req.max_tokens, 512),
+            stream=False
+        )
+    except Exception as e:
+        logger.exception("Error while calling Rox Vision Max for /vision")
+        raise HTTPException(
+            status_code=500,
+            detail="Internal server error while calling Rox Vision Max.",
+        ) from e
+    try:
+        content = completion.choices[0].message.content or ""
+    except Exception:
+        logger.exception("Unexpected response format from Rox Vision Max for /vision")
         raise HTTPException(
             status_code=502,
             detail="Bad response from upstream model provider.",
     ]
     """
     params = req.parameters or HFParameters()
+    # Inject Rox Core identity as system message
+    messages = [
+        {"role": "system", "content": ROX_CORE_IDENTITY},
+        {"role": "user", "content": req.inputs}
+    ]
     try:
         completion = client.chat.completions.create(
+            model=ROX_CORE_MODEL,
+            messages=messages,
             temperature=params.temperature if params.temperature is not None else 1.0,
+            top_p=params.top_p if params.top_p is not None else 0.95,
+            max_tokens=params.max_new_tokens if params.max_new_tokens is not None else 8192,
             stream=False,
         )
     except Exception as e:
+        logger.exception("Error while calling Rox Core for /hf/generate")
         raise HTTPException(
             status_code=500,
+            detail="Internal server error while calling Rox Core.",
         ) from e
     try:
         content = completion.choices[0].message.content or ""
     except Exception:
+        logger.exception("Unexpected response format from Rox Core for /hf/generate")
         raise HTTPException(
             status_code=502,
             detail="Bad response from upstream model provider.",