> 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/language-models/ollama.md).

# Ollama

CLORE.AI GPU पर LLMs को स्थानीय रूप से चलाने का सबसे आसान तरीका।

{% hint style="info" %}
**वर्तमान संस्करण: v0.6+** — यह गाइड Ollama v0.6 और उसके बाद के संस्करणों को कवर करती है। प्रमुख नई सुविधाओं में संरचित आउटपुट (JSON schema enforcement), OpenAI-संगत embeddings endpoint (`/api/embed`), और concurrent model loading (स्वैप किए बिना एक साथ कई मॉडल चलाना) शामिल हैं। विवरण के लिए देखें [v0.6+ में नया](#new-in-v06) ।
{% endhint %}

{% hint style="success" %}
सभी उदाहरण उन GPU सर्वरों पर चलाए जा सकते हैं जो इनके माध्यम से किराए पर लिए गए हों [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## सर्वर आवश्यकताएँ

| पैरामीटर      | न्यूनतम    | अनुशंसित |
| ------------- | ---------- | -------- |
| RAM           | 8GB        | 16GB+    |
| VRAM          | 6GB        | 8GB+     |
| नेटवर्क       | 100Mbps    | 500Mbps+ |
| स्टार्टअप समय | \~30 सेकंड | -        |

{% hint style="info" %}
Ollama हल्का है और अधिकांश GPU सर्वरों पर काम करता है। बड़े मॉडलों (13B+) के लिए, 16GB+ RAM और 12GB+ VRAM वाले सर्वर चुनें।
{% endhint %}

## Ollama क्यों?

* **एक-कमांड सेटअप** - Python नहीं, कोई निर्भरता नहीं
* **मॉडल लाइब्रेरी** - मॉडलों को डाउनलोड करें `ollama pull`
* **OpenAI-संगत API** - सीधे बदले जाने योग्य विकल्प
* **GPU एक्सेलेरेशन** - स्वचालित CUDA पहचान
* **मल्टी-मॉडल** - एक साथ कई मॉडल चलाएँ (v0.6+)

## CLORE.AI पर त्वरित डिप्लॉय

**Docker इमेज:**

```
ollama/ollama
```

**पोर्ट्स:**

```
22/tcp
11434/http
```

**कमांड:**

```bash
ollama serve
```

### सत्यापित करें कि यह काम कर रहा है

डिप्लॉयमेंट के बाद, अपना खोजें `http_pub` URL **मेरे ऑर्डर्स** में और परीक्षण करें:

```bash
# अपने वास्तविक http_pub URL से बदलें
curl https://your-http-pub.clorecloud.net/

# अपेक्षित उत्तर: "Ollama is running"
```

{% hint style="warning" %}
यदि आपको HTTP 502 मिलता है, तो 30-60 सेकंड प्रतीक्षा करें - सेवा अभी भी शुरू हो रही है।
{% endhint %}

## अपनी सेवा तक पहुँचना

जब CLORE.AI पर डिप्लॉय किया गया हो, तो अपने Ollama इंस्टेंस तक पहुँचें इस के माध्यम से `http_pub` URL:

```bash
# अपना http_pub My Orders में ढूँढें, फिर:
curl https://your-http-pub.clorecloud.net/api/tags

# API कॉल्स के लिए, अपना http_pub URL उपयोग करें:
curl https://your-http-pub.clorecloud.net/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Hello!"}],
  "stream": false
}'
```

{% hint style="info" %}
सभी `localhost:11434` नीचे दिए गए उदाहरण SSH के माध्यम से कनेक्ट होने पर काम करते हैं। बाहरी पहुँच के लिए, इसे अपने से बदलें `https://your-http-pub.clorecloud.net/` URL.
{% endhint %}

## इंस्टॉलेशन

### Docker का उपयोग करके (अनुशंसित)

```bash
docker run -d --gpus all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama
```

### मैन्युअल इंस्टॉलेशन

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

यह एकल कमांड Ollama का नवीनतम संस्करण इंस्टॉल करती है, systemd service सेट करती है, और GPU पहचान को स्वचालित रूप से कॉन्फ़िगर करती है। Ubuntu, Debian, Fedora, और अधिकांश आधुनिक Linux वितरणों पर काम करती है।

## मॉडल चलाना

### Pull और Run

```bash
# मॉडल pull करें
ollama pull llama3.2

# इंटरैक्टिव चैट चलाएँ
ollama run llama3.2

# प्रॉम्प्ट के साथ चलाएँ
ollama run llama3.2 "Explain quantum computing"
```

### लोकप्रिय मॉडल

| मॉडल                | आकार    | उपयोग का मामला          |
| ------------------- | ------- | ----------------------- |
| `llama3.2`          | 3B      | तेज़, सामान्य-उद्देश्य  |
| `llama3.1`          | 8B      | बेहतर गुणवत्ता          |
| `llama3.1:70b`      | 70B     | सर्वोत्तम गुणवत्ता      |
| `mistral`           | 7B      | तेज़, अच्छी गुणवत्ता    |
| `mixtral`           | 47B     | MoE, उच्च गुणवत्ता      |
| `codellama`         | 7-34B   | कोड जनरेशन              |
| `deepseek-coder-v2` | 16B     | कोड के लिए सर्वोत्तम    |
| `deepseek-r1`       | 7B-671B | रीज़निंग मॉडल           |
| `deepseek-r1:32b`   | 32B     | संतुलित रीज़निंग        |
| `qwen2.5`           | 7B      | बहुभाषी                 |
| `qwen2.5:72b`       | 72B     | सर्वोत्तम Qwen गुणवत्ता |
| `phi4`              | 14B     | Microsoft का नवीनतम     |
| `gemma2`            | 9B      | Google का मॉडल          |

### मॉडल वैरिएंट्स

```bash
# क्वांटाइजेशन वैरिएंट्स
ollama pull llama3.1:8b-instruct-q4_K_M   # 4-bit (छोटा, तेज़)
ollama pull llama3.1:8b-instruct-q8_0     # 8-bit (बेहतर गुणवत्ता)
ollama pull llama3.1:8b-instruct-fp16     # पूर्ण परिशुद्धता

# आकार वैरिएंट्स
ollama pull llama3.1:8b    # 8 अरब पैरामीटर
ollama pull llama3.1:70b   # 70 अरब पैरामीटर

# नए मॉडल (v0.6+ युग)
ollama pull deepseek-r1:7b      # रीज़निंग, बजट
ollama pull deepseek-r1:14b     # रीज़निंग, कुशल
ollama pull deepseek-r1:32b     # रीज़निंग, संतुलित
ollama pull deepseek-r1:70b     # रीज़निंग, उच्च गुणवत्ता
ollama pull qwen2.5:72b         # सबसे बड़ा Qwen, शीर्ष गुणवत्ता
ollama pull phi4                # Microsoft Phi-4 14B
```

## v0.6+ में नया

Ollama v0.6 ने उत्पादन वर्कलोड के लिए कई प्रमुख सुविधाएँ पेश कीं:

### संरचित आउटपुट (JSON Schema)

मॉडल प्रतिक्रियाओं को एक विशिष्ट JSON schema से मिलाने के लिए बाध्य करें। विश्वसनीय, parseable आउटपुट की आवश्यकता वाले एप्लिकेशन बनाने के लिए उपयोगी:

```bash
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Tell me about Canada."}],
  "format": {
    "type": "object",
    "properties": {
      "name": {"type": "string"},
      "capital": {"type": "string"},
      "population": {"type": "integer"},
      "languages": {
        "type": "array",
        "items": {"type": "string"}
      }
    },
    "required": ["name", "capital", "population", "languages"]
  },
  "stream": false
}'
```

संरचित आउटपुट के साथ Python उदाहरण:

```python
from openai import OpenAI
import json

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "List 3 programming languages with their main use cases"}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "languages",
            "schema": {
                "type": "object",
                "properties": {
                    "languages": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name": {"type": "string"},
                                "use_case": {"type": "string"},
                                "popularity_rank": {"type": "integer"}
                            }
                        }
                    }
                }
            }
        }
    }
)

data = json.loads(response.choices[0].message.content)
print(data)
```

### OpenAI-संगत Embeddings Endpoint (`/api/embed`)

v0.6+ में नया: `/api/embed` endpoint पूरी तरह OpenAI-संगत है और batched inputs का समर्थन करता है:

```bash
# एकल टेक्स्ट embedding
curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": "Hello world"
}'

# बैच embeddings (v0.6 में नया)
curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": ["First document", "Second document", "Third document"]
}'
```

OpenAI client सीधे इसके साथ काम करता है `/v1/embeddings`:

```python
from openai import OpenAI
import numpy as np

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

# पहले embedding model pull करें: ollama pull nomic-embed-text
response = client.embeddings.create(
    model="nomic-embed-text",
    input=["Hello world", "Goodbye world"]
)

emb1 = np.array(response.data[0].embedding)
emb2 = np.array(response.data[1].embedding)

# Cosine similarity
similarity = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print(f"Similarity: {similarity:.4f}")
```

लोकप्रिय embedding मॉडल:

```bash
ollama pull nomic-embed-text      # 137M, तेज़, अच्छी गुणवत्ता
ollama pull mxbai-embed-large     # 335M, उच्च गुणवत्ता
ollama pull all-minilm            # 23M, सबसे तेज़
```

### समवर्ती मॉडल लोडिंग

v0.6 से पहले, Ollama एक मॉडल को अनलोड करके दूसरा लोड करता था। V0.6+ उपलब्ध VRAM तक सीमित होकर एक साथ कई मॉडल चलाने का समर्थन करता है:

```bash
# एक ही समय में दो मॉडल लोड करें
ollama run llama3.2 &
ollama run deepseek-r1:7b &

# देखें क्या चल रहा है
curl http://localhost:11434/api/ps
```

समवर्तीता कॉन्फ़िगर करें:

```bash
# एक साथ अधिकतम 4 मॉडल लोड करने की अनुमति दें
OLLAMA_MAX_LOADED_MODELS=4 ollama serve

# प्रत्येक runner अलग प्रक्रिया में (बेहतर isolation)
OLLAMA_NUM_PARALLEL=2 ollama serve
```

यह विशेष रूप से उपयोगी है:

* विभिन्न मॉडलों का A/B परीक्षण
* विभिन्न कार्यों के लिए विशेष मॉडल (कोडिंग + चैट)
* बार-बार उपयोग होने वाले मॉडलों को VRAM में warm रखना

## API उपयोग

### चैट पूर्णता

```bash
# http_pub के माध्यम से (बाहरी पहुँच):
curl https://your-http-pub.clorecloud.net/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Hello!"}],
  "stream": false
}'

# SSH tunnel के माध्यम से (localhost):
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Hello!"}],
  "stream": false
}'
```

{% hint style="info" %}
जोड़ें `"stream": false` ताकि streaming के बजाय पूरी प्रतिक्रिया एक बार में मिले।
{% endhint %}

### OpenAI-संगत Endpoint

```python
from openai import OpenAI

# बाहरी पहुँच के लिए, अपना http_pub URL उपयोग करें:
client = OpenAI(
    base_url="https://your-http-pub.clorecloud.net/v1",
    api_key="ollama"  # कोई भी स्ट्रिंग काम करती है
)

# या SSH tunnel के माध्यम से:
# client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="llama3.2",
    messages=[
        {"role": "user", "content": "What is machine learning?"}
    ]
)

print(response.choices[0].message.content)
```

### स्ट्रीमिंग

```python
stream = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Write a poem"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")
```

### Embeddings

```bash
# लेगेसी endpoint (अभी भी काम करता है)
curl http://localhost:11434/api/embeddings -d '{
  "model": "nomic-embed-text",
  "prompt": "Hello world"
}'

# नया v0.6+ endpoint (batch समर्थन, OpenAI-संगत)
curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": ["Hello world", "Another text"]
}'
```

### टेक्स्ट जनरेशन (चैट नहीं)

```bash
curl https://your-http-pub.clorecloud.net/api/generate -d '{
  "model": "llama3.2",
  "prompt": "The meaning of life is",
  "stream": false
}'
```

## पूर्ण API संदर्भ

सभी endpoint दोनों के साथ काम करते हैं `http://localhost:11434` (SSH के माध्यम से) और `https://your-http-pub.clorecloud.net` (बाहरी).

### मॉडल प्रबंधन

| Endpoint       | Method | विवरण                                 |
| -------------- | ------ | ------------------------------------- |
| `/api/tags`    | GET    | सभी डाउनलोड किए गए मॉडल सूचीबद्ध करें |
| `/api/show`    | POST   | मॉडल विवरण प्राप्त करें               |
| `/api/pull`    | POST   | एक मॉडल डाउनलोड करें                  |
| `/api/delete`  | DELETE | एक मॉडल हटाएँ                         |
| `/api/ps`      | GET    | वर्तमान में चल रहे मॉडल सूचीबद्ध करें |
| `/api/version` | GET    | Ollama संस्करण प्राप्त करें           |

#### मॉडल सूची

```bash
curl https://your-http-pub.clorecloud.net/api/tags
```

प्रतिक्रिया:

```json
{
  "models": [
    {"name": "llama3.2:latest", "size": 2019393189, "digest": "...", "modified_at": "..."}
  ]
}
```

#### मॉडल विवरण दिखाएँ

```bash
curl https://your-http-pub.clorecloud.net/api/show -d '{"name": "llama3.2"}'
```

#### API के माध्यम से मॉडल pull करें

```bash
curl https://your-http-pub.clorecloud.net/api/pull -d '{
  "name": "mistral:7b",
  "stream": false
}'
```

प्रतिक्रिया:

```json
{"status": "success"}
```

{% hint style="warning" %}
बड़े मॉडलों को डाउनलोड होने में कई मिनट लग सकते हैं। बहुत बड़े मॉडलों (30GB+) के लिए, SSH और CLI का उपयोग करने पर विचार करें: `ollama pull model-name`
{% endhint %}

#### मॉडल हटाएँ

```bash
curl -X DELETE https://your-http-pub.clorecloud.net/api/delete -d '{"name": "mistral:7b"}'
```

#### चल रहे मॉडल सूचीबद्ध करें

```bash
curl https://your-http-pub.clorecloud.net/api/ps
```

प्रतिक्रिया:

```json
{
  "models": [
    {"name": "llama3.2:latest", "size": 2019393189, "expires_at": "2025-01-25T12:00:00Z"}
  ]
}
```

#### संस्करण प्राप्त करें

```bash
curl https://your-http-pub.clorecloud.net/api/version
```

प्रतिक्रिया:

```json
{"version": "0.6.8"}
```

### Inference Endpoints

| Endpoint               | Method | विवरण                                            |
| ---------------------- | ------ | ------------------------------------------------ |
| `/api/generate`        | POST   | टेक्स्ट पूर्णता                                  |
| `/api/chat`            | POST   | चैट पूर्णता                                      |
| `/api/embeddings`      | POST   | Embeddings जनरेट करें (लेगेसी)                   |
| `/api/embed`           | POST   | Embeddings जनरेट करें v0.6+ (batch, OpenAI-संगत) |
| `/v1/chat/completions` | POST   | OpenAI-संगत चैट                                  |
| `/v1/embeddings`       | POST   | OpenAI-संगत embeddings                           |

### कस्टम मॉडल निर्माण

API के माध्यम से विशिष्ट system prompt के साथ कस्टम मॉडल बनाएँ:

```bash
curl https://your-http-pub.clorecloud.net/api/create -d '{
  "name": "my-assistant",
  "modelfile": "FROM llama3.2\nSYSTEM You are a helpful coding assistant."
}'
```

## GPU कॉन्फ़िगरेशन

### GPU उपयोग जाँचें

```bash
# कंटेनर या सर्वर में
nvidia-smi

# Ollama लॉग में GPU दिखाता है
ollama run llama3.2 --verbose
```

### मल्टी-GPU

Ollama स्वतः उपलब्ध GPUs का उपयोग करता है। विशिष्ट GPU के लिए:

```bash
CUDA_VISIBLE_DEVICES=0 ollama serve
```

### मेमोरी प्रबंधन

```bash
# GPU मेमोरी सीमा सेट करें
OLLAMA_GPU_MEMORY=8GiB ollama serve

# मॉडल को लोडेड रखें
OLLAMA_KEEP_ALIVE=24h ollama serve

# समवर्ती मॉडल की अनुमति दें (v0.6+)
OLLAMA_MAX_LOADED_MODELS=3 ollama serve
```

## कस्टम मॉडल (Modelfile)

system prompts के साथ कस्टम मॉडल बनाएँ:

```dockerfile
# Modelfile
FROM llama3.2

SYSTEM आप एक सहायक कोडिंग सहायक हैं। हमेशा कोड उदाहरण दें।

PARAMETER temperature 0.7
PARAMETER top_p 0.9
```

```bash
ollama create coding-assistant -f Modelfile
ollama run coding-assistant
```

## सेवा के रूप में चलाना

### Systemd

```ini
# /etc/systemd/system/ollama.service
[Unit]
Description=Ollama Service
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/ollama serve
Restart=always
Environment="OLLAMA_HOST=0.0.0.0"

[Install]
WantedBy=multi-user.target
```

```bash
systemctl enable ollama
systemctl start ollama
```

## प्रदर्शन सुझाव

1. **उपयुक्त quantization का उपयोग करें**
   * गति के लिए Q4\_K\_M
   * गुणवत्ता के लिए Q8\_0
   * अधिकतम गुणवत्ता के लिए fp16
2. **मॉडल को VRAM से मिलाएँ**
   * 8GB: 7B मॉडल (Q4)
   * 16GB: 13B मॉडल या 7B (Q8)
   * 24GB: 34B मॉडल (Q4)
   * 48GB+: 70B मॉडल
3. **मॉडल को लोडेड रखें**

   ```bash
   OLLAMA_KEEP_ALIVE=1h ollama serve
   ```
4. **तेज़ SSD प्रदर्शन सुधारता है**
   * मॉडल लोडिंग और KV cache को तेज़ storage से लाभ मिलता है
   * NVMe SSD वाले सर्वर 2-3x बेहतर प्रदर्शन प्राप्त कर सकते हैं

## बेंचमार्क

### जनरेशन गति (tokens/sec)

| मॉडल                 | RTX 3060 | RTX 3090 | RTX 4090 | A100 40GB |
| -------------------- | -------- | -------- | -------- | --------- |
| Llama 3.2 3B (Q4)    | 120      | 160      | 200      | 220       |
| Llama 3.1 8B (Q4)    | 60       | 100      | 130      | 150       |
| Llama 3.1 8B (Q8)    | 45       | 80       | 110      | 130       |
| Mistral 7B (Q4)      | 70       | 110      | 140      | 160       |
| Mixtral 8x7B (Q4)    | -        | 35       | 55       | 75        |
| Llama 3.1 70B (Q4)   | -        | -        | 18       | 35        |
| DeepSeek-R1 7B (Q4)  | 65       | 105      | 135      | 155       |
| DeepSeek-R1 32B (Q4) | -        | -        | 22       | 42        |
| Qwen2.5 72B (Q4)     | -        | -        | 15       | 30        |
| Phi-4 14B (Q4)       | -        | 50       | 75       | 90        |

*बेंचमार्क जनवरी 2026 में अपडेट किए गए। वास्तविक गति सर्वर कॉन्फ़िगरेशन के आधार पर भिन्न हो सकती है।*

### पहले token तक का समय (ms)

| मॉडल | RTX 3090 | RTX 4090 | A100 |
| ---- | -------- | -------- | ---- |
| 3B   | 50       | 35       | 25   |
| 7-8B | 120      | 80       | 60   |
| 13B  | 250      | 150      | 100  |
| 34B  | 600      | 350      | 200  |
| 70B  | -        | 1200     | 500  |

### Context Length बनाम VRAM (Q4)

| मॉडल | 2K ctx | 4K ctx | 8K ctx | 16K ctx |
| ---- | ------ | ------ | ------ | ------- |
| 7B   | 5GB    | 6GB    | 8GB    | 12GB    |
| 13B  | 8GB    | 10GB   | 14GB   | 22GB    |
| 34B  | 20GB   | 24GB   | 32GB   | 48GB    |
| 70B  | 40GB   | 48GB   | 64GB   | 96GB    |

## GPU आवश्यकताएँ

| मॉडल | Q4 VRAM | Q8 VRAM |
| ---- | ------- | ------- |
| 3B   | 3GB     | 5GB     |
| 7-8B | 5GB     | 9GB     |
| 13B  | 8GB     | 15GB    |
| 34B  | 20GB    | 38GB    |
| 70B  | 40GB    | 75GB    |

## लागत का अनुमान

CLORE.AI मार्केटप्लेस की सामान्य दरें:

| GPU                                                                                                | VRAM | मूल्य/दिन  | इसके लिए उपयुक्त |
| -------------------------------------------------------------------------------------------------- | ---- | ---------- | ---------------- |
| [RTX 3090](https://clore.ai/rent-3090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=ollama) | 24GB | $0.30–1.00 | 13B-34B मॉडल     |
| [RTX 4090](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=ollama) | 24GB | $0.50–2.00 | 34B मॉडल, तेज़   |
| RTX 4070                                                                                           | 12GB | $0.20–0.50 | 7B मॉडल          |
| A100 80GB                                                                                          | 80GB | $1.50–3.00 | 70B मॉडल         |

*कीमतें USD/दिन में हैं। दरें प्रदाता के अनुसार बदलती हैं — वर्तमान दरों के लिए देखें* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *।*

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

### मॉडल लोड नहीं हो रहा है

```bash
# उपलब्ध मेमोरी जाँचें
nvidia-smi

# छोटी क्वांटाइज़ेशन आज़माएँ
ollama pull llama3.1:8b-q4_0
```

### धीमी जनरेशन

```bash
# जाँचें कि GPU का उपयोग हो रहा है या नहीं
ollama run llama3.2 --verbose

# सुनिश्चित करें कि CUDA उपलब्ध है
nvidia-smi
```

### कनेक्शन अस्वीकृत

```bash
# सुनिश्चित करें कि सर्वर चल रहा है
ollama serve

# जाँचें कि सभी इंटरफेस से बाइंड हो रहा है या नहीं
OLLAMA_HOST=0.0.0.0 ollama serve
```

### http\_pub URL पर HTTP 502

इसका मतलब है कि सेवा अभी भी शुरू हो रही है। 30-60 सेकंड प्रतीक्षा करें और फिर पुनः प्रयास करें:

```bash
# जाँचें कि सेवा तैयार है या नहीं
curl https://your-http-pub.clorecloud.net/

# अपेक्षित: "Ollama is running"
# यदि 502: प्रतीक्षा करें और पुनः प्रयास करें
```

## अगले चरण

* [Open WebUI](/guides/guides_v2-hi/language-models/open-webui.md) - Ollama के लिए सुंदर चैट इंटरफ़ेस
* [vLLM](/guides/guides_v2-hi/language-models/vllm.md) - उच्च-थ्रूपुट प्रोडक्शन सर्विंग
* [DeepSeek-R1](/guides/guides_v2-hi/language-models/deepseek-r1.md) - तर्क मॉडल
* [DeepSeek-V3](/guides/guides_v2-hi/language-models/deepseek-v3.md) - सर्वश्रेष्ठ सामान्य मॉडल
* [Qwen2.5](/guides/guides_v2-hi/language-models/qwen25.md) - बहुभाषी विकल्प
* [Text Generation WebUI](/guides/guides_v2-hi/language-models/text-generation-webui.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/language-models/ollama.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.