> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-hi/other-workloads/openclaw-on-clore.md).

# Clore पर OpenClaw

Clore.ai GPU सर्वर पर OpenClaw AI सहायक तैनात करें — हमेशा चालू, GPU-त्वरित, Telegram/Discord एकीकरण, स्थानीय LLM इन्फरेंस, और वॉइस क्षमताओं के साथ।

## अवलोकन

[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.03–0.07/घंटा                           |
| **स्थानीय 70B LLM** (vLLM + Llama 3.1 70B)         | RTX 4090 / A100   | 24–80 GB | 64 GB+ | [bare metal](https://clore.ai/bare-metal) |
| **पूरा स्टैक** (LLM + Whisper + TTS + इमेज जनरेशन) | RTX 4090          | 24 GB    | 32 GB+ | $0.14–0.42/hr                             |

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

***

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

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

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

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

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

1. सर्वर चुनें → **किराए पर लें**
2. चुनें **ऑन-डिमांड** (घंटे के हिसाब से) या **स्पॉट** (सस्ता लेकिन अधिक बोली लगाकर लिया जा सकता है)
3. Docker इमेज चुनें: **`ubuntu:22.04`** या **`nvidia/cuda:12.8.1-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 key पेस्ट करें या OAuth के माध्यम से कनेक्ट करें
2. **एक चैनल चुनें** — Telegram bot token, 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]
विवरण=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

# एक detached screen session में OpenClaw शुरू करें
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 गाइड](/guides/guides_v2-hi/language-models/ollama.md) विवरण के लिए।

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

GPU-त्वरित speech-to-text के लिए:

```bash
pip install faster-whisper

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

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

***

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

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

डिफ़ॉल्ट रूप से, गेटवे loopback (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/`           | कॉन्फ़िग, auth, state, agent profiles                |
| `~/.openclaw/workspace/` | MEMORY.md, दैनिक नोट्स, skills, tools                |
| `~/.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_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 key + Telegram bot token
```

### 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+ agents) + Ollama + साझा skills
```

***

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

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

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

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

### GPU का पता नहीं चला

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

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

### सर्वर रीस्टार्ट पर कनेक्शन टूट जाता है

Clore spot instances को वापस लिया जा सकता है। स्थायी संचालन के लिए:

* उपयोग करें **ऑन-डिमांड** मूल्य निर्धारण (spot नहीं)
* systemd सेवा सेट करें (auto-restart)
* बैकअप रखें (ऊपर वाली बैकअप स्क्रिप्ट)
* महत्वपूर्ण कार्यभार के लिए समर्पित/आरक्षित सर्वर पर विचार करें

### Node.js संस्करण समस्याएँ

```bash
# संस्करण जांचें
node --version

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

***

## टिप्स और सर्वोत्तम अभ्यास

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

***

## अधिक पढ़ें

* [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](/guides/guides_v2-hi/language-models/ollama.md)
* [Clore पर vLLM](/guides/guides_v2-hi/language-models/vllm.md)
* [GPU तुलना और मूल्य निर्धारण](/guides/guides_v2-hi/getting-started/gpu-comparison.md)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-hi/other-workloads/openclaw-on-clore.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
