> 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/crypto-and-mining/xmrig.md).

# XMRig माइनिंग

Clore.ai के GPU और CPU सर्वरों पर XMRig का उपयोग करके Monero (XMR) और अन्य क्रिप्टोकरेंसी माइन करें।

{% hint style="info" %}
**XMRig** सबसे व्यापक रूप से उपयोग किया जाने वाला ओपन-सोर्स क्रिप्टोकरेंसी माइनर है। यह CPU माइनिंग (Monero के लिए RandomX एल्गोरिद्म) और GPU माइनिंग (KawPow, Ethash, और अन्य) का समर्थन करता है। यह गाइड Clore.ai सर्वरों पर तैनाती को कवर करती है।
{% endhint %}

{% hint style="warning" %}
**शुरू करने से पहले**: माइनिंग शुरू करने से पहले हमेशा लाभप्रदता की गणना करें। Clore.ai किराया लागत, पूल शुल्क, और मौजूदा कॉइन कीमतों को शामिल करें। सकारात्मक रिटर्न सुनिश्चित करने के लिए माइनिंग लाभप्रदता कैलकुलेटर का उपयोग करें।
{% endhint %}

***

## XMRig क्या है?

XMRig CPU और GPU के लिए एक उच्च-प्रदर्शन, क्रॉस-प्लेटफ़ॉर्म माइनर है:

| विशेषता         | विवरण                                                |
| --------------- | ---------------------------------------------------- |
| **CPU माइनिंग** | RandomX के जरिए Monero (XMR) — सर्वोत्तम उपयोग मामला |
| **GPU माइनिंग** | KawPow (RVN), Ethash वेरिएंट, Octopus                |
| **एल्गोरिद्म**  | RandomX, KawPow, Ethash, Autolykos2, Octopus + और भी |
| **Stratum V2**  | आधुनिक पूल प्रोटोकॉल समर्थन                          |
| **TLS समर्थन**  | एन्क्रिप्टेड पूल कनेक्शन                             |
| **लाइसेंस**     | GPL 3.0, ओपन सोर्स                                   |

### XMRig के लिए Clore.ai क्यों?

* **उच्च-कोर-गणना वाले CPU**: Clore.ai सर्वरों में अक्सर 32-128 CPU कोर होते हैं — RandomX के लिए आदर्श
* **स्पॉट मूल्य निर्धारण**: ऑफ-पीक घंटों में सस्ते में किराये पर लें
* **हार्डवेयर निवेश नहीं**: हार्डवेयर खरीदे और बनाए रखे बिना माइन करें
* **लचीलापन**: लाभप्रदता के आधार पर एल्गोरिद्म या कॉइन बदलें

***

## पहले लाभप्रदता जांचें

{% hint style="danger" %}
**किराया लागत पर एक भी पैसा खर्च करने से पहले यह करें!**

माइनिंग लाभप्रदता रोज़ बदलती है। शुरू करने से पहले हमेशा सत्यापित करें।
{% endhint %}

### लाभप्रदता कैलकुलेटर

* [minerstat.com/calc](https://minerstat.com/calc) — बहु-एल्गोरिद्म
* [whattomine.com](https://whattomine.com) — व्यापक
* [xmrig.com/docs/algorithms](https://xmrig.com/docs/algorithms) — हैशरेट संदर्भ

### त्वरित गणित

```
दैनिक लाभ = (दैनिक इनाम USD में) - (दैनिक किराया लागत)

उदाहरण (Monero, 32-कोर सर्वर):
- हैशरेट: ~32,000 H/s (प्रति कोर 1,000 H/s)
- दैनिक XMR इनाम: ~0.001-0.003 XMR/दिन
- XMR कीमत (उदाहरण): $160
- दैनिक राजस्व: $0.16-0.48
- सर्वर किराया (32-कोर, ~$0.20/घंटा): $4.80/दिन

परिणाम: नकारात्मक। उच्च-कोर सर्वर अक्सर सोलो माइनिंग के लिए लाभदायक नहीं होते।

बेहतर तरीका: ऐसे सस्ते उच्च-कोर-गणना वाले सर्वर खोजें जहाँ किराया < दैनिक इनाम हो
```

{% hint style="success" %}
**यह कब समझ में आता है**: जब आपको $0.05-0.10/घंटा पर 64+ कोर वाला सर्वर मिले, या GPU-माइन योग्य कॉइनों के लिए कम स्पॉट कीमतों पर GPU सर्वर मिलें। हमेशा पहले गणना करें!
{% endhint %}

***

## पूर्वापेक्षाएँ

| आवश्यकता         | विवरण                                              |
| ---------------- | -------------------------------------------------- |
| Clore.ai खाता    | CLORE बैलेंस के साथ                                |
| माइनिंग पूल खाता | supportXMR.com, MoneroOcean आदि पर बनाएं।          |
| Monero वॉलेट     | getmonero.org से डाउनलोड करें (XMR माइनिंग के लिए) |
| SSH पहुँच        | पोर्ट 22                                           |

### एक Monero वॉलेट बनाएं

```bash
# विकल्प 1: CLI वॉलेट
wget https://downloads.getmonero.org/cli/linux64
tar xzf monero-linux-x64-*.tar.bz2
./monero-x86_64-linux-gnu-v*/monero-wallet-cli --generate-new-wallet mywallet

# विकल्प 2: GUI वॉलेट (लोकल मशीन)
# यहाँ से डाउनलोड करें: https://www.getmonero.org/downloads/
```

अपना वॉलेट पता सेव करें — यह कुछ ऐसा दिखता है:

```
43xxxx...लंबी स्ट्रिंग...xxxx
```

***

## चरण 1: सर्वर किराये पर लें

### CPU माइनिंग (Monero/RandomX) के लिए

1. पर जाएँ [clore.ai](https://clore.ai) → **मार्केटप्लेस**
2. के अनुसार फ़िल्टर करें **CPU कोर**: 32+ कोर बेहतर हैं
3. उच्च CPU थ्रेड काउंट वाले सर्वर देखें
4. पोर्ट **22** पर्याप्त है
5. सर्वर ऑर्डर करें

### GPU माइनिंग (KawPow, Octopus) के लिए

1. के अनुसार फ़िल्टर करें **GPU**: सर्वोत्तम प्रदर्शन के लिए RTX 3080+, RTX 4090
2. आवश्यक पोर्ट: **22** केवल
3. CUDA माइनिंग के लिए केवल NVIDIA GPUs

{% hint style="info" %}
**Clore.ai पर CPU बनाम GPU**: Clore.ai मुख्य रूप से एक GPU मार्केटप्लेस है। Monero (RandomX) के लिए, समर्पित CPU सर्वर सस्ते हो सकते हैं। GPU-माइन योग्य कॉइनों के लिए, NVIDIA सर्वर बेहतर प्रदर्शन देते हैं।
{% endhint %}

***

## चरण 2: Docker के माध्यम से XMRig तैनात करें

### कस्टम Dockerfile

एक `Dockerfile` सर्वर पर बनाएं:

```dockerfile
FROM ubuntu:22.04

ENV DEBIAN_FRONTEND=noninteractive

# निर्भरताएँ इंस्टॉल करें
RUN apt-get update && apt-get install -y \\
    wget \\
    libssl-dev \\
    libhwloc-dev \\
    libuv1-dev \\
    build-essential \\
    cmake \\
    git \\
    && rm -rf /var/lib/apt/lists/*

WORKDIR /opt/xmrig

# XMRig रिलीज़ डाउनलोड करें
RUN wget https://github.com/xmrig/xmrig/releases/download/v6.21.3/xmrig-6.21.3-linux-static-x64.tar.gz \\
    && tar xzf xmrig-*.tar.gz \\
    && mv xmrig-*/xmrig . \\
    && rm -rf xmrig-*.tar.gz xmrig-*/

# कॉन्फ़िग डायरेक्टरी बनाएं
RUN mkdir -p /etc/xmrig

ENTRYPOINT ["/opt/xmrig/xmrig"]
```

### इमेज बनाएं

```bash
docker build -t xmrig-miner .
```

### CPU माइनिंग चलाएं (Monero)

```bash
docker run -d \\
  --name xmrig-cpu \\
  --restart unless-stopped \\
  --privileged \\
  xmrig-miner \\
  -o pool.supportxmr.com:443 \\
  -u YOUR_MONERO_WALLET_ADDRESS \\
  -p worker1 \\
  -k \\
  --tls \\
  --cpu-max-threads-hint=100 \\
  --log-file=/var/log/xmrig.log
```

### GPU माइनिंग चलाएं (KawPow - Ravencoin)

```bash
docker run -d \\
  --name xmrig-gpu \\
  --restart unless-stopped \\
  --gpus all \\
  xmrig-miner \\
  -a kawpow \\
  -o rvn.2miners.com:6060 \\
  -u YOUR_RVN_WALLET.worker1 \\
  --log-file=/var/log/xmrig.log
```

***

## चरण 3: कॉन्फ़िगरेशन फ़ाइल विधि

कमांड-लाइन फ़्लैग्स की तुलना में कॉन्फ़िग फ़ाइल का उपयोग अधिक साफ़ है।

### बनाएँ `config.json`

```json
{
    "autosave": true,
    "background": false,
    "colors": true,
    "title": true,
    "api": {
        "id": null,
        "worker-id": "clore-worker-1",
        "port": 9090,
        "access-token": null,
        "restricted": true
    },
    "http": {
        "enabled": true,
        "host": "0.0.0.0",
        "port": 9090,
        "access-token": null,
        "restricted": true
    },
    "randomx": {
        "init": -1,
        "init-avx2": -1,
        "mode": "auto",
        "1gb-pages": false,
        "rdmsr": true,
        "wrmsr": true,
        "cache_qos": false,
        "numa": true,
        "scratchpad_prefetch_mode": 1
    },
    "cpu": {
        "enabled": true,
        "huge-pages": true,
        "huge-pages-jit": false,
        "hw-aes": null,
        "priority": null,
        "memory-pool": false,
        "yield": true,
        "max-threads-hint": 100,
        "asm": true,
        "argon2-impl": null,
        "astrobwt-max-size": 550,
        "astrobwt-avx2": false
    },
    "opencl": {
        "enabled": false,
        "cache": true,
        "loader": null,
        "platform": "AMD"
    },
    "cuda": {
        "enabled": true,
        "loader": null,
        "nvml": true
    },
    "log-file": null,
    "donate-level": 1,
    "donate-over-proxy": 1,
    "pools": [
        {
            "algo": null,
            "coin": "XMR",
            "url": "pool.supportxmr.com:443",
            "user": "YOUR_MONERO_WALLET_ADDRESS",
            "pass": "worker1",
            "rig-id": null,
            "nicehash": false,
            "keepalive": true,
            "enabled": true,
            "tls": true,
            "tls-fingerprint": null,
            "daemon": false,
            "socks5": null,
            "self-select": null,
            "submit-to-origin": false
        }
    ],
    "print-time": 60,
    "health-print-time": 60,
    "dmi": true,
    "retries": 5,
    "retry-pause": 5,
    "syslog": false,
    "tls": {
        "enabled": false,
        "protocols": null,
        "cert": null,
        "cert_key": null,
        "ciphers": null,
        "ciphersuites": null,
        "dhparam": null
    },
    "dns": {
        "ipv6": false,
        "ttl": 30
    },
    "user-agent": null,
    "verbose": 0,
    "watch": true
}
```

बदलें `YOUR_MONERO_WALLET_ADDRESS` अपने वास्तविक वॉलेट पते के साथ।

### कॉन्फ़िग फ़ाइल के साथ चलाएं

```bash
docker run -d \\
  --name xmrig \\
  --restart unless-stopped \\
  --privileged \\
  -v $(pwd)/config.json:/etc/xmrig/config.json \\
  xmrig-miner \\
  --config=/etc/xmrig/config.json
```

***

## चरण 4: Huge Pages सक्षम करें (प्रदर्शन बढ़ोतरी)

RandomX को 1GB huge pages से काफ़ी लाभ होता है। होस्ट पर सक्षम करें:

```bash
# huge pages सक्षम करें (Clore.ai सर्वर पर root के रूप में चलाएँ)
echo 1 > /proc/sys/vm/nr_hugepages

# 1GB huge pages के लिए (यदि CPU द्वारा समर्थित हो)
mkdir -p /mnt/hugepages-1g
mount -t hugetlbfs -o pagesize=1G none /mnt/hugepages-1g
echo 4 > /proc/sys/vm/nr_hugepages

# इसे स्थायी बनाएं
echo "vm.nr_hugepages = 128" >> /etc/sysctl.conf
sysctl -p
```

{% hint style="info" %}
**प्रदर्शन प्रभाव**: huge pages कुछ CPUs पर Monero हैशरेट को 20-50% तक बढ़ा सकती हैं। यदि आपके पास होस्ट सिस्टम तक पहुंच है, तो इन्हें सक्षम करना सार्थक है।
{% endhint %}

***

## चरण 5: माइनिंग मॉनिटर करें

### कंटेनर स्थिति जांचें

```bash
# रीयल-टाइम लॉग देखें
docker logs xmrig -f

# API के माध्यम से आँकड़े जांचें
curl http://localhost:9090/2/summary | python3 -m json.tool
```

### नमूना लॉग आउटपुट

```
[2024-03-01 10:15:23.456]  माइनर    गति 10s/60s/15m 31.2k 31.4k 31.1k H/s अधिकतम 32.1k H/s
[2024-03-01 10:15:30.123]  नेटवर्क      स्वीकृत (1/0) diff 200001 (123 ms)
[2024-03-01 10:16:00.789]  माइनर    गति 10s/60s/15m 31.5k 31.3k 31.2k H/s अधिकतम 32.1k H/s
```

### देखने योग्य प्रमुख मेट्रिक्स

| मेट्रिक       | इसका क्या अर्थ है                       |
| ------------- | --------------------------------------- |
| H/s (हैशरेट)  | माइनिंग गति — अधिक बेहतर                |
| स्वीकृत शेयर  | पूल को जमा किया गया मान्य कार्य         |
| अस्वीकृत शेयर | अमान्य कार्य — लगभग 0 के पास होना चाहिए |
| लेटेंसी       | पूल कनेक्शन गति                         |

### पूल डैशबोर्ड

अपने पूल की वेबसाइट पर अपनी प्रगति जांचें:

* **SupportXMR**: `https://supportxmr.com/#/dashboard?wallet=YOUR_ADDRESS`
* **MoneroOcean**: `https://moneroocean.stream/#/dashboard?wallet=YOUR_ADDRESS`
* **2Miners**: `https://xmr.2miners.com/account/YOUR_ADDRESS`

***

## लोकप्रिय माइनिंग पूल

### Monero (XMR) पूल

| पूल         | URL                         | शुल्क | न्यूनतम भुगतान |
| ----------- | --------------------------- | ----- | -------------- |
| SupportXMR  | pool.supportxmr.com:443     | 0.6%  | 0.1 XMR        |
| MoneroOcean | gulf.moneroocean.stream:443 | 0%    | 0.003 XMR      |
| XMRig पूल   | pool.xmrig.com:443          | 1%    | 0.01 XMR       |
| MineXMR     | pool.minexmr.com:4444       | 1%    | 0.004 XMR      |

### GPU-माइन योग्य कॉइन

| कॉइन                   | एल्गोरिद्म | पूल उदाहरण           |
| ---------------------- | ---------- | -------------------- |
| Ravencoin (RVN)        | KawPow     | rvn.2miners.com:6060 |
| Ergo (ERG)             | Autolykos2 | erg.2miners.com:8888 |
| Conflux (CFX)          | Octopus    | cfx.2miners.com:4040 |
| Ethereum Classic (ETC) | Etchash    | etc.2miners.com:1010 |

{% hint style="info" %}
**MoneroOcean विशेष है**: यह किसी भी समय आपके माइनर को सबसे लाभदायक एल्गोरिद्म पर स्वचालित रूप से बदल देता है, जबकि भुगतान फिर भी XMR में होता है। रिटर्न अधिकतम करने के लिए बहुत अच्छा है।
{% endhint %}

***

## MoneroOcean: स्वचालित-लाभ स्विचिंग

MoneroOcean स्वचालित रूप से सबसे लाभदायक एल्गोरिद्म माइन करता है:

```bash
docker run -d \\
  --name xmrig-mo \\
  --restart unless-stopped \\
  --privileged \\
  xmrig-miner \\
  --algo=rx/0 \\
  -o gulf.moneroocean.stream:443 \\
  -u YOUR_MONERO_WALLET \\
  -p "YOUR_WORKER:PERFORMANCE_FEE" \\
  --tls \\
  --cpu-max-threads-hint=95
```

***

## अनुकूलन सुझाव

### CPU अनुकूलन

```bash
# सभी CPU थ्रेड्स का उपयोग करें
--cpu-max-threads-hint=100

# CPU प्राथमिकता सेट करें (0=सबसे कम, 5=सबसे अधिक)
--cpu-priority=3

# yield अक्षम करें (CPU को अन्य प्रक्रियाओं के साथ साझा न करें)
--no-yield

# तेज़ RandomX के लिए AVX2 सक्षम करें
# (यदि CPU इसे सपोर्ट करता है तो स्वचालित)
```

### GPU अनुकूलन (CUDA)

```json
"cuda": {
    "enabled": true,
    "loader": null,
    "nvml": true,
    "devices": [
        {
            "index": 0,
            "threads": 512,
            "blocks": 0,
            "bfactor": 0,
            "bsleep": 0,
            "affinity": -1
        }
    ]
}
```

### दोहरी माइनिंग (CPU + GPU)

```json
"cpu": {
    "enabled": true,
    "max-threads-hint": 100
},
"cuda": {
    "enabled": true,
    "nvml": true
}
```

***

## सुरक्षा संबंधी विचार

{% hint style="warning" %}
**माइनिंग सुरक्षा चेकलिस्ट:**

* यदि संभव हो तो माइनर को कभी भी root के रूप में न चलाएँ
* XMRig API पोर्ट (9090) को सार्वजनिक रूप से एक्सपोज़ न करें
* पूल्स से TLS कनेक्शन का उपयोग करें (`--tls` फ़्लैग)
* कमज़ोरियों को पैच करने के लिए XMRig को अपडेट रखें
* असामान्य CPU/GPU उपयोग में उछालों की निगरानी करें
  {% endhint %}

### API एंडपॉइंट सुरक्षित करें

```json
"api": {
    "port": 9090,
    "access-token": "आपका-गुप्त-टोकन-यहाँ",
    "restricted": true
}
```

```bash
# टोकन के साथ एक्सेस करें
curl -H "Authorization: Bearer आपका-गुप्त-टोकन-यहाँ" \
     http://localhost:9090/2/summary
```

***

## स्वचालित लाभ निगरानी स्क्रिप्ट

```bash
#!/bin/bash
# monitor-mining.sh

WALLET="आपका_वॉलेट_पता"
RENTAL_COST_PER_HOUR=0.50  # आपका Clore.ai लागत USD में

while true; do
  # वर्तमान हैशरेट प्राप्त करें
  HASHRATE=$(curl -s http://localhost:9090/2/summary | \
             python3 -c "import sys,json; d=json.load(sys.stdin); print(d['hashrate']['total'][0])")
  
  echo "$(date): हैशरेट: ${HASHRATE} H/s"
  echo "$(date): प्रति घंटा लागत: \$${RENTAL_COST_PER_HOUR}"
  
  # स्वीकृत शेयरों की जाँच करें
  ACCEPTED=$(curl -s http://localhost:9090/2/summary | \
             python3 -c "import sys,json; d=json.load(sys.stdin); print(d['results']['shares_good'])")
  echo "$(date): स्वीकृत शेयर: ${ACCEPTED}"
  
  sleep 300  # हर 5 मिनट में जाँच करें
done
```

***

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

### कम हैशरेट

```bash
# कंटेनर में CPU आवंटन की जाँच करें
docker exec xmrig cat /proc/cpuinfo | grep processor | wc -l

# सुनिश्चित करें कि huge pages सक्षम हैं
cat /proc/sys/vm/nr_hugepages

# थर्मल थ्रॉटलिंग की जाँच करें
watch -n1 "sensors 2>/dev/null | grep temp || cat /sys/class/thermal/thermal_zone*/temp"
```

### कनेक्शन समस्याएँ

```bash
# पूल कनेक्टिविटी का परीक्षण करें
curl -k telnet://pool.supportxmr.com:443

# यदि ब्लॉक हो तो वैकल्पिक पूल का उपयोग करें
# प्रयास करें: xmr.pool.minergate.com:443
```

### CUDA त्रुटियाँ

```bash
# कंटेनर में GPU एक्सेस की पुष्टि करें
docker exec xmrig-gpu nvidia-smi

# यदि अनुपस्थित हो, तो docker run में --gpus all जोड़ें
docker stop xmrig-gpu
docker rm xmrig-gpu
# --gpus all के साथ फिर से चलाएँ
```

### कंटेनर बार-बार रीस्टार्ट हो रहा है

```bash
# एग्ज़िट कोड जाँचें
docker inspect xmrig --format='{{.State.ExitCode}}'

# विस्तृत लॉग देखें
docker logs xmrig --since 5m

# सामान्य कारण:
# - अमान्य वॉलेट पता
# - पूल कनेक्शन विफल हुआ
# - कॉन्फ़िग फ़ाइल में सिंटैक्स त्रुटि
```

***

## कानूनी और नैतिक नोट्स

{% hint style="info" %}
**महत्वपूर्ण बातें:**

1. **Clore.ai की सेवा शर्तें जाँचें**: सुनिश्चित करें कि आपके किराए के सर्वरों पर माइनिंग की अनुमति है
2. **कर अनुपालन**: आपकी jurisdiction में माइन की गई क्रिप्टोकरेंसी करयोग्य आय हो सकती है
3. **लाभप्रदता**: क्लाउड माइनिंग अक्सर लाभदायक नहीं होती — पहले अपनी गणना करें
4. **नेटवर्क प्रभाव**: माइनिंग ब्लॉकचेन सुरक्षा में योगदान देती है (सकारात्मक योगदान)
   {% endhint %}

***

## त्वरित संदर्भ

### कमांड-लाइन फ़्लैग

| फ़्लैग                     | विवरण                           |
| -------------------------- | ------------------------------- |
| `-o URL`                   | पूल पता                         |
| `-u ADDRESS`               | वॉलेट पता                       |
| `-p WORKER`                | वर्कर नाम                       |
| `-a ALGO`                  | एल्गोरिथ्म (Monero के लिए rx/0) |
| `--tls`                    | TLS एन्क्रिप्शन सक्षम करें      |
| `-k`                       | कीप-अलाइव कनेक्शन               |
| `--cpu-max-threads-hint=N` | CPU थ्रेड्स का N% उपयोग करें    |
| `--donate-level=0`         | डेवलपर दान अक्षम करें           |

### एल्गोरिथ्म संदर्भ

| एल्गोरिद्म | कॉइन            | सर्वश्रेष्ठ हार्डवेयर |
| ---------- | --------------- | --------------------- |
| rx/0       | मोनेरो (XMR)    | CPU (RandomX)         |
| kawpow     | Ravencoin (RVN) | GPU                   |
| autolykos2 | Ergo (ERG)      | GPU                   |
| octopus    | Conflux (CFX)   | GPU                   |
| etchash    | ETC             | GPU                   |

***

## उपयोगी लिंक

* [XMRig GitHub](https://github.com/xmrig/xmrig)
* [XMRig प्रलेखन](https://xmrig.com/docs)
* [WhatToMine कैलकुलेटर](https://whattomine.com)
* [MoneroOcean पूल](https://moneroocean.stream)
* [SupportXMR पूल](https://supportxmr.com)
* [Clore.ai मार्केटप्लेस](https://clore.ai)

***

## सारांश

| चरण | क्रिया                                                      |
| --- | ----------------------------------------------------------- |
| 1   | सबसे पहले लाभप्रदता की गणना करें                            |
| 2   | getmonero.org पर Monero वॉलेट बनाएं                         |
| 3   | किसी माइनिंग पूल पर पंजीकरण करें                            |
| 4   | सर्वर किराए पर लें (XMR के लिए CPU कोर, अन्य के लिए GPU)    |
| 5   | XMRig Docker इमेज बनाएं                                     |
| 6   | config.json को वॉलेट और पूल के साथ कॉन्फ़िगर करें           |
| 7   | 20-50% हैशरेट वृद्धि के लिए huge pages सक्षम करें           |
| 8   | माइनिंग शुरू करें और पूल डैशबोर्ड के माध्यम से निगरानी करें |

Clore.ai पर XMRig आपको मांग पर उच्च-प्रदर्शन माइनिंग हार्डवेयर तक पहुँच देता है। इसका रणनीतिक रूप से उपयोग करें — जब कीमतें ऊँची हों और किराया कम हो तब माइन करें। हमेशा पहले गणना करें। ⛏️

***

## Clore.ai GPU अनुशंसाएँ

| उपयोग-प्रकरण           | अनुशंसित GPU    | Clore.ai पर अनुमानित लागत |
| ---------------------- | --------------- | ------------------------- |
| प्रारंभिक-स्तर माइनिंग | RTX 3080 (10GB) | $0.05–0.19/gpu/hr         |
| इष्टतम माइनिंग         | RTX 3090 (24GB) | $0.07–0.21/gpu/hr         |
| उच्च-प्रदर्शन माइनिंग  | RTX 4090 (24GB) | $0.14–0.42/gpu/hr         |

> 💡 इस गाइड के सभी उदाहरण [Clore.ai](https://clore.ai/marketplace) GPU servers पर तैनात किए जा सकते हैं। उपलब्ध GPUs ब्राउज़ करें और घंटे के हिसाब से किराए पर लें — कोई प्रतिबद्धता नहीं, पूर्ण root access.


---

# 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/crypto-and-mining/xmrig.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.