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

# AnythingLLM RAG Platform

## अवलोकन

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

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

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

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

```
┌─────────────────────────────────────────────┐
│            AnythingLLM (Port 3001)          │
│                                             │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  │
│  │ RAG/Docs │  │  Agents  │  │  Users   │  │
│  └────┬─────┘  └────┬─────┘  └──────────┘  │
│       │             │                       │
│  ┌────▼─────────────▼───────┐               │
│  │    LLM Provider Router   │               │
│  └──────────────┬───────────┘               │
└─────────────────┼───────────────────────────┘
                  │
     ┌────────────┼────────────┐
     ▼            ▼            ▼
  OpenAI       Anthropic    Ollama (local)
  Claude        Gemini      vLLM (local)
```

***

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

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

| घटक         | न्यूनतम         | अनुशंसित                                           | नोट्स                                      |
| ----------- | --------------- | -------------------------------------------------- | ------------------------------------------ |
| **GPU**     | कोई आवश्यक नहीं | RTX 3090 (यदि स्थानीय LLMs का उपयोग कर रहे हों तो) | केवल Ollama/vLLM बैकएंड के लिए             |
| **VRAM**    | —               | 24 GB                                              | स्थानीय मॉडल इन्फरेंस के लिए               |
| **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.20/घंटा      | AnythingLLM + Ollama स्थानीय LLMs   |
| RTX 4090 (24 GB VRAM)           | \~$0.35/घंटा      | AnythingLLM + तेज़ स्थानीय इनफेरेंस |
| A100 80 GB                      | \~$1.10/घंटा      | AnythingLLM + बड़े 70B+ मॉडल        |

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

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

* SSH एक्सेस वाला Clore.ai सर्वर
* Docker (Clore.ai सर्वरों पर प्री-इंस्टॉल्ड)
* कम से कम एक 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 Provider (एक कॉन्फ़िगर करें)
      LLM_PROVIDER: openai
      OPEN_AI_KEY: ${OPENAI_API_KEY}
      OPEN_MODEL_PREF: gpt-4o-mini
      # Embedding
      EMBEDDING_ENGINE: native
      # Vector DB
      VECTOR_DB: lancedb
      # Auth
      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=आपका-रैंडम-64-करैक्टर-सीक्रेट-यहाँ
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 में सेट करें: **Settings → LLM Preference**, या एनवायरनमेंट वेरिएबल्स के माध्यम से:

**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 एम्बेडिंग का उपयोग करें
-e EMBEDDING_ENGINE=openai
-e OPEN_AI_KEY=sk-your-key
-e EMBEDDING_MODEL_PREF=text-embedding-3-small

# पूरी तरह स्थानीय पाइपलाइन के लिए Ollama एम्बेडिंग का उपयोग करें
-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 GB  | तेज़            | 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"

# विभिन्न दस्तावेज़ प्रकारों के लिए अनुशंसित चंक सेटिंग्स
# टेक्निकल डॉक्स: चंक साइज 1000, ओवरलैप 200
# कानूनी/अनुबंध: चंक साइज 500, ओवरलैप 100
# किताबें/लेख: चंक साइज 1500, ओवरलैप 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 इंस्टेंस क्षणिक (ephemeral) होते हैं, हमेशा स्टोरेज डायरेक्टरी का बैकअप लें। इसमें शामिल है:

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

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

```bash
# UI में मल्टी-यूज़र मोड सक्षम करें:
# Settings → Security → Enable Multi-User Mode

# या एनवायरनमेंट के माध्यम से:
-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 एजेंट वास्तविक-विश्व कार्य कर सकते हैं। उपकरणों को सक्षम करें: **Settings → Agents**:

* **वेब ब्राउज़** — वेब पेज फ़ेच और पढ़ता है
* **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. समानता थ्रेशोल्ड समायोजित करें (न्यून = अधिक दस्तावेज़ प्राप्त होते हैं)
# Settings → Workspace → Vector Database → Similarity Threshold: 0.5

# 2. टॉप-K परिणाम बढ़ाएँ
# Settings → Workspace → Vector Database → Max Context Snippets: 10

# 3. चंक साइज सुधारें (बदलने के बाद दस्तावेज़ फिर से इनजेस्ट करें)
# Settings → Workspace → Text Splitter → Chunk Size: 1000, Overlap: 200

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

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

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

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

# विकल्प: होस्ट नेटवर्किंग का उपयोग करें
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
# मेमोरी उपयोग जाँचें
docker stats anythingllm

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

# मेमोरी सीमाओं और स्वैप के साथ पुनः प्रारंभ करें
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-platforms-and-agents/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.