> 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-platforms-and-agents/gpt4all.md).

# GPT4All Local LLM

## अवलोकन

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

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

* 🔒 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.10/घं               |
| **अनुशंसित**   | RTX 3090      | 24 GB | 32 GB | 100 GB SSD | \~$0.20/घंटा             |
| **हाई-एंड**    | RTX 4090      | 24 GB | 64 GB | 200 GB SSD | \~$0.35/घंटा             |

> **नोट:** GPT4All GPU समर्थन अंदर से llama.cpp के माध्यम से CUDA का उपयोग करता है। vLLM के विपरीत, यह **समर्थन** विशेष CUDA कंप्यूट क्षमता की आवश्यकता नहीं रखता — सामान्यतः 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.1.0-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.1.0-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"Loading model: {MODEL_NAME}")
    print(f"Model path: {MODEL_PATH}")
    print(f"Device: {DEVICE}")
    model = GPT4All(
        model_name=MODEL_NAME,
        model_path=MODEL_PATH,
        device=DEVICE,
        n_ctx=N_CTX,
        allow_download=True,  # यदि उपलब्ध नहीं है तो GPT4All हब से डाउनलोड करता है
        verbose=True
    )
    print("Model loaded successfully!")

# --- 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="Model not loaded")

    # संदेशों को एकल प्रॉम्प्ट में फ़ॉर्मैट करें
    prompt_parts = []
    for msg in request.messages:
        if msg.role == "system":
            prompt_parts.append(f"### System:\n{msg.content}")
        elif msg.role == "user":
            prompt_parts.append(f"### Human:\n{msg.content}")
        elif msg.role == "assistant":
            prompt_parts.append(f"### Assistant:\n{msg.content}")
    prompt_parts.append("### Assistant:")
    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="Model not loaded")

    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('Available GPUs:', devices)
"
```

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

The `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("Explain GPU computing in simple terms", 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.20/घंटा — 7B मॉडलों के लिए उपयोग करें (सबसे अच्छा मूल्य)
# अनुमानित थ्रूपुट: Mistral 7B Q4 के लिए ~40 टोकन/सेकंड
# 1M जेनरेट किए गए टोकन्स की लागत: ~$0.005 (OpenAI की तुलना में बेहद सस्ता)

# RTX 4090 @ $0.35/घंटा — 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()
image_folder = "./images"
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'Processed {len(results)} prompts')
"
```

***

## समस्याओं का निवारण

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

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

# GPT4All मॉडल नामों के साथ केस-सेंसिटिव है
# ls आउटपुट से सटीक फ़ाइलनाम का उपयोग MODEL_NAME के रूप में करें
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 त्रुटि: इस आर्किटेक्चर के लिए कोई कर्नेल इमेज नहीं

```bash
# आपका GPU संभवतः CUDA संस्करण के साथ संगत नहीं हो सकता
# GPU कंप्यूट क्षमता जांचें
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('Model OK:', m)
"
```

### पोर्ट 4891 बाहर से पहुँचयोग्य नहीं

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

# जाँचें कि Clore.ai के फ़ायरवॉल नियम हैं या नहीं
# 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 मॉडल एक्सप्लोरर](https://gpt4all.io/models/gguf/) — उपलब्ध मॉडलों को ब्राउज़ करें
* [LocalAI दस्तावेज़](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 क्वांटाइज़ेशन्स
* [GGUF फॉर्मेट समझाया गया](https://github.com/ggerganov/ggml/blob/master/docs/gguf.md) — मॉडल फॉर्मेट दस्तावेज़

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


---

# 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-platforms-and-agents/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.