docs/CODE.md

# 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