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

# AnythingLLM RAG प्लेटफ़ॉर्म

Clore.ai पर AnythingLLM डिप्लॉय करें — एक ऑल-इन-वन RAG एप्लिकेशन और AI एजेंट प्लेटफ़ॉर्म, जिसमें बिल्ट-इन डॉक्यूमेंट चैट, नो-कोड एजेंट बिल्डर, और MCP सपोर्ट शामिल है, जो किफ़ायती GPU क्लाउड सर्वरों पर चलता है।

## अवलोकन

[AnythingLLM](https://github.com/Mintplex-Labs/anything-llm) एक पूर्ण-विशेषताओं वाला, ओपन-सोर्स AI वर्कस्पेस है जिसके GitHub पर 40K+ स्टार हैं। यह दस्तावेज़-आधारित RAG (Retrieval-Augmented Generation), AI एजेंट्स, और एक नो-कोड एजेंट बिल्डर को एक ही, स्व-होस्टेड एप्लिकेशन में जोड़ता है — जिसे सेट अप करने के लिए बिल्कुल भी कोडिंग की आवश्यकता नहीं होती, और सब कुछ एक साफ़, सहज UI के माध्यम से प्रबंधित होता है.

**Clore.ai पर AnythingLLM क्यों चलाएँ?**

* **आउट ऑफ द बॉक्स पूरा RAG पाइपलाइन** — PDFs, Word डॉक्यूमेंट्स, वेबसाइट्स, और YouTube ट्रांसक्रिप्ट अपलोड करें। AnythingLLM उन्हें स्वचालित रूप से चंक्स में विभाजित करता है, एम्बेड करता है, और सिमेंटिक सर्च के लिए संग्रहीत करता है.
* **एप्लिकेशन के लिए GPU की आवश्यकता नहीं** — AnythingLLM डिफ़ॉल्ट रूप से CPU-आधारित एम्बेडिंग का उपयोग करता है। स्थानीय इन्फ़रेंस के लिए इसे Ollama या vLLM चला रहे Clore.ai GPU सर्वर के साथ जोड़ें.
* **वास्तविक टूल्स वाले AI एजेंट्स** — बिल्ट-इन एजेंट वेब ब्राउज़ कर सकते हैं, कोड लिख और चला सकते हैं, फ़ाइलें प्रबंधित कर सकते हैं, और बाहरी APIs को कॉल कर सकते हैं — सब कुछ GUI के माध्यम से संचालित होता है.
* **MCP संगतता** — विस्तारित टूल कनेक्टिविटी के लिए Model Context Protocol इकोसिस्टम के साथ इंटीग्रेट करता है.
* **वर्कस्पेस आइसोलेशन** — अलग-अलग परियोजनाओं या टीमों के लिए अलग ज्ञान-आधार और LLM सेटिंग्स वाले अलग वर्कस्पेस बनाएं.

### आर्किटेक्चर का अवलोकन

```
┌─────────────────────────────────────────────┐
│            AnythingLLM (पोर्ट 3001)         │
│                                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │ RAG/डॉक्स │  │  एजेंट्स │  │  उपयोगकर्ता │  │
│  └────┬─────┘  └────┬─────┘  └──────────┘  │
│       │             │                       │
│  ┌────▼─────────────▼───────┐               │
│  │    LLM प्रदाता राउटर    │               │
│  └──────────────┬───────────┘               │
└─────────────────┼───────────────────────────┘
                  │
     ┌────────────┼────────────┐
     ▼            ▼            ▼
  OpenAI       Anthropic    Ollama (स्थानीय)
  Claude        Gemini      vLLM (स्थानीय)
```

***

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

### सर्वर विनिर्देश

| घटक         | न्यूनतम     | अनुशंसित                                        | नोट्स                                               |
| ----------- | ----------- | ----------------------------------------------- | --------------------------------------------------- |
| **GPU**     | आवश्यक नहीं | RTX 3090 (यदि स्थानीय LLMs का उपयोग कर रहे हों) | केवल Ollama/vLLM बैकएंड के लिए                      |
| **VRAM**    | —           | 24 GB                                           | स्थानीय मॉडल inference के लिए                       |
| **CPU**     | 2 vCPU      | 4 vCPU                                          | एम्बेडिंग CPU पर चलती है                            |
| **RAM**     | 4 GB        | 8 GB                                            | जितना अधिक = मेमोरी में उतना बड़ा दस्तावेज़ इंडेक्स |
| **स्टोरेज** | 10 GB       | 50+ GB                                          | दस्तावेज़ स्टोरेज, वेक्टर DB, मॉडल कैश              |

### Clore.ai मूल्य निर्धारण संदर्भ

| सर्वर प्रकार                    | अनुमानित लागत                             | उपयोग-प्रकरण                         |
| ------------------------------- | ----------------------------------------- | ------------------------------------ |
| CPU इंस्टेंस (4 vCPU, 8 GB RAM) | \~$0.05–0.10/घंटा                         | AnythingLLM + बाहरी API प्रदाता      |
| RTX 3090 (24 GB VRAM)           | $0.07–0.21/hr                             | AnythingLLM + Ollama स्थानीय LLMs    |
| RTX 4090 (24 GB VRAM)           | $0.14–0.42/hr                             | AnythingLLM + तेज़ स्थानीय इन्फ़रेंस |
| A100 80 GB                      | [bare metal](https://clore.ai/bare-metal) | AnythingLLM + बड़े 70B+ मॉडल         |

> 💡 **प्रो टिप:** AnythingLLM की बिल्ट-इन एम्बेडिंग (LanceDB + स्थानीय CPU एम्बेडर) बिना GPU के काम करती है। LLM बैकएंड के लिए, आप OpenRouter या Groq जैसे फ्री-टियर API प्रदाताओं का उपयोग करके लागत को न्यूनतम रख सकते हैं.

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

* SSH एक्सेस वाला Clore.ai सर्वर
* Docker (Clore.ai servers पर पहले से इंस्टॉल)
* कम-से-कम एक LLM API कुंजी **या** स्थानीय Ollama/vLLM बैकएंड

***

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

### विधि 1: एकल Docker कंटेनर (अनुशंसित)

आधिकारिक एकल-कंटेनर डिप्लॉयमेंट में सब कुछ शामिल है: वेब UI, LanceDB वेक्टर स्टोर, और दस्तावेज़ प्रोसेसर.

**चरण 1: अपने Clore.ai सर्वर से कनेक्ट करें**

```bash
ssh root@<your-clore-server-ip> -p <ssh-port>
```

**चरण 2: स्टोरेज डायरेक्टरी सेट अप करें**

```bash
export STORAGE_LOCATION=$HOME/anythingllm
mkdir -p $STORAGE_LOCATION
touch "$STORAGE_LOCATION/.env"
```

**चरण 3: AnythingLLM चलाएँ**

```bash
docker run -d \\
  --name anythingllm \\
  --restart unless-stopped \\
  -p 3001:3001 \\
  --cap-add SYS_ADMIN \\
  -v ${STORAGE_LOCATION}:/app/server/storage \\
  -v ${STORAGE_LOCATION}/.env:/app/server/.env \\
  -e STORAGE_DIR="/app/server/storage" \\
  mintplexlabs/anythingllm
```

> **क्यों `--cap-add SYS_ADMIN`?** AnythingLLM वेबपेज स्क्रैपिंग और PDF रेंडरिंग के लिए Chromium का उपयोग करता है, जिसके लिए कंटेनर की ऊँची क्षमताएँ आवश्यक होती हैं.

**चरण 4: स्टार्टअप सत्यापित करें**

```bash
docker logs anythingllm --tail 30 -f
# प्रतीक्षा करें: "Server listening on port 3001"
```

**चरण 5: सेटअप विज़ार्ड पूरा करें**

ब्राउज़र में खोलें:

```
http://<your-clore-server-ip>:3001
```

पहली बार का सेटअप विज़ार्ड आपको इन चरणों से गुज़ारता है:

1. एडमिन खाता बनाएँ
2. LLM प्रदाता चुनें
3. एम्बेडिंग मॉडल चुनें
4. अपना पहला वर्कस्पेस कॉन्फ़िगर करें

***

### विधि 2: Docker Compose (मल्टी-सर्विस)

अलग सेवाओं और आसान प्रबंधन वाले प्रोडक्शन डिप्लॉयमेंट के लिए:

**चरण 1: प्रोजेक्ट डायरेक्टरी बनाएँ**

```bash
mkdir -p ~/anythingllm && cd ~/anythingllm
mkdir -p storage
touch storage/.env
```

**चरण 2: बनाएँ `docker-compose.yml`**

```bash
cat > docker-compose.yml << 'EOF'
version: '3.8'

services:
  anythingllm:
    image: mintplexlabs/anythingllm:latest
    container_name: anythingllm
    restart: unless-stopped
    ports:
      - "3001:3001"
    cap_add:
      - SYS_ADMIN
    environment:
      STORAGE_DIR: "/app/server/storage"
      # LLM प्रदाता (एक चुनें)
      LLM_PROVIDER: openai
      OPEN_AI_KEY: ${OPENAI_API_KEY}
      OPEN_MODEL_PREF: gpt-4o-mini
      # एम्बेडिंग
      EMBEDDING_ENGINE: native
      # वेक्टर DB
      VECTOR_DB: lancedb
      # प्रमाणीकरण
      AUTH_TOKEN: ${ANYTHINGLLM_AUTH_TOKEN}
      JWT_SECRET: ${JWT_SECRET}
    volumes:
      - ./storage:/app/server/storage
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3001/api/ping"]
      interval: 30s
      timeout: 10s
      retries: 3

volumes:
  anythingllm_storage:
EOF
```

**चरण 3: बनाएँ `.env` फ़ाइल**

```bash
cat > .env << 'EOF'
OPENAI_API_KEY=sk-your-openai-key-here
ANYTHINGLLM_AUTH_TOKEN=your-instance-password-here
JWT_SECRET=your-random-64-char-secret-here
EOF
```

**चरण 4: शुरू करें**

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

***

### विधि 3: पूर्व-कॉन्फ़िगर किए गए वातावरण वेरिएबल्स के साथ

सेटअप विज़ार्ड के बिना स्वचालित डिप्लॉयमेंट के लिए:

```bash
export STORAGE_LOCATION=$HOME/anythingllm
mkdir -p $STORAGE_LOCATION && touch "$STORAGE_LOCATION/.env"

docker run -d \\
  --name anythingllm \\
  --restart unless-stopped \\
  -p 3001:3001 \\
  --cap-add SYS_ADMIN \\
  -v ${STORAGE_LOCATION}:/app/server/storage \\
  -v ${STORAGE_LOCATION}/.env:/app/server/.env \\
  -e STORAGE_DIR="/app/server/storage" \\
  -e LLM_PROVIDER=openai \\
  -e OPEN_AI_KEY=sk-your-key \\
  -e OPEN_MODEL_PREF=gpt-4o-mini \\
  -e EMBEDDING_ENGINE=native \\
  -e VECTOR_DB=lancedb \\
  -e AUTH_TOKEN=your-password \\
  -e JWT_SECRET=$(openssl rand -hex 32) \\
  mintplexlabs/anythingllm
```

***

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

### LLM प्रदाता विकल्प

AnythingLLM LLM बैकएंड्स की एक विस्तृत श्रृंखला का समर्थन करता है। इसे UI में यहाँ सेट करें **सेटिंग्स → LLM प्राथमिकता**, या वातावरण वेरिएबल्स के माध्यम से:

**OpenAI:**

```bash
-e LLM_PROVIDER=openai
-e OPEN_AI_KEY=sk-your-key
-e OPEN_MODEL_PREF=gpt-4o
```

**Anthropic Claude:**

```bash
-e LLM_PROVIDER=anthropic
-e ANTHROPIC_API_KEY=sk-ant-your-key
-e ANTHROPIC_MODEL_PREF=claude-sonnet-4-5
```

**Google Gemini:**

```bash
-e LLM_PROVIDER=gemini
-e GEMINI_API_KEY=your-key
-e GEMINI_LLM_MODEL_PREF=gemini-1.5-pro
```

**Ollama (स्थानीय):**

```bash
-e LLM_PROVIDER=ollama
-e OLLAMA_BASE_PATH=http://172.17.0.1:11434
-e OLLAMA_MODEL_PREF=llama3.2
```

**OpenRouter (100+ मॉडलों तक पहुँच):**

```bash
-e LLM_PROVIDER=openrouter
-e OPENROUTER_API_KEY=sk-or-your-key
-e OPENROUTER_MODEL_PREF=meta-llama/llama-3.1-8b-instruct:free
```

### एम्बेडिंग कॉन्फ़िगरेशन

| इंजन      | बैकएंड         | GPU आवश्यक | गुणवत्ता    |
| --------- | -------------- | ---------- | ----------- |
| `native`  | CPU (बिल्ट-इन) | नहीं       | अच्छा       |
| `openai`  | OpenAI API     | नहीं       | उत्कृष्ट    |
| `ollama`  | स्थानीय Ollama | वैकल्पिक   | अच्छा-उत्तम |
| `localai` | LocalAI        | वैकल्पिक   | वेरिएबल     |

```bash
# सर्वोत्तम गुणवत्ता के लिए OpenAI embeddings का उपयोग करें
-e EMBEDDING_ENGINE=openai
-e OPEN_AI_KEY=sk-your-key
-e EMBEDDING_MODEL_PREF=text-embedding-3-small

# पूरी तरह स्थानीय पाइपलाइन के लिए Ollama embeddings का उपयोग करें
-e EMBEDDING_ENGINE=ollama
-e OLLAMA_BASE_PATH=http://172.17.0.1:11434
-e EMBEDDING_MODEL_PREF=nomic-embed-text
```

### वेक्टर डेटाबेस विकल्प

| DB         | विवरण                       | किसके लिए सर्वोत्तम          |
| ---------- | --------------------------- | ---------------------------- |
| `lancedb`  | बिल्ट-इन, कोई कॉन्फ़िग नहीं | डिफ़ॉल्ट, छोटे-मध्यम डेटासेट |
| `chroma`   | ChromaDB (बाहरी)            | मध्यम डेटासेट, लचीलापन       |
| `pinecone` | Pinecone क्लाउड             | बड़े डेटासेट, प्रोडक्शन      |
| `weaviate` | Weaviate (स्व-होस्टेड)      | उन्नत उपयोग मामलों           |

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

AnythingLLM वर्कस्पेसेज़ पृथक वातावरण हैं जिनमें अपना:

* दस्तावेज़ ज्ञान-आधार
* LLM सेटिंग्स (वैश्विक सेटिंग्स को ओवरराइड कर सकती हैं)
* चैट इतिहास
* एजेंट कॉन्फ़िगरेशन

UI या API के माध्यम से वर्कस्पेसेज़ बनाएँ:

```bash
# API के माध्यम से वर्कस्पेस बनाएँ
curl -X POST http://localhost:3001/api/v1/workspace/new \\
  -H "Authorization: Bearer your-api-key" \\
  -H "Content-Type: application/json" \
  -d '{"name": "My Project", "similarityThreshold": 0.7}'
```

### दस्तावेज़ इनजेशन

UI या API के माध्यम से दस्तावेज़ अपलोड करें:

```bash
# API के माध्यम से दस्तावेज़ अपलोड करें
curl -X POST http://localhost:3001/api/v1/document/upload \\
  -H "Authorization: Bearer your-api-key" \\
  -F "file=@/path/to/document.pdf"

# दस्तावेज़ को वर्कस्पेस में स्थानांतरित करें
curl -X POST http://localhost:3001/api/v1/workspace/my-project/update-embeddings \\
  -H "Authorization: Bearer your-api-key" \\
  -H "Content-Type: application/json" \
  -d '{"adds": ["custom-documents/document.pdf-chunk-1.json"]}'
```

***

## GPU त्वरण

AnythingLLM स्वयं CPU पर चलता है। GPU त्वरण LLM इन्फ़रेंस बैकएंड पर लागू होता है.

### एक ही Clore.ai सर्वर पर Ollama चलाना

```bash
# GPU सपोर्ट के साथ Ollama शुरू करें
docker run -d \\
  --name ollama \
  --gpus all \\
  --restart unless-stopped \\
  -p 11434:11434 \
  -v ollama_data:/root/.ollama \\
  ollama/ollama

# AnythingLLM के लिए मॉडल्स पुल करें
docker exec ollama ollama pull llama3.2          # 2B, तेज़
docker exec ollama ollama pull llama3.1:8b       # 8B, संतुलित
docker exec ollama ollama pull nomic-embed-text  # एम्बेडिंग्स के लिए
docker exec ollama ollama pull mxbai-embed-large # बेहतर एम्बेडिंग्स

# Ollama कॉन्फ़िग के साथ AnythingLLM पुनः प्रारंभ करें
docker stop anythingllm && docker rm anythingllm

docker run -d \\
  --name anythingllm \\
  --restart unless-stopped \\
  -p 3001:3001 \\
  --cap-add SYS_ADMIN \\
  -v $HOME/anythingllm:/app/server/storage \\
  -v $HOME/anythingllm/.env:/app/server/.env \\
  -e STORAGE_DIR="/app/server/storage" \\
  -e LLM_PROVIDER=ollama \\
  -e OLLAMA_BASE_PATH=http://172.17.0.1:11434 \\
  -e OLLAMA_MODEL_PREF=llama3.1:8b \\
  -e EMBEDDING_ENGINE=ollama \\
  -e EMBEDDING_MODEL_PREF=nomic-embed-text \\
  mintplexlabs/anythingllm
```

### Clore.ai पर GPU-मॉडल प्रदर्शन

| मॉडल          | GPU       | VRAM   | एम्बेडिंग गति | इन्फ़रेंस गति | लागत/घंटा |
| ------------- | --------- | ------ | ------------- | ------------- | --------- |
| Llama 3.2 3B  | RTX 3090  | 2 जीबी | तेज़          | 60–80 tok/s   | \~$0.20   |
| Llama 3.1 8B  | RTX 3090  | 6 GB   | तेज़          | 40–60 tok/s   | \~$0.20   |
| Mistral 7B    | RTX 3090  | 5 GB   | तेज़          | 45–65 tok/s   | \~$0.20   |
| Llama 3.1 70B | A100 80GB | 40 GB  | मध्यम         | 20–35 tok/s   | \~$1.10   |

***

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

### दस्तावेज़ इनजेशन की सर्वोत्तम प्रथाएँ

```bash
# बड़े दस्तावेज़ सेट के लिए, Node.js मेमोरी बढ़ाएँ
-e NODE_OPTIONS="--max-old-space-size=4096"

# विभिन्न दस्तावेज़ प्रकारों के लिए अनुशंसित चंक सेटिंग्स
# तकनीकी दस्तावेज़: chunk size 1000, overlap 200
# कानूनी/अनुबंध: chunk size 500, overlap 100
# पुस्तकें/लेख: chunk size 1500, overlap 300
```

* **बड़े PDFs को पूर्व-प्रसंस्कृत करें** — OCR-भारी स्कैन इनजेशन को धीमा करते हैं। पहले `pdftotext` या Adobe OCR का उपयोग करें.
* **वर्कस्पेस के अनुसार व्यवस्थित करें** — बेहतर रिट्रीवल सटीकता के लिए प्रति प्रोजेक्ट/डोमेन अलग वर्कस्पेस बनाएँ.
* **विशिष्ट क्वेरीज़ का उपयोग करें** — RAG विशिष्ट प्रश्नों के साथ सबसे अच्छा काम करता है, व्यापक अनुरोधों के साथ नहीं.

### Clore.ai पर लागत प्रबंधन

```bash
# Clore.ai इंस्टेंस बंद करने से पहले अपने स्टोरेज का बैकअप लें
tar -czf anythingllm-backup-$(date +%Y%m%d).tar.gz ~/anythingllm/

# नए Clore.ai इंस्टेंस पर फिर से शुरू करने के लिए, बैकअप पुनर्स्थापित करें
tar -xzf anythingllm-backup-20240101.tar.gz -C ~/
```

चूँकि Clore.ai इंस्टेंस अस्थायी होते हैं, इसलिए हमेशा स्टोरेज डायरेक्टरी का बैकअप लें। इसमें शामिल है:

* वेक्टर एम्बेडिंग्स (LanceDB)
* अपलोड किए गए दस्तावेज़
* चैट इतिहास
* एजेंट कॉन्फ़िगरेशन

### मल्टी-यूज़र सेटअप

```bash
# UI में मल्टी-यूज़र मोड सक्षम करें:
# सेटिंग्स → सुरक्षा → मल्टी-यूज़र मोड सक्षम करें

# या वातावरण के माध्यम से:
-e MULTI_USER_MODE=true

# मल्टी-यूज़र सक्षम करने के बाद API के माध्यम से उपयोगकर्ता बनाएँ
curl -X POST http://localhost:3001/api/v1/admin/users/new \\
  -H "Authorization: Bearer admin-api-key" \\
  -H "Content-Type: application/json" \
  -d '{"username": "alice", "password": "securepass", "role": "default"}'
```

### AI एजेंट कॉन्फ़िगरेशन

AnythingLLM एजेंट वास्तविक दुनिया के कार्य कर सकते हैं। टूल्स सक्षम करें **सेटिंग्स → एजेंट्स**:

* **वेब ब्राउज़** — वेब पेज लाता और पढ़ता है
* **Google खोज** — Google खोजता है (API कुंजी आवश्यक)
* **कोड इंटरप्रेटर** — सैंडबॉक्स में Python चलाता है
* **GitHub** — रिपॉज़िटरीज़ पढ़ता है
* **SQL कनेक्टर** — डेटाबेस क्वेरी करता है

```bash
# वातावरण के माध्यम से एजेंट क्षमताएँ सक्षम करें
-e AGENT_SEARCH_PROVIDER=google
-e AGENT_GSX_GOOGLE_SEARCH_ENGINE_ID=your-cx-id
-e AGENT_GSX_GOOGLE_SEARCH_KEY=your-api-key
```

### प्रदर्शन ट्यूनिंग

```bash
# भारी दस्तावेज़-प्रसंस्करण वर्कलोड के लिए
docker run -d \\
  --name anythingllm \\
  --restart unless-stopped \\
  --cpus="4" \\
  --memory="8g" \\
  -p 3001:3001 \\
  --cap-add SYS_ADMIN \\
  -v $HOME/anythingllm:/app/server/storage \\
  -v $HOME/anythingllm/.env:/app/server/.env \\
  -e STORAGE_DIR="/app/server/storage" \\
  mintplexlabs/anythingllm
```

### AnythingLLM अपडेट करना

```bash
# नवीनतम इमेज डाउनलोड करें
docker pull mintplexlabs/anythingllm:latest

# पहले बैकअप लें
cp -r $HOME/anythingllm $HOME/anythingllm-backup-$(date +%Y%m%d)

# पुराने कंटेनर को रोकें और हटाएँ (डेटा वॉल्यूम में है, सुरक्षित है)
docker stop anythingllm && docker rm anythingllm

# उसी कमांड के साथ पुनः प्रारंभ करें
docker run -d \\
  --name anythingllm \\
  --restart unless-stopped \\
  -p 3001:3001 \\
  --cap-add SYS_ADMIN \\
  -v $HOME/anythingllm:/app/server/storage \\
  -v $HOME/anythingllm/.env:/app/server/.env \\
  -e STORAGE_DIR="/app/server/storage" \\
  mintplexlabs/anythingllm
```

***

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

### कंटेनर शुरू हो जाता है लेकिन UI सुलभ नहीं है

```bash
# जांचें कि कंटेनर चल रहा है
docker ps | grep anythingllm

# स्टार्टअप त्रुटियों के लिए लॉग जाँचें
docker logs anythingllm --tail 50

# पोर्ट बाइंडिंग सत्यापित करें
ss -tlnp | grep 3001

# जाँचें कि Clore.ai सर्वर की पोर्ट मैपिंग में 3001 है या नहीं
# (इसे Clore.ai डिप्लॉयमेंट सेटिंग्स में जोड़ें)
```

### दस्तावेज़ अपलोड विफल होता है

```bash
# उपलब्ध डिस्क स्पेस जाँचें
df -h

# दस्तावेज़ प्रोसेसर लॉग्स जाँचें
docker logs anythingllm 2>&1 | grep -i "error\|fail\|upload"

# सत्यापित करें कि SYS_ADMIN क्षमता सेट है (Chromium के लिए आवश्यक)
docker inspect anythingllm | grep -A5 CapAdd
```

### RAG प्रतिक्रियाएँ खराब गुणवत्ता की हैं / हैलुसिनेट कर रही हैं

सामान्य कारण और समाधान:

```bash
# 1. समानता थ्रेशहोल्ड समायोजित करें (कम = अधिक दस्तावेज़ प्राप्त होंगे)
# सेटिंग्स → वर्कस्पेस → वेक्टर डेटाबेस → समानता थ्रेशहोल्ड: 0.5

# 2. शीर्ष-K परिणाम बढ़ाएँ
# सेटिंग्स → वर्कस्पेस → वेक्टर डेटाबेस → अधिकतम संदर्भ स्निपेट: 10

# 3. चंक आकार बेहतर करें (बदलाव के बाद दस्तावेज़ों को फिर से इनजेस्ट करें)
# सेटिंग्स → वर्कस्पेस → टेक्स्ट स्प्लिटर → चंक आकार: 1000, ओवरलैप: 200

# बेहतर एम्बेडिंग मॉडल पर स्विच करें
-e EMBEDDING_ENGINE=openai
-e EMBEDDING_MODEL_PREF=text-embedding-3-large
```

### AnythingLLM से Ollama कनेक्शन विफल होता है

```bash
# AnythingLLM कंटेनर से परीक्षण करें
docker exec anythingllm curl -s http://172.17.0.1:11434/api/tags

# यदि वह विफल हो, तो वास्तविक Docker ब्रिज IP खोजें
ip route | grep docker
# OLLAMA_BASE_PATH में उस IP का उपयोग करें

# वैकल्पिक: host networking का उपयोग करें
docker run -d \\
  --name anythingllm \\
  --network host \
  --cap-add SYS_ADMIN \\
  -v $HOME/anythingllm:/app/server/storage \\
  -v $HOME/anythingllm/.env:/app/server/.env \\
  -e STORAGE_DIR="/app/server/storage" \\
  -e OLLAMA_BASE_PATH=http://localhost:11434 \\
  mintplexlabs/anythingllm
```

### मेमोरी समाप्त / कंटेनर क्रैश

```bash
# memory usage जांचें
docker stats anythingllm

# LanceDB कैश कम करके मेमोरी मुक्त करें
# या अधिक RAM वाले Clore.ai इंस्टेंस पर स्विच करें

# मेमोरी सीमाओं और swap के साथ पुनः प्रारंभ करें
docker run -d \\
  --name anythingllm \\
  --memory=6g \\
  --memory-swap=8g \\
  -p 3001:3001 \\
  --cap-add SYS_ADMIN \\
  -v $HOME/anythingllm:/app/server/storage \\
  -v $HOME/anythingllm/.env:/app/server/.env \\
  -e STORAGE_DIR="/app/server/storage" \\
  mintplexlabs/anythingllm
```

***

## अधिक पढ़ें

* [AnythingLLM दस्तावेज़ीकरण](https://docs.anythingllm.com) — पूर्ण सेटअप और API संदर्भ
* [AnythingLLM GitHub](https://github.com/Mintplex-Labs/anything-llm) — स्रोत कोड, समस्याएँ, रोडमैप
* [AnythingLLM Docker Hub](https://hub.docker.com/r/mintplexlabs/anythingllm) — इमेज टैग्स
* [Clore.ai पर Ollama चलाना](/guides/guides_v2-hi/language-models/ollama.md) — AnythingLLM के लिए स्थानीय LLM बैकएंड
* [Clore.ai पर vLLM चलाना](/guides/guides_v2-hi/language-models/vllm.md) — उच्च-प्रदर्शन इन्फरेंस
* [GPU तुलना गाइड](/guides/guides_v2-hi/getting-started/gpu-comparison.md) — सही Clore.ai टियर चुनना
* [MCP दस्तावेज़ीकरण](https://modelcontextprotocol.io) — एजेंटों को विस्तारित करने के लिए Model Context Protocol
* [AnythingLLM API संदर्भ](https://docs.anythingllm.com/api-reference) — स्वचालन के लिए REST API


---

# 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/anythingllm.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.