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

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

अवलोकन

AnythingLLM एक पूर्ण-विशेषताओं वाला, ओपन-सोर्स 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

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 सर्वर से कनेक्ट करें

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

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

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

चरण 3: AnythingLLM चलाएँ

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: स्टार्टअप सत्यापित करें

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

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

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

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

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

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

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

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

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

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

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

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 फ़ाइल

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: शुरू करें

docker compose up -d
docker compose logs anythingllm -f

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

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

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:

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

Anthropic Claude:

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

Google Gemini:

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

Ollama (स्थानीय):

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

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

-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

वैकल्पिक

वेरिएबल

# सर्वोत्तम गुणवत्ता के लिए 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

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

विवरण

किसके लिए सर्वोत्तम

lancedb

बिल्ट-इन, कोई कॉन्फ़िग नहीं

डिफ़ॉल्ट, छोटे-मध्यम डेटासेट

chroma

ChromaDB (बाहरी)

मध्यम डेटासेट, लचीलापन

pinecone

Pinecone क्लाउड

बड़े डेटासेट, प्रोडक्शन

weaviate

Weaviate (स्व-होस्टेड)

उन्नत उपयोग मामलों

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

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

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

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

# 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 के माध्यम से दस्तावेज़ अपलोड करें:

# 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 चलाना

# 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

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

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

# बड़े दस्तावेज़ सेट के लिए, 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 पर लागत प्रबंधन

# 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)
अपलोड किए गए दस्तावेज़
चैट इतिहास
एजेंट कॉन्फ़िगरेशन

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

# 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 कनेक्टर — डेटाबेस क्वेरी करता है

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

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

# भारी दस्तावेज़-प्रसंस्करण वर्कलोड के लिए
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 अपडेट करना

# नवीनतम इमेज डाउनलोड करें
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 सुलभ नहीं है

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# 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

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

# 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 दस्तावेज़ीकरण — पूर्ण सेटअप और API संदर्भ
AnythingLLM GitHub — स्रोत कोड, समस्याएँ, रोडमैप
AnythingLLM Docker Hub — इमेज टैग्स
Clore.ai पर Ollama चलाना — AnythingLLM के लिए स्थानीय LLM बैकएंड
Clore.ai पर vLLM चलाना — उच्च-प्रदर्शन इन्फरेंस
GPU तुलना गाइड — सही Clore.ai टियर चुनना
MCP दस्तावेज़ीकरण — एजेंटों को विस्तारित करने के लिए Model Context Protocol
AnythingLLM API संदर्भ — स्वचालन के लिए REST API

पिछलाLibreChat मल्टी-प्रोवाइडर

अगलाJan.ai ऑफ़लाइन असिस्टेंट

अंतिम अपडेट 23 दिन पहले

क्या यह उपयोगी था?