> 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/ai/gpt4all.md).

# GPT4All लोकल LLM

Clore.ai पर GPT4All डिप्लॉय करें — Docker का उपयोग करके OpenAI-संगत API सर्वर के साथ privacy-first लोकल LLMs चलाएँ, अधिकतम प्रदर्शन के लिए वैकल्पिक CUDA एक्सेलेरेशन वाले GGUF मॉडल्स को सपोर्ट करते हुए।

## अवलोकन

[GPT4All](https://github.com/nomic-ai/gpt4all) Nomic AI द्वारा यह सबसे लोकप्रिय ओपन-सोर्स लोकल LLM प्रोजेक्ट्स में से एक है, जिसके पास **72,000 GitHub स्टार्स**। यह आपको बड़े भाषा मॉडल पूरी तरह ऑफ़लाइन अपने हार्डवेयर पर चलाने देता है — इंटरनेट कनेक्शन की आवश्यकता नहीं, और कोई डेटा तीसरे पक्षों को नहीं भेजा जाता।

GPT4All अपनी सुघड़ डेस्कटॉप एप्लिकेशन के लिए सबसे ज्यादा जाना जाता है, लेकिन इसमें एक **Python लाइब्रेरी** (`gpt4all` पैकेज) और एक अंतर्निहित **OpenAI-संगत API सर्वर** जो पोर्ट पर चल रहा है **4891**। Clore.ai पर, आप GPT4All को किराए की GPU पर Docker कंटेनर में डिप्लॉय कर सकते हैं, इसे HTTP के माध्यम से सर्व कर सकते हैं, और किसी भी OpenAI-संगत क्लाइंट को इससे जोड़ सकते हैं।

> **Docker नोट:** GPT4All सर्वर घटक के लिए कोई आधिकारिक Docker इमेज प्रकाशित नहीं करता। यह गाइड `gpt4all` Python पैकेज के साथ एक कस्टम Docker सेटअप का उपयोग करती है। एक अधिक प्रोडक्शन-रेडी Docker विकल्प के लिए जो **वही GGUF मॉडल फ़ाइलें**, देखें [LocalAI वैकल्पिक अनुभाग](#alternative-localai-docker-image) — LocalAI Docker-first है और वही मॉडल फ़ॉर्मेट सपोर्ट करता है।

**मुख्य विशेषताएँ:**

* 🔒 100% ऑफ़लाइन — सभी इन्फ़रेंस स्थानीय रूप से चलते हैं
* 🤖 OpenAI-संगत REST API (पोर्ट 4891)
* 📚 LocalDocs — अपने दस्तावेज़ों पर RAG
* 🧩 सभी लोकप्रिय GGUF मॉडल फ़ॉर्मेट्स को सपोर्ट करता है
* 🐍 पूर्ण Python API के साथ `pip install gpt4all`
* 💬 सुंदर डेस्कटॉप UI (सर्वर के लिए प्रासंगिक नहीं, लेकिन स्थानीय परीक्षण के लिए अच्छा)

***

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

### हार्डवेयर आवश्यकताएँ

| स्तर                | GPU           | VRAM  | RAM   | स्टोरेज    | Clore.ai मूल्य           |
| ------------------- | ------------- | ----- | ----- | ---------- | ------------------------ |
| **केवल CPU**        | कोई नहीं      | —     | 16 GB | 50 GB SSD  | \~$0.02/घंटा (CPU सर्वर) |
| **प्रवेश-स्तर GPU** | RTX 3060 12GB | 12 GB | 16 GB | 50 GB SSD  | $0.03–0.07/घंटा          |
| **अनुशंसित**        | RTX 3090      | 24 GB | 32 GB | 100 GB SSD | $0.07–0.21/hr            |
| **उच्च-स्तरीय**     | RTX 4090      | 24 GB | 64 GB | 200 GB SSD | $0.14–0.42/hr            |

> **ध्यान दें:** GPT4All GPU सपोर्ट पर्दे के पीछे llama.cpp के माध्यम से CUDA का उपयोग करता है। vLLM के विपरीत, इसे **नहीं** एक विशिष्ट CUDA compute capability की आवश्यकता होती है — RTX 10xx और नए आमतौर पर काम करते हैं।

### मॉडल VRAM आवश्यकताएँ (GGUF Q4\_K\_M)

| मॉडल                  | डिस्क पर आकार | VRAM    | न्यूनतम GPU |
| --------------------- | ------------- | ------- | ----------- |
| Phi-3 Mini 3.8B       | \~2.4 GB      | \~3 GB  | RTX 3060    |
| Mistral 7B Instruct   | \~4.1 GB      | \~5 GB  | RTX 3060    |
| Llama 3.1 8B Instruct | \~4.7 GB      | \~6 GB  | RTX 3060    |
| Llama 3 70B Instruct  | \~40 GB       | \~45 GB | A100 80GB   |
| Mixtral 8x7B          | \~26 GB       | \~30 GB | 2× RTX 3090 |

***

## त्वरित शुरुआत

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

1. में लॉग इन करें [clore.ai](https://clore.ai)
2. फ़िल्टर: **Docker सक्षम**, **GPU**: RTX 3090 (7B–13B मॉडल के लिए)
3. इमेज के साथ डिप्लॉय करें: `nvidia/cuda:12.8.1-runtime-ubuntu22.04`
4. पोर्ट खोलें: **4891** (GPT4All API), **22** (SSH)
5. कम से कम आवंटित करें **50 GB** डिस्क स्पेस

### चरण 2 — SSH के माध्यम से कनेक्ट करें

```bash
ssh -p <CLORE_SSH_PORT> root@<CLORE_SERVER_IP>

# GPU सत्यापित करें
nvidia-smi
# ड्राइवर संस्करण के साथ आपका GPU सूचीबद्ध होना चाहिए
```

### चरण 3 — GPT4All Docker इमेज बनाएं

चूंकि कोई आधिकारिक GPT4All Docker इमेज नहीं है, हम एक बनाएंगे:

```bash
mkdir -p /workspace/gpt4all-server && cd /workspace/gpt4all-server

cat > Dockerfile << 'EOF'
FROM nvidia/cuda:12.8.1-runtime-ubuntu22.04

ENV DEBIAN_FRONTEND=noninteractive
ENV PYTHONUNBUFFERED=1

# Python और सिस्टम निर्भरताएँ स्थापित करें
RUN apt-get update && apt-get install -y \\
    python3.11 \\
    python3.11-dev \\
    python3-pip \\
    curl \\
    wget \\
    git \\
    libgomp1 \\
    && rm -rf /var/lib/apt/lists/*

# python3.11 को डिफ़ॉल्ट बनाएं
RUN update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.11 1 \\
    && update-alternatives --install /usr/bin/python python python3.11 1

# CUDA सपोर्ट के साथ GPT4All स्थापित करें
RUN pip install --upgrade pip && \\
    pip install gpt4all>=2.8.0 fastapi uvicorn aiofiles pydantic

# डायरेक्टरी बनाएं
RUN mkdir -p /models /workspace /app

WORKDIR /app

# सर्वर स्क्रिप्ट कॉपी करें (माउंट की जाएगी या इमेज में शामिल की जाएगी)
COPY server.py .

EXPOSE 4891

CMD ["python", "server.py"]
EOF
```

### चरण 4 — API सर्वर स्क्रिप्ट बनाएं

```bash
cat > /workspace/gpt4all-server/server.py << 'PYEOF'
#!/usr/bin/env python3
"""
GPT4All OpenAI-संगत API सर्वर
पोर्ट 4891 पर चलता है (GPT4All डिफ़ॉल्ट)
"""

import os
import time
import json
import asyncio
from typing import Optional, List, Dict, Any
from pathlib import Path

from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
import uvicorn
from gpt4all import GPT4All

# कॉन्फ़िगरेशन
MODEL_NAME = os.environ.get("MODEL_NAME", "Mistral 7B Instruct v0.1 Q4_0")
MODEL_PATH = os.environ.get("MODEL_PATH", "/models")
API_HOST = os.environ.get("API_HOST", "0.0.0.0")
API_PORT = int(os.environ.get("API_PORT", "4891"))
DEVICE = os.environ.get("DEVICE", "gpu")  # 'gpu', 'cpu', 'metal'
N_CTX = int(os.environ.get("N_CTX", "4096"))

app = FastAPI(title="GPT4All API Server", version="1.0.0")

# वैश्विक मॉडल इंस्टेंस
model = None

def load_model():
    global model
    print(f"मॉडल लोड हो रहा है: {MODEL_NAME}")
    print(f"मॉडल पथ: {MODEL_PATH}")
    print(f"डिवाइस: {DEVICE}")
    model = GPT4All(
        model_name=MODEL_NAME,
        model_path=MODEL_PATH,
        device=DEVICE,
        n_ctx=N_CTX,
        allow_download=True,  # यदि मौजूद न हो तो GPT4All हब से डाउनलोड करता है
        verbose=True
    )
    मॉडल सफलतापूर्वक लोड हो गया!

# --- Pydantic मॉडल्स ---

class Message(BaseModel):
    role: str
    content: str

class ChatCompletionRequest(BaseModel):
    model: str
    messages: List[Message]
    temperature: float = 0.7
    max_tokens: int = 512
    top_p: float = 0.95
    top_k: int = 40
    stream: bool = False

class CompletionRequest(BaseModel):
    model: str
    prompt: str
    temperature: float = 0.7
    max_tokens: int = 512
    stream: bool = False

# --- API रूट्स ---

@app.get("/health")
async def health():
    return {"status": "ok", "model": MODEL_NAME, "device": DEVICE}

@app.get("/v1/models")
async def list_models():
    return {
        "object": "list",
        "data": [{
            "id": MODEL_NAME,
            "object": "model",
            "created": int(time.time()),
            "owned_by": "gpt4all",
        }]
    }

@app.post("/v1/chat/completions")
async def chat_completions(request: ChatCompletionRequest):
    if model is None:
        raise HTTPException(status_code=503, detail="मॉडल लोड नहीं हुआ है")

    # संदेशों को एकल प्रॉम्प्ट में फ़ॉर्मैट करें
    prompt_parts = []
    for msg in request.messages:
        if msg.role == "system":
            prompt_parts.append(f"### सिस्टम:\n{msg.content}")
        elif msg.role == "user":
            prompt_parts.append(f"### मानव:\n{msg.content}")
        elif msg.role == "assistant":
            prompt_parts.append(f"### सहायक:\n{msg.content}")
    prompt_parts.append("### सहायक:")
    full_prompt = "\n\n".join(prompt_parts)

    with model.chat_session():
        response_text = model.generate(
            full_prompt,
            max_tokens=request.max_tokens,
            temp=request.temperature,
            top_p=request.top_p,
            top_k=request.top_k,
        )

    return {
        "id": f"chatcmpl-{int(time.time())}",
        "object": "chat.completion",
        "created": int(time.time()),
        "model": request.model,
        "choices": [{
            "index": 0,
            "message": {"role": "assistant", "content": response_text},
            "finish_reason": "stop"
        }],
        "usage": {
            "prompt_tokens": len(full_prompt.split()),
            "completion_tokens": len(response_text.split()),
            "total_tokens": len(full_prompt.split()) + len(response_text.split())
        }
    }

@app.post("/v1/completions")
async def completions(request: CompletionRequest):
    if model is None:
        raise HTTPException(status_code=503, detail="मॉडल लोड नहीं हुआ है")

    response_text = model.generate(
        request.prompt,
        max_tokens=request.max_tokens,
        temp=request.temperature,
    )

    return {
        "id": f"cmpl-{int(time.time())}",
        "object": "text_completion",
        "created": int(time.time()),
        "model": request.model,
        "choices": [{
            "text": response_text,
            "index": 0,
            "finish_reason": "stop"
        }]
    }

if __name__ == "__main__":
    load_model()
    uvicorn.run(app, host=API_HOST, port=API_PORT, log_level="info")
PYEOF
```

### चरण 5 — बिल्ड और रन करें

```bash
cd /workspace/gpt4all-server

# Docker इमेज बनाएं
docker build -t gpt4all-server:latest .

# पहले एक मॉडल डाउनलोड करें (वैकल्पिक — सर्वर इसे स्वचालित रूप से भी डाउनलोड कर सकता है)
mkdir -p /workspace/models
wget -O /workspace/models/mistral-7b-instruct-v0.1.Q4_0.gguf \\
  https://gpt4all.io/models/gguf/mistral-7b-instruct-v0.1.Q4_0.gguf

# GPU सपोर्ट के साथ चलाएं
docker run -d \\
  --name gpt4all-server \\
  --gpus all \\
  --restart unless-stopped \\
  -p 4891:4891 \\
  -v /workspace/models:/models \\
  -v /workspace/gpt4all-server/server.py:/app/server.py \\
  -e MODEL_NAME="mistral-7b-instruct-v0.1.Q4_0.gguf" \\
  -e MODEL_PATH="/models" \\
  -e DEVICE="gpu" \\
  -e N_CTX="4096" \\
  gpt4all-server:latest

# लॉग्स फ़ॉलो करें
docker logs -f gpt4all-server
```

### चरण 6 — API का परीक्षण करें

```bash
# हेल्थ चेक
curl http://localhost:4891/health

# मॉडल सूचीबद्ध करें
curl http://localhost:4891/v1/models

# चैट पूर्णता
curl http://localhost:4891/v1/chat/completions \\
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-7b-instruct-v0.1.Q4_0.gguf",
    "messages": [
      {"role": "user", "content": "फ्रांस की राजधानी क्या है?"}
    ],
    "temperature": 0.7,
    "max_tokens": 256
  }'
```

***

## विकल्प: LocalAI Docker इमेज

एक अधिक मजबूत, प्रोडक्शन-रेडी Docker डिप्लॉयमेंट के लिए जो **वही GGUF मॉडल** GPT4All की तरह, LocalAI अनुशंसित विकल्प है। इसमें आधिकारिक Docker इमेज, CUDA सपोर्ट है, और इसे सक्रिय रूप से मेंटेन किया जाता है:

```bash
# CUDA सपोर्ट के साथ LocalAI पुल करें
docker pull localai/localai:latest-aio-gpu-nvidia-cuda-12

# मॉडल्स डायरेक्टरी बनाएं और एक GGUF मॉडल डाउनलोड करें
mkdir -p /workspace/localai-models
wget -O /workspace/localai-models/mistral-7b.gguf \\
  https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.1-GGUF/resolve/main/mistral-7b-instruct-v0.1.Q4_K_M.gguf

# मॉडल कॉन्फ़िगरेशन बनाएं
cat > /workspace/localai-models/mistral-7b.yaml << 'EOF'
name: mistral-7b
parameters:
  model: mistral-7b.gguf
  temperature: 0.7
  top_p: 0.95
  top_k: 40
  max_tokens: 2048
context_size: 4096
f16: true
gpu_layers: 35
threads: 8
EOF

# LocalAI चलाएं
docker run -d \\
  --name localai \\
  --gpus all \\
  --restart unless-stopped \\
  -p 8080:8080 \
  -v /workspace/localai-models:/build/models \\
  -e DEBUG=true \\
  localai/localai:latest-aio-gpu-nvidia-cuda-12

# LocalAI का परीक्षण करें (वही OpenAI-संगत API)
curl http://localhost:8080/v1/chat/completions \\
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral-7b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'
```

***

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

### GPT4All सर्वर के लिए पर्यावरण चर

| वेरिएबल      | डिफ़ॉल्ट                 | विवरण                            |
| ------------ | ------------------------ | -------------------------------- |
| `MODEL_NAME` | `mistral-7b-instruct...` | मॉडल फ़ाइल नाम या GPT4All हब नाम |
| `MODEL_PATH` | `/models`                | मॉडल फ़ाइलें वाली डायरेक्टरी     |
| `DEVICE`     | `gpu`                    | `gpu`, `cpu`या `metal` (macOS)   |
| `N_CTX`      | `4096`                   | संदर्भ विंडो आकार (टोकन)         |
| `API_HOST`   | `0.0.0.0`                | बाइंड पता                        |
| `API_PORT`   | `4891`                   | API सर्वर के लिए पोर्ट           |

### Docker Compose सेटअप

```yaml
# /workspace/gpt4all-server/docker-compose.yml
version: '3.8'

services:
  gpt4all-server:
    build: .
    container_name: gpt4all-server
    restart: unless-stopped
    ports:
      - "4891:4891"
    volumes:
      - /workspace/models:/models
      - ./server.py:/app/server.py
    environment:
      - MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf
      - MODEL_PATH=/models
      - DEVICE=gpu
      - N_CTX=4096
      - API_PORT=4891
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:4891/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 120s
```

```bash
docker compose up -d
docker compose logs -f
```

***

## GPU त्वरण

### GPU उपयोग सत्यापित करना

GPT4All Python लाइब्रेरी उपयोग करती है `llama.cpp` CUDA सपोर्ट के साथ पर्दे के पीछे:

```bash
# मॉडल लोड होने के बाद GPU VRAM उपयोग जांचें
watch -n 2 nvidia-smi

# कंटेनर के अंदर जांचें कि CUDA उपलब्ध है
docker exec gpt4all-server python3 -c "
from gpt4all import GPT4All
devices = GPT4All.list_gpus()
print('उपलब्ध GPUs:', devices)
"
```

### GPU लेयर्स चुनना

यह `gpu_layers` (या `n_gpu_layers`) पैरामीटर नियंत्रित करता है कि मॉडल का कितना भाग GPU बनाम CPU पर चलता है:

```python
# server.py में — सभी लेयर्स को GPU पर मजबूर करें
model = GPT4All(
    model_name=MODEL_NAME,
    model_path=MODEL_PATH,
    device="gpu",
    n_ctx=N_CTX,
    # अतिरिक्त llama.cpp पैरामीटर आगे भेजे जाते हैं:
    # n_gpu_layers=99  # सभी लेयर्स GPU पर
)
```

```bash
# अधिकतम GPU लेयर्स के साथ पुनः बिल्ड और रीस्टार्ट करें
docker stop gpt4all-server && docker rm gpt4all-server
docker run -d \\
  --name gpt4all-server \\
  --gpus all \\
  -p 4891:4891 \\
  -v /workspace/models:/models \\
  -e DEVICE=gpu \\
  -e MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf \
  gpt4all-server:latest
```

### CPU फ़ॉलबैक मोड

यदि कोई GPU उपलब्ध नहीं है (जैसे, परीक्षण के लिए केवल-CPU Clore.ai सर्वर):

```bash
docker run -d \\
  --name gpt4all-server-cpu \
  -p 4891:4891 \\
  -v /workspace/models:/models \\
  -e DEVICE=cpu \
  -e MODEL_NAME=Phi-3-mini-4k-instruct.Q4_0.gguf \
  gpt4all-server:latest
```

> ⚠️ CPU इन्फ़रेंस **GPU की तुलना में 10–50× धीमा है** । केवल-CPU सर्वरों के लिए, छोटे मॉडल (Phi-3 Mini, TinyLlama) इस्तेमाल करें और 2–5 टोकन/सेकंड की अपेक्षा करें।

***

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

### 📥 मॉडल पहले से डाउनलोड करना

स्टार्टअप पर ऑटो-डाउनलोड पर निर्भर रहने के बजाय, तेज़ रीस्टार्ट के लिए मॉडल पहले से डाउनलोड करें:

```bash
# लोकप्रिय GPT4All मॉडल डाउनलोड करें
mkdir -p /workspace/models

# Mistral 7B (सबसे लोकप्रिय, अच्छी गुणवत्ता)
wget -q -O /workspace/models/mistral-7b-instruct-v0.1.Q4_0.gguf \
  "https://gpt4all.io/models/gguf/mistral-7b-instruct-v0.1.Q4_0.gguf"

# Phi-3 Mini (सबसे तेज़, सबसे छोटा)
wget -q -O /workspace/models/Phi-3-mini-4k-instruct.Q4_0.gguf \
  "https://gpt4all.io/models/gguf/Phi-3-mini-4k-instruct.Q4_0.gguf"

# Llama 3 (8B रेंज में सर्वोत्तम गुणवत्ता)
wget -q -O /workspace/models/Meta-Llama-3-8B-Instruct.Q4_0.gguf \
  "https://gpt4all.io/models/gguf/Meta-Llama-3-8B-Instruct.Q4_0.gguf"

ls -lh /workspace/models/
```

### 🔌 Python अनुप्रयोगों के साथ उपयोग करना

```python
# सीधे Python उपयोग (Docker API के बिना)
from gpt4all import GPT4All

model = GPT4All(
    model_name="mistral-7b-instruct-v0.1.Q4_0.gguf",
    model_path="/workspace/models",
    device="gpu"
)

# सरल जनरेशन
with model.chat_session():
    response = model.generate("साधारण शब्दों में GPU कंप्यूटिंग समझाइए", max_tokens=200)
    print(response)

# OpenAI क्लाइंट के साथ API सर्वर का उपयोग करना
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:4891/v1",
    api_key="not-needed"
)

completion = client.chat.completions.create(
    model="mistral-7b-instruct-v0.1.Q4_0.gguf",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(completion.choices[0].message.content)
```

### 💰 Clore.ai पर लागत अनुकूलन

```bash
# RTX 3090 @ $0.07–0.21/hr — 7B मॉडल के लिए उपयोग करें (सर्वश्रेष्ठ मूल्य)
# अपेक्षित थ्रूपुट: Mistral 7B Q4 के लिए ~40 टोकन/सेकंड
# 1M उत्पन्न टोकन की लागत: ~$0.005 (OpenAI की तुलना में अत्यंत सस्ता)

# RTX 4090 @ $0.14–0.42/hr — 13B मॉडल के लिए या जब गति महत्वपूर्ण हो तब उपयोग करें
# अपेक्षित थ्रूपुट: Mistral 7B Q4 के लिए ~60 टोकन/सेकंड

# बैच प्रोसेसिंग के लिए: मॉडल पहले लोड करें, सभी प्रॉम्प्ट्स प्रोसेस करें, फिर बंद करें
docker run --rm \
  --gpus all \\
  -v /workspace/models:/models \\
  -v /workspace/prompts:/prompts \
  gpt4all-server:latest \
  python3 -c "
from gpt4all import GPT4All
import json

model = GPT4All('mistral-7b-instruct-v0.1.Q4_0.gguf', '/models', device='gpu')
prompts = open('/prompts/batch.txt').readlines()
results = []
for p in prompts:
    with model.chat_session():
        results.append(model.generate(p.strip(), max_tokens=256))
json.dump(results, open('/prompts/results.json', 'w'))
print(f'प्रोसेस किए गए {len(results)} प्रॉम्प्ट्स')
"
```

***

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

### मॉडल लोड करने में विफल — फ़ाइल नहीं मिली

```bash
# जाँचें कि मॉडल फ़ाइल मौजूद है और उसका नाम सही है
ls -lh /workspace/models/
docker exec gpt4all-server ls /models/

# GPT4All मॉडल नामों के लिए case-sensitive है
# MODEL_NAME के रूप में ls आउटपुट से सटीक फ़ाइलनाम का उपयोग करें
docker stop gpt4all-server && docker rm gpt4all-server
docker run -d --gpus all -p 4891:4891 \
  -v /workspace/models:/models \\
  -e MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf \
  gpt4all-server:latest
```

### CUDA त्रुटि: इस आर्किटेक्चर के लिए कोई kernel image नहीं

```bash
# आपका GPU CUDA संस्करण के साथ संगत नहीं हो सकता है
# GPU compute capability जाँचें
nvidia-smi --query-gpu=compute_cap --format=csv,noheader

# यदि < 6.0, तो CPU मोड का उपयोग करें
docker run -d --gpus all -p 4891:4891 \
  -v /workspace/models:/models \\
  -e DEVICE=cpu \
  -e MODEL_NAME=Phi-3-mini-4k-instruct.Q4_0.gguf \
  gpt4all-server:latest
```

### API 503 लौटाता है — मॉडल लोड नहीं हुआ

```bash
# स्टार्टअप लॉग्स जाँचें
docker logs gpt4all-server | head -50

# मॉडल लोड होने में 30–120 सेकंड लग सकते हैं
# प्रतीक्षा करें और पुनः प्रयास करें:
sleep 60 && curl http://localhost:4891/health

# जाँचें कि मॉडल फ़ाइल भ्रष्ट तो नहीं है
python3 -c "
from gpt4all import GPT4All
m = GPT4All('mistral-7b-instruct-v0.1.Q4_0.gguf', '/workspace/models')
print('मॉडल ठीक है:', m)
"
```

### पोर्ट 4891 बाहर से सुलभ नहीं है

```bash
# पोर्ट बाइंडिंग सत्यापित करें
docker ps | grep 4891
# यह दिखना चाहिए: 0.0.0.0:4891->4891/tcp

# जाँचें कि क्या Clore.ai में firewall नियम हैं
# Clore.ai सर्वर सेटिंग्स में सुनिश्चित करें कि पोर्ट 4891 खुला सूचीबद्ध है

# आंतरिक रूप से परीक्षण करें:
curl http://127.0.0.1:4891/health

# नोट: Clore.ai पोर्ट्स को यादृच्छिक रूप से मैप करता है — अपने सर्वर डैशबोर्ड में दिखाया गया पोर्ट उपयोग करें
```

***

## अधिक पढ़ें

* [GPT4All GitHub](https://github.com/nomic-ai/gpt4all) — मुख्य रिपॉज़िटरी
* [GPT4All Python Docs](https://docs.gpt4all.io/) — Python API संदर्भ
* [GPT4All Model Explorer](https://gpt4all.io/models/gguf/) — उपलब्ध मॉडल ब्राउज़ करें
* [LocalAI Documentation](https://localai.io/) — Docker-अनुकूल विकल्प
* [Clore.ai पर Ollama](/guides/guides_v2-hi/language-models/ollama.md) — आसान Docker LLM परिनियोजन
* [Clore.ai पर vLLM](/guides/guides_v2-hi/language-models/vllm.md) — प्रोडक्शन इन्फ़रेंस सर्वर
* [GPU तुलना गाइड](/guides/guides_v2-hi/getting-started/gpu-comparison.md) — सही Clore.ai GPU चुनें
* [TheBloke on HuggingFace](https://huggingface.co/TheBloke) — हज़ारों GGUF quantizations
* [GGUF फ़ॉर्मेट समझाया गया](https://github.com/ggerganov/ggml/blob/master/docs/gguf.md) — मॉडल फ़ॉर्मेट दस्तावेज़

> 💡 **सिफारिश:** यदि आप स्थानीय LLMs के लिए सबसे सरल Docker परिनियोजन चाहते हैं, तो [Ollama](/guides/guides_v2-hi/language-models/ollama.md) इसके बजाय विचार करें — इसमें आधिकारिक Docker image, अंतर्निहित GPU सपोर्ट है, और यह विशेष रूप से सर्वर-साइड परिनियोजन के लिए डिज़ाइन किया गया है। GPT4All की ताकत इसका सुंदर desktop UI और LocalDocs (RAG) सुविधाएँ हैं, जो server mode में उपलब्ध नहीं हैं।


---

# 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/ai/gpt4all.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.