# Clore पर OpenClaw

## सारांश

[OpenClaw](https://openclaw.ai) एक ओपन-सोर्स AI एजेंट प्लेटफ़ॉर्म है जो Claude, GPT, Gemini, और लोकल मॉडल्स से जुड़ता है — Telegram, Discord, WhatsApp और अन्य पर व्यक्तिगत AI सहायक के रूप में कार्य करता है। इसे Clore.ai सर्वर पर चलाने से आपको मिलता है:

* **24/7 अपटाइम** — कोई लैपटॉप स्लीप नहीं, कोई डिसकनेक्शन नहीं
* **GPU त्वरण** — स्थानीय LLM अनुमान (Ollama, vLLM), Whisper STT, TTS, इमेज जनरेशन
* **कम लागत** — ठीक उतना हार्डवेयर किराए पर लें जितनी ज़रूरत हो, घंटे के हिसाब से भुगतान करें
* **पूर्ण नियंत्रण** — रूट एक्सेस, Docker सपोर्ट, किसी भी सॉफ़्टवेयर स्टैक

### क्यों Clore + OpenClaw?

| फीचर               | लैपटॉप    | पारंपरिक VPS | Clore.ai सर्वर  |
| ------------------ | --------- | ------------ | --------------- |
| हमेशा चालू         | ❌         | ✅            | ✅               |
| GPU उपलब्ध         | सीमित     | ❌ या $$$     | ✅ $0.10/घंटा से |
| स्थानीय LLM अनुमान | धीमा      | केवल CPU     | पूर्ण GPU गति   |
| वॉइस (Whisper/TTS) | ✅         | धीमा (CPU)   | ✅ वास्तविक समय  |
| रूट + Docker       | ✅         | ✅            | ✅               |
| घंटेवार बिलिंग     | लागू नहीं | मासिक        | ✅ प्रति घंटा    |

### अनुशंसित हार्डवेयर

| उपयोग केस                                           | GPU               | VRAM     | RAM    | अनुमानित लागत   |
| --------------------------------------------------- | ----------------- | -------- | ------ | --------------- |
| **बेसिक असिस्टेंट** (केवल API, स्थानीय मॉडल नहीं)   | कोई भी / केवल CPU | —        | 8 GB+  | $0.05–0.15/घंटा |
| **लोकल 7–8B LLM** (Ollama + Llama 3.1 8B)           | RTX 3060/3070     | 12 GB    | 16 GB+ | $0.10–0.25/घंटा |
| **लोकल 70B LLM** (vLLM + Llama 3.1 70B)             | RTX 4090 / A100   | 24–80 GB | 64 GB+ | $0.30–1.00/घंटा |
| **पूर्ण स्टैक** (LLM + Whisper + TTS + इमेज जनरेशन) | RTX 4090          | 24 GB    | 32 GB+ | $0.25–0.50/घंटा |

> **सुझाव:** यदि आपको केवल API मॉडल्स (Claude, GPT) का उपयोग करने वाला क्लाउड-आधारित OpenClaw चाहिए, तो आपको GPU की बिल्कुल आवश्यकता नहीं है — एक सस्ता CPU सर्वर पर्याप्त है। स्थानीय अनुमान करने के लिए जब चाहें GPU जोड़ें।

***

## चरण 1: Clore.ai पर सर्वर किराए पर लें

### 1.1 मार्केटप्लेस ब्राउज़ करें

जाएँ [clore.ai/marketplace](https://clore.ai/marketplace) और अपनी आवश्यकताओं के अनुसार फ़िल्टर करें:

* **बेसिक असिस्टेंट के लिए**: कीमत के अनुसार सॉर्ट करें, कोई भी सस्ता Ubuntu सर्वर चुनें
* **लोकल LLM के लिए**: GPU (उदा., RTX 4090) द्वारा फ़िल्टर करें, सुनिश्चित करें ≥24 GB VRAM
* **OS**: चुनें **Ubuntu 22.04** या **Ubuntu 24.04** (सर्वोत्तम संगतता)

### 1.2 ऑर्डर बनाएं

1. सर्वर चुनें → **किराए पर लें**
2. चुनें **ऑन-डिमांड** (घंटेवार) या **स्पॉट** (सस्ता लेकिन आउटबिड हो सकता है)
3. Docker इमेज चुनें: **`ubuntu:22.04`** या **`nvidia/cuda:12.4.0-runtime-ubuntu22.04`** (यदि आपको GPU चाहिए)
4. SSH सार्वजनिक कुंजी सेट करें (या पासवर्ड का उपयोग करें — SSH कुंजी की सिफारिश की जाती है)
5. ऑर्डर की पुष्टि करें

### 1.3 SSH के माध्यम से कनेक्ट करें

एक बार सर्वर चलने पर, अपने ऑर्डर के पृष्ठ में SSH कनेक्शन विवरण देखें: [ऑर्डर](https://clore.ai/my-orders) पृष्ठ:

```bash
ssh root@<server-ip> -p <port>
```

> **नोट:** Clore सर्वर Docker कंटेनरों का उपयोग करते हैं, इसलिए आपको कंटेनर के अंदर रूट एक्सेस मिलता है। SSH पोर्ट गैर-मानक हो सकता है (उदा., 50022) — अपने ऑर्डर विवरण जांचें।

***

## चरण 2: OpenClaw स्थापित करें

### 2.1 Node.js 22+ स्थापित करें

```bash
# सिस्टम पैकेज अपडेट करें
apt update && apt upgrade -y

# NodeSource के माध्यम से Node.js 22 स्थापित करें
curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
apt install -y nodejs

# सत्यापित करें
node --version   # यह v22.x.x दिखाना चाहिए
npm --version
```

### 2.2 OpenClaw स्थापित करें

**विकल्प A: इंस्टॉलर स्क्रिप्ट (सिफारिश की गई)**

```bash
curl -fsSL https://openclaw.ai/install.sh | bash
```

स्क्रिप्ट CLI स्थापित करती है, ऑनबोर्डिंग चलाती है, और गेटवे शुरू करती है।

**विकल्प B: मैनुअल npm इंस्टॉल**

```bash
npm install -g openclaw@latest
openclaw onboard --install-daemon
```

### 2.3 ऑनबोर्डिंग विज़ार्ड चलाएँ

यदि आपने इंस्टॉलर स्क्रिप्ट का उपयोग किया, तो ऑनबोर्डिंग स्वचालित रूप से चलती है। अन्यथा:

```bash
openclaw onboard --install-daemon
```

विज़ार्ड आपसे पूछेगा:

1. **ऑथ सेट करें** — अपना Anthropic API कुंजी पेस्ट करें या OAuth के माध्यम से कनेक्ट करें
2. **एक चैनल चुनें** — Telegram बोट टोकन, Discord, WhatsApp, आदि
3. **गेटवे कॉन्फ़िगर करें** — पोर्ट, बाइंडिंग, सुरक्षा

> **Telegram के लिए:** बनाएँ एक बोट द्वारा [@BotFather](https://t.me/BotFather), टोकन कॉपी करें, और ऑनबोर्डिंग के दौरान पेस्ट करें।

***

## चरण 3: हमेशा-ऑन संचालन के लिए कॉन्फ़िगर करें

### 3.1 गेटवे को सर्विस के रूप में शुरू करें

```bash
# जांचें कि गेटवे चल रहा है या नहीं
openclaw gateway status

# शुरू करें (यदि पहले से नहीं चल रहा है)
openclaw gateway start

# सत्यापित करें कि यह स्वस्थ है
openclaw status
```

### 3.2 इसे systemd के साथ चलाते रखें (सिफारिश)

यदि OpenClaw ने systemd सेवा ऑटो-इंस्टॉल नहीं की:

```bash
# एक systemd सेवा फ़ाइल बनाएँ
cat > /etc/systemd/system/openclaw.service << 'EOF'
[Unit]
Description=OpenClaw Gateway
After=network.target

[Service]
Type=simple
ExecStart=/usr/bin/openclaw gateway --port 18789
Restart=always
RestartSec=10
Environment=NODE_ENV=production
WorkingDirectory=/root

[Install]
WantedBy=multi-user.target
EOF

# सक्षम करें और शुरू करें
systemctl daemon-reload
systemctl enable openclaw
systemctl start openclaw

# स्थिति जांचें
systemctl status openclaw
```

### 3.3 विकल्प: Screen/tmux (तेज़ और सरल)

```bash
# screen स्थापित करें
apt install -y screen

# OpenClaw को एक detached screen सत्र में शुरू करें
screen -dmS openclaw openclaw gateway --port 18789

# बाद में पुनः संलग्न करें
screen -r openclaw
```

***

## चरण 4: GPU सेटअप (वैकल्पिक — स्थानीय मॉडल्स के लिए)

यदि आप केवल API-आधारित मॉडल्स (Claude, GPT, आदि) का उपयोग करते हैं तो इस अनुभाग को छोड़ दें।

### 4.1 GPU एक्सेस सत्यापित करें

```bash
# जांचें कि NVIDIA ड्राइवर उपलब्ध हैं या नहीं
nvidia-smi
```

यदि `nvidia-smi` काम करता है, तो आपका GPU तैयार है। अधिकांश Clore CUDA इमेज पहले से कॉन्फ़िगर होकर आती हैं।

### 4.2 Ollama स्थापित करें (स्थानीय LLM अनुमान)

```bash
curl -fsSL https://ollama.com/install.sh | sh

# Ollama शुरू करें
ollama serve &

# एक मॉडल पुल करें
ollama pull llama3.1:8b        # 8B — 12GB VRAM में फिट होता है
# ollama pull llama3.1:70b     # 70B — 48GB+ VRAM चाहिए
# ollama pull qwen2.5:32b      # 32B — 24GB VRAM चाहिए
```

OpenClaw को Ollama को एक प्रदाता के रूप में उपयोग करने के लिए कॉन्फ़िगर करें — विवरण के लिए देखें [Ollama गाइड](https://docs.clore.ai/guides/guides_v2-hi/language-models/ollama) ।

### 4.3 Whisper स्थापित करें (वॉइस ट्रांसक्रिप्शन)

GPU-त्वरित स्पीच-टू-टेक्स्ट के लिए:

```bash
pip install faster-whisper

# या बेहतर सटीकता के लिए WhisperX का उपयोग करें
pip install whisperx
```

देखें [WhisperX गाइड](https://docs.clore.ai/guides/guides_v2-hi/audio-and-voice/whisperx) पूरा सेटअप के लिए।

***

## चरण 5: सुरक्षा और रिमोट एक्सेस

### 5.1 गेटवे सुरक्षित करें

डिफ़ॉल्ट के रूप में, गेटवे लूपबैक (127.0.0.1) से बाइंड होता है। रिमोट एक्सेस के लिए:

**विकल्प A: SSH टनल (सबसे सुरक्षित)**

अपने लैपटॉप से:

```bash
ssh -N -L 18789:127.0.0.1:18789 root@<server-ip> -p <port>
```

फिर खोलें `http://127.0.0.1:18789/` अपने ब्राउज़र में।

**विकल्प B: टोकन-प्रोटेक्टेड डायरेक्ट एक्सेस**

संपादित करें `~/.openclaw/config.json5`:

```json5
{
  gateway: {
    bind: "lan",       // सभी इंटरफेस पर सुनें
    port: 18789,
    auth: {
      token: "your-secret-token-here"  // रिमोट एक्सेस के लिए आवश्यक!
    }
  }
}
```

> ⚠️ **यदि बाइंड कर रहे हैं तो हमेशा एक टोकन सेट करें** lan `पर`। इसके बिना, कोई भी आपके गेटवे तक पहुँच सकता है।

### 5.2 फ़ायरवॉल सेटअप

```bash
# UFW स्थापित करें
apt install -y ufw

# SSH की अनुमति दें (अपने Clore SSH पोर्ट का उपयोग करें)
ufw allow <ssh-port>/tcp

# OpenClaw गेटवे की अनुमति दें (केवल यदि डायरेक्ट एक्सेस उपयोग कर रहे हैं)
ufw allow 18789/tcp

# फ़ायरवॉल सक्षम करें
ufw enable
```

***

## चरण 6: परसिस्टेंस और बैकअप्स

### 6.1 महत्वपूर्ण निर्देशिकाएँ

| पथ                       | सामग्री                                                |
| ------------------------ | ------------------------------------------------------ |
| `~/.openclaw/`           | कॉन्फ़िग, ऑथ, स्थिति, एजेंट प्रोफाइल्स                 |
| `~/.openclaw/workspace/` | MEMORY.md, दैनिक नोट्स, स्किल्स, उपकरण                 |
| `~/.openclaw/agents/`    | मल्टी-एजेंट कॉन्फ़िग्स (यदि टीम्स का उपयोग कर रहे हैं) |

### 6.2 बैकअप स्क्रिप्ट

अपनी कॉन्फ़िग़ सुरक्षित रखने के लिए एक सरल बैकअप बनाएँ:

```bash
cat > /root/backup-openclaw.sh << 'EOF'
#!/bin/bash
BACKUP_DIR="/root/openclaw-backups"
mkdir -p "$BACKUP_DIR"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
tar czf "$BACKUP_DIR/openclaw-$TIMESTAMP.tar.gz" \\
  ~/.openclaw/config.json5 \\
  ~/.openclaw/workspace/ \\
  ~/.openclaw/agents/ \\
  ~/.openclaw/identity/
echo "Backup saved: $BACKUP_DIR/openclaw-$TIMESTAMP.tar.gz"
EOF
chmod +x /root/backup-openclaw.sh

# दैनिक रूप से cron के माध्यम से चलाएँ
(crontab -l 2>/dev/null; echo "0 4 * * * /root/backup-openclaw.sh") | crontab -
```

### 6.3 सर्वरों के बीच माइग्रेट करना

यदि आपको किसी अलग Clore सर्वर पर स्विच करना है:

```bash
# पुराने सर्वर पर — एक्सपोर्ट करें
tar czf /tmp/openclaw-migration.tar.gz ~/.openclaw/

# नए सर्वर पर ट्रांसफर करें
scp -P <port> /tmp/openclaw-migration.tar.gz root@<new-server-ip>:/tmp/

# नए सर्वर पर — इम्पोर्ट करें
tar xzf /tmp/openclaw-migration.tar.gz -C /
openclaw gateway start
```

***

## उदाहरण कॉन्फ़िगरेशन्स

### बेसिक Telegram बोट (कोई GPU नहीं)

सबसे सस्ता सेटअप — सिर्फ एक API-पावर्ड असिस्टेंट:

```
सर्वर: कोई भी Ubuntu, GPU की आवश्यकता नहीं
लागत: ~$0.05–0.15/घंटा ($3–10/माह)
कॉन्फ़िग: Anthropic API कुंजी + Telegram बोट टोकन
```

### AI वर्कस्टेशन (GPU)

लोकल मॉडल्स के साथ पूर्ण-फीचर:

```
सर्वर: RTX 4090, 24GB VRAM, 32GB RAM
लागत: ~$0.25–0.50/घंटा
स्टैक: OpenClaw + Ollama (Llama 3.1 70B) + WhisperX + Coqui TTS
```

### मल्टी-एजेंट टीम

विशेषीकृत AI एजेंट्स की एक टीम चलाएँ:

```
सर्वर: RTX 4090 या ड्यूल GPU
लागत: ~$0.30–0.60/घंटा
स्टैक: OpenClaw मल्टी-एजेंट (5+ एजेंट) + Ollama + साझा स्किल्स
```

***

## समस्या निवारण

### गेटवे शुरू नहीं होता

```bash
# लॉग्स जांचें
openclaw gateway status
journalctl -u openclaw -n 50

# सामान्य सुधार: पोर्ट पहले से उपयोग में है
lsof -i :18789
kill <pid>
openclaw gateway start
```

### GPU नहीं मिला

```bash
# NVIDIA ड्राइवर जांचें
nvidia-smi

# यदि नहीं मिला, तो आपको CUDA Docker इमेज की आवश्यकता हो सकती है
# nvidia/cuda:12.4.0-runtime-ubuntu22.04 के साथ ऑर्डर पुन: बनाएँ
```

### सर्वर रिस्टार्ट पर कनेक्शन ड्रॉप होता है

Clore स्पॉट इंस्टेंस रीक्लेम किए जा सकते हैं। लगातार संचालन के लिए:

* उपयोग करें **ऑन-डिमांड** प्राइसिंग (स्पॉट नहीं)
* systemd सेवा सेटअप करें (ऑटो-रीस्टार्ट)
* बैकअप रखें (ऊपर बैकअप स्क्रिप्ट)
* महत्वपूर्ण वर्कलोड के लिए समर्पित/रिज़र्व्ड सर्वर पर विचार करें

### Node.js वर्शन समस्याएँ

```bash
# वर्शन जांचें
node --version

# यदि v22 से नीचे है, तो पुनः इंस्टॉल करें
curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
apt install -y nodejs
```

***

## टिप्स और सर्वोत्तम प्रथाएँ

1. **सस्ता शुरू करें** — पहले एक बेसिक CPU सर्वर का उपयोग करें। स्थानीय अनुमान के लिए जब आवश्यक हो GPU जोड़ें।
2. **उत्पादन के लिए ऑन-डिमांड का उपयोग करें** — स्पॉट सस्ता है पर रुकावट हो सकती है। ऑन-डिमांड अपटाइम की गारंटी देता है।
3. **नियमित रूप से बैकअप लें** — आपकी `~/.openclaw/workspace/` सारी मेमोरी और कॉन्फ़िग्स को रखता है।
4. **लागत मॉनिटर करें** — अपने Clore डैशबोर्ड को नियमित रूप से जांचें। यदि उपलब्ध हो तो खर्च की अलर्ट सेट करें।
5. **कंट्रोल UI का उपयोग करें** — वेब-आधारित प्रबंधन के लिए SSH टनल के माध्यम से पहुँचें `http://127.0.0.1:18789/` पर।
6. **API मॉडलों के साथ संयोजित करें** — GPU सर्वर होने पर भी, मुख्य एजेंट के लिए Claude/GPT को API के माध्यम से और विशिष्ट कार्यों (एंबेडिंग, ट्रांसक्रिप्शन) के लिए स्थानीय मॉडल्स का उपयोग करें।

***

## अग्रिम पठन

* [OpenClaw आरंभ करने की गाइड](https://docs.openclaw.ai/start/getting-started)
* [OpenClaw VPS होस्टिंग गाइड](https://docs.openclaw.ai/install/vps)
* [OpenClaw Docker सेटअप](https://docs.openclaw.ai/install/docker)
* [Clore पर Ollama](https://docs.clore.ai/guides/guides_v2-hi/language-models/ollama)
* [Clore पर vLLM](https://docs.clore.ai/guides/guides_v2-hi/language-models/vllm)
* [GPU तुलना और मूल्य निर्धारण](https://docs.clore.ai/guides/guides_v2-hi/getting-started/gpu-comparison)
