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

# SuperAGI Agent Framework

## अवलोकन

[SuperAGI](https://github.com/TransformerOptimus/SuperAGI) एक ओपन-सोर्स, डेवलपर-प्रथम स्वायत्त AI एजेंट फ्रेमवर्क है जिसे 15K+ GitHub स्टार मिले हैं। साधारण चैटबॉट्स के विपरीत, SuperAGI चलाता है **स्वायत्त एजेंट** — AI सिस्टम जो स्वतंत्र रूप से योजना बनाते हैं, बहु-चरण कार्यों को निष्पादित करते हैं, टूल्स का उपयोग करते हैं, और निरंतर मानवीय इनपुट के बिना लक्ष्य की ओर पुनरावृत्त होते हैं।

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

* **GPU-वैकल्पिक शक्तिशाली स्थानीय LLM समर्थन के साथ** — पूरी तरह निजी, लागत-नियंत्रित स्वायत्त AI के लिए Clore.ai GPU पर स्थानीय मॉडलों (Llama, Mistral, आदि) द्वारा समर्थित एजेंट चलाएँ।
* **समानांतर एजेंट निष्पादन** — एक ही सर्वर पर एक साथ कई एजेंट समानांतर रूप से चलाएँ, हर एक एक ही समय में अलग-अलग कार्यों पर काम करता है।
* **स्थायी एजेंट मेमोरी** — एजेंट संदर्भ बनाए रखते हैं, टूल आउटपुट से सीखते हैं, और रन के बीच दीर्घकालिक मेमोरी को वेक्टर डेटाबेस में संग्रहित करते हैं।
* **टूल मार्केटप्लेस** — Google Search, GitHub, Email, Jira, Notion और अन्य के लिए प्री-बिल्ट इंटीग्रेशन।
* **Clore.ai अर्थशास्त्र** — RTX 3090 के लिए लगभग $0.20/घंटा पर, आप क्लाउड AI सेवा की लागत के एक हिस्से पर सक्षम स्वायत्त एजेंट चला सकते हैं।

### प्रमुख विशेषताएँ

| फ़ीचर              | विवरण                                                       |
| ------------------ | ----------------------------------------------------------- |
| एजेंट प्रोविजनिंग  | GUI के माध्यम से एजेंट बनाएं, कॉन्फ़िगर करें और तैनात करें  |
| टूल मार्केटप्लेस   | 30+ बिल्ट-इन टूल्स (सर्च, कोड, फाइलें, APIs)                |
| मल्टि-मॉडल समर्थन  | OpenAI, Anthropic, कस्टम एंडपॉइंट के माध्यम से स्थानीय LLMs |
| समानांतर एजेंट     | एक साथ कई एजेंट चलाएँ                                       |
| एजेंट मेमोरी       | अल्पकालिक (संदर्भ विंडो) + दीर्घकालिक (वेक्टर DB)           |
| GUI डैशबोर्ड       | एजेंट प्रबंधन के लिए पूर्ण वेब इंटरफ़ेस                     |
| रिसोर्स मैनेजर     | प्रति एजेंट टोकन उपयोग और लागत ट्रैक करें                   |
| वर्कफ़्लो टेम्पलेट | सामान्य कार्यों के लिए प्री-बिल्ट एजेंट टेम्पलेट्स          |

### आर्किटेक्चर

```
┌────────────────────────────────────────────────────┐
│              SuperAGI स्टैक                         │
│                                                    │
│  ┌─────────────────────┐   ┌───────────────────┐   │
│  │  फ्रंटएंड (पोर्ट 3000)│   │  API (पोर्ट 8001)  │   │
│  │   Next.js UI         │   │  FastAPI बैकएंड     │   │
│  └──────────┬──────────┘   └─────────┬─────────┘   │
│             └──────────┬─────────────┘             │
│                        ▼                           │
│  ┌─────────────────────────────────────────────┐   │
│  │              एजेंट एक्ज़ेक्यूटर              │   │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  │   │
│  │  │  एजेंट 1  │  │  एजेंट 2  │  │  एजेंट N  │  │   │
│  │  └──────────┘  └──────────┘  └──────────┘  │   │
│  └───────┬─────────────┬─────────────┬─────────┘   │
│          ▼             ▼             ▼             │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐      │
│  │ PostgreSQL │  │  Redis    │  │  Vector   │      │
│  │  (State)  │  │  (Queue)  │  │    DB     │      │
│  └───────────┘  └───────────┘  └───────────┘      │
└────────────────────────────────────────────────────┘
          │
    ┌─────┴──────┐
    ▼            ▼
 OpenAI      स्थानीय LLM
 Anthropic   (Ollama/vLLM)
```

***

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

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

| घटक         | न्यूनतम            | अनुशंसित                | नोट्स                                            |
| ----------- | ------------------ | ----------------------- | ------------------------------------------------ |
| **GPU**     | कोई नहीं (API मोड) | RTX 3090 (स्थानीय LLMs) | स्थानीय मॉडल इन्फरेंस के लिए GPU की आवश्यकता     |
| **VRAM**    | —                  | 24 GB                   | 13B+ स्थानीय मॉडल चलाने के लिए                   |
| **CPU**     | 4 vCPU             | 8 vCPU                  | एजेंट निष्पादन CPU-गहन है                        |
| **RAM**     | 8 GB               | 16 GB                   | कई समवर्ती एजेंटों को मेमोरी की आवश्यकता होती है |
| **स्टोरेज** | 20 GB              | 100+ GB                 | एजेंट लॉग, वेक्टर DB, मॉडल स्टोरेज               |

### Clore.ai मूल्य संदर्भ

| सर्वर प्रकार        | अनुमानित लागत     | उपयोग का मामला                          |
| ------------------- | ----------------- | --------------------------------------- |
| CPU (8 vCPU, 16 GB) | \~$0.10–0.20/घंटा | SuperAGI + बाहरी API (OpenAI/Anthropic) |
| RTX 3090 (24 GB)    | \~$0.20/घंटा      | SuperAGI + Ollama 13B स्थानीय मॉडल      |
| RTX 4090 (24 GB)    | \~$0.35/घंटा      | SuperAGI + Ollama, तेज़ इन्फरेंस        |
| 2× RTX 3090         | \~$0.40/घंटा      | SuperAGI + 70B मॉडल (Q4 क्वांटाइज्ड)    |
| A100 80 GB          | \~$1.10/घंटा      | SuperAGI + बड़े मॉडल, उच्च समवर्तीता    |
| H100 80 GB          | \~$2.50/घंटा      | प्रोडक्शन-ग्रेड स्वायत्त एजेंट सिस्टम   |

> 💡 **खर्च सुझाव:** विकास और परीक्षण के लिए, OpenAI या Anthropic APIs का उपयोग करें (GPU की आवश्यकता नहीं)। केवल जब गोपनीयता या लागत कारणों से स्थानीय LLM इन्फरेंस की आवश्यकता हो तब GPU इंस्टेंस पर स्विच करें। देखें [GPU तुलना मार्गदर्शिका](/guides/guides_v2-hi/getting-started/gpu-comparison.md).

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

* SSH एक्सेस वाला Clore.ai सर्वर
* Docker + Docker Compose (Clore.ai पर पूर्व-स्थापित)
* Git (पूर्व-स्थापित)
* 4+ vCPU, 8+ GB RAM (समवर्ती एजेंट्स के लिए 16 GB की सिफारिश)
* OpenAI API कुंजी **या** स्थानीय LLM एंडपॉइंट (Ollama/vLLM)

***

## त्वरित प्रारम्भ

### विधि 1: Docker Compose (आधिकारिक — अनुशंसित)

SuperAGI की आधिकारिक तैनाती सभी सेवाओं का प्रबंधन करने के लिए Docker Compose का उपयोग करती है।

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

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

**चरण 2: क्लोन और कॉन्फ़िगर करें**

```bash
git clone https://github.com/TransformerOptimus/SuperAGI.git
cd SuperAGI
cp config_template.yaml config.yaml
```

**चरण 3: संपादित करें `config.yaml`**

```bash
nano config.yaml
```

न्यूनतम आवश्यक कॉन्फ़िगरेशन:

```yaml
# config.yaml
OPENAI_API_KEY: "sk-your-openai-key-here"

# डेटाबेस (Docker Compose के लिए डिफ़ॉल्ट पर छोड़ें)
POSTGRES_DB: "super_agi"
POSTGRES_USER: "super_agi"
POSTGRES_PASSWORD: "password"

# वेक्टर डेटाबेस
VECTOR_STORE: "Redis"  # या "Pinecone", "Qdrant", "Weaviate"
REDIS_URL: "redis://super__agi-redis-1:6379/0"

# ऐप सेटिंग्स
ENV: "PROD"
ALLOW_LISTS_CREATION: "true"

# वैकल्पिक: पहुँच प्रतिबंधित करें
# AUTH_SECRET_KEY: "your-random-secret"
```

**चरण 4: स्टैक शुरू करें**

```bash
docker compose up -d --build
```

बिल्ड प्रक्रिया डिपेंडेंसीज़ डाउनलोड करती है और फ्रंटएंड को कंपाइल करती है (पहली बार रन पर \~5–10 मिनट)।

**चरण 5: स्टार्टअप मॉनिटर करें**

```bash
# सभी सेवाओं को उठते हुए देखें
docker compose ps

# लॉग्स फॉलो करें
docker compose logs -f

# बैकएंड लॉग्स में "Application startup complete" का इंतजार करें
docker compose logs superagi-backend --tail 30
```

**चरण 6: डैशबोर्ड तक पहुँचें**

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

API उपलब्ध है:

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

API दस्तावेज़:

```
http://<your-clore-server-ip>:8001/docs
```

***

### विधि 2: प्री-बिल्ट इमेज के साथ क्विक स्टार्ट

बिल्ड चरण छोड़कर प्री-बिल्ट इमेज का उपयोग करके तेज़ स्टार्टअप के लिए:

```bash
git clone https://github.com/TransformerOptimus/SuperAGI.git
cd SuperAGI
cp config_template.yaml config.yaml

# अपनी API कुंजियों के साथ config संपादित करें
nano config.yaml

# यदि उपलब्ध हो तो प्री-बिल्ट इमेज का उपयोग करें
docker compose -f docker-compose.yaml pull
docker compose up -d
```

***

### विधि 3: न्यूनतम सिंगल-मॉडल सेटअप

केवल OpenAI के साथ परीक्षण के लिए एक सरलीकृत सेटअप:

```bash
git clone https://github.com/TransformerOptimus/SuperAGI.git
cd SuperAGI

# न्यूनतम कॉन्फ़िग बनाएं
cat > config.yaml << 'EOF'
OPENAI_API_KEY: "sk-your-key-here"
POSTGRES_DB: "super_agi"
POSTGRES_USER: "super_agi"
POSTGRES_PASSWORD: "superagi_password_123"
REDIS_URL: "redis://super__agi-redis-1:6379/0"
ENV: "PROD"
EOF

docker compose up -d --build

# बिल्ड प्रगति मॉनिटर करें
docker compose logs superagi-frontend --tail 5 -f &
docker compose logs superagi-backend --tail 5 -f
```

***

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

### `config.yaml` संदर्भ

```yaml
# ============================================================
# LLM Providers
# ============================================================
OPENAI_API_KEY: "sk-..."                    # OpenAI GPT मॉडेल
ANTHROPIC_API_KEY: "sk-ant-..."            # Claude मॉडेल

# स्थानीय मॉडलों के लिए (Ollama या OpenAI-संगत API)
# UI में सेट करें: Settings → Models → Custom Model
OPENAI_API_BASE: "http://172.17.0.1:11434/v1"  # उसी होस्ट पर Ollama
OPENAI_MODEL: "llama3.1:8b"

# ============================================================
# Database
# ============================================================
POSTGRES_DB: "super_agi"
POSTGRES_USER: "super_agi"
POSTGRES_PASSWORD: "your-strong-password"

# ============================================================
# वेक्टर डेटाबेस (एजेंट दीर्घकालिक मेमोरी)
# ============================================================
VECTOR_STORE: "Redis"       # Redis (डिफ़ॉल्ट, बिल्ट-इन)
# या बाहरी का उपयोग करें:
# VECTOR_STORE: "Pinecone"
# PINECONE_API_KEY: "your-key"
# PINECONE_ENVIRONMENT: "us-east-1-aws"

# VECTOR_STORE: "Weaviate"
# WEAVIATE_URL: "http://weaviate:8080"

# ============================================================
# टूल API कीज़ (वैकल्पिक, विशिष्ट टूल्स के लिए)
# ============================================================
GOOGLE_API_KEY: "your-google-key"
GOOGLE_CUSTOM_SEARCH_ENGINE_ID: "your-cx-id"
GITHUB_TOKEN: "ghp_your-token"
JIRA_EMAIL: "your@email.com"
JIRA_API_TOKEN: "your-jira-token"
JIRA_SERVER_URL: "https://your-org.atlassian.net"

# ============================================================
# स्टोरेज
# ============================================================
STORAGE_TYPE: "File"        # लोकल फाइल स्टोरेज
# STORAGE_TYPE: "S3"        # S3-संगत (MinIO, AWS)
# BUCKET_NAME: "superagi"
# AWS_ACCESS_KEY_ID: "..."
# AWS_SECRET_ACCESS_KEY: "..."

# ============================================================
# सुरक्षा
# ============================================================
JWT_SECRET_KEY: "your-random-secret-key"
```

### SuperAGI को टूल्स से कनेक्ट करना

टूल्स GUI के माध्यम से कॉन्फ़िगर किए जाते हैं: **Settings → Toolkit**। प्रत्येक टूल को प्रत्येक एजेंट के लिए सक्षम/अक्षम किया जा सकता है।

**बिल्ट-इन टूल्स:**

| टूल         | उद्देश्य                    | API कुंजी आवश्यक    |
| ----------- | --------------------------- | ------------------- |
| Google सर्च | वेब सर्च                    | हाँ (Google API)    |
| DuckDuckGo  | वेब सर्च                    | नहीं                |
| GitHub      | कोड रिपॉजिटरी एक्सेस        | हाँ (GitHub टोकन)   |
| ईमेल        | ईमेल भेजें/पढ़ें            | हाँ (SMTP कॉन्फ़िग) |
| कोड राइटर   | कोड लिखें और निष्पादित करें | नहीं                |
| फाइल मैनेजर | स्थानीय फाइलें पढ़ें/लिखें  | नहीं                |
| ब्राउज़र    | हेडलैस वेब ब्राउज़िंग       | नहीं                |
| Jira        | इशू ट्रैकिंग                | हां                 |
| Notion      | नॉलेज बेस                   | हां                 |
| इमेज जनरेशन | DALL-E 3, Stable Diffusion  | हाँ (OpenAI की)     |

### अपना पहला एजेंट बनाना

GUI के माध्यम से (Settings → Agents → Create Agent):

1. **नाम** — अपने एजेंट को एक वर्णनात्मक नाम दें
2. **विवरण** — यह एजेंट क्या करता है
3. **लक्ष्य** — उद्देश्य सूचीबद्ध करें (प्रत्येक पंक्ति में एक)
4. **निर्देश** — व्यवहार के लिए सिस्टम प्रॉम्प्ट
5. **मॉडल** — LLM चुनें (GPT-4, Claude, या स्थानीय)
6. **टूल्स** — संबंधित टूल्स सक्षम करें
7. **अधिकतम पुनरावृत्तियाँ** — सुरक्षा सीमा (सामान्यतः 10–50)

REST API के माध्यम से:

```bash
# API के माध्यम से एक एजेंट बनाएं
curl -X POST "http://localhost:8001/v1/agent" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Research Agent",
    "description": "Researches topics and writes summaries",
    "goal": [
      "Research the topic provided",
      "Write a comprehensive summary",
      "Save the summary to a file"
    ],
    "agent_type": "Task Queue",
    "constraints": [],
    "tools": ["DuckDuckGoSearch", "WriteFileTool", "ReadFileTool"],
    "exit_criterion": "No exit criterion",
    "max_iterations": 25,
    "user_timezone": "UTC",
    "llm_model_config": {
      "model_name": "gpt-4o-mini",
      "temperature": 0.5,
      "max_new_tokens": 2000
    }
  }'
```

***

## GPU त्वरक

SuperAGI किसी भी OpenAI-संगत एंडपॉइंट के माध्यम से स्थानीय LLM इन्फरेंस का समर्थन करता है, जिससे यह GPU-संपन्न Clore.ai तैनातियों के लिए आदर्श है।

### एजेंट LLM बैकएंड के रूप में Ollama सेट करना

देखें [Ollama गाइड](/guides/guides_v2-hi/language-models/ollama.md) पूर्ण Ollama सेटअप के लिए। SuperAGI के साथ इंटीग्रेशन:

**चरण 1: उसी Clore.ai सर्वर पर Ollama शुरू करें**

```bash
docker run -d \
  --name ollama \
  --gpus all \
  --restart unless-stopped \
  -p 11434:11434 \
  -v ollama_models:/root/.ollama \
  ollama/ollama

# एजेंट उपयोग के लिए सक्षम मॉडल खींचें (अच्छी तर्कशीलता चाहिए)
docker exec ollama ollama pull llama3.1:8b        # तेज़, अच्छी तर्कशीलता
docker exec ollama ollama pull mistral:7b-instruct  # कोड कार्यों के लिए
docker exec ollama ollama pull deepseek-coder:6.7b # कोड-भारित एजेंट्स के लिए
```

**चरण 2: SuperAGI को Ollama का उपयोग करने के लिए कॉन्फ़िगर करें**

में `config.yaml`:

```yaml
# Ollama की ओर पॉइंट करें (Docker होस्ट पर चल रहा है)
OPENAI_API_BASE: "http://172.17.0.1:11434/v1"
```

या SuperAGI UI में कॉन्फ़िगर करें:

* **Settings → Models → Add Custom Model**
* प्रदाता: OpenAI-संगत
* बेस URL: `http://172.17.0.1:11434/v1`
* API कुंजी: `ollama` (कोई भी स्ट्रिंग)
* मॉडल का नाम: `llama3.1:8b`

### उच्च-थ्रूपुट एजेंट्स के लिए vLLM सेटअप करना

कई समवर्ती एजेंटों के साथ प्रोडक्शन तैनातियों के लिए (देखें [vLLM गाइड](/guides/guides_v2-hi/language-models/vllm.md)):

```bash
# GPU सर्वर पर vLLM शुरू करें
docker run -d \
  --name vllm \
  --gpus all \
  --restart unless-stopped \
  -p 8000:8000 \
  -v hf_cache:/root/.cache/huggingface \
  -e HF_TOKEN=hf_your-token \
  vllm/vllm-openai:latest \
  --model mistralai/Mistral-7B-Instruct-v0.3 \
  --served-model-name mistral-7b \
  --max-model-len 8192 \
  --enable-prefix-caching

# config.yaml में:
# OPENAI_API_BASE: "http://172.17.0.1:8000/v1"
```

### एजेंट वर्कलोड्स के लिए GPU आकार निर्धारण

| उपयोग का मामला  | मॉडल                | GPU         | VRAM  | समवर्ती एजेंट        |
| --------------- | ------------------- | ----------- | ----- | -------------------- |
| परीक्षण         | GPT-4o-mini (API)   | कोई नहीं    | —     | असीमित (रेट-लिमिटेड) |
| लाइट एजेंट      | Llama 3.1 8B        | RTX 3090    | 8 GB  | 2–4                  |
| तर्कशीलता कार्य | Mistral 7B Instruct | RTX 3090    | 6 GB  | 3–5                  |
| जटिल एजेंट      | Llama 3.1 70B Q4    | 2× RTX 3090 | 48 GB | 1–2                  |
| उत्पादन         | Llama 3.1 70B FP16  | A100 80GB   | 80 GB | 3–6                  |

***

## टिप्स और सर्वोत्तम प्रथाएँ

### एजेंट डिज़ाइन

* **लक्ष्यों के साथ स्पष्ट रहें** — "अनुसंधान करो" जैसे अस्पष्ट लक्ष्य एजेंट्स को लूप में डाल सकते हैं। उपयोग करें "X का अनुसंधान करें और 500-शब्द का सारांश file output.txt में लिखें."
* **पुनरावृत्ति सीमाएँ सेट करें** — हमेशा सेट करें `max_iterations` (20–50)। असीमित एजेंट तेजी से टोकन खपत कर सकते हैं।
* **टास्क क्यू मोड का उपयोग करें** — बहु-चरण पाइपलाइनों के लिए, "Task Queue" एजेंट "Don't Limit" मोड की तुलना में अधिक विश्वसनीय होते हैं।
* **पहले सस्ते मॉडलों से परीक्षण करें** — महंगे मॉडलों का उपयोग करने से पहले GPT-4o-mini या स्थानीय 7B मॉडल के साथ एजेंट लॉजिक मान्य करें।

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

```bash
# SuperAGI डैशबोर्ड से रीयल-टाइम में टोकन उपयोग मॉनिटर करें
# Settings → Resources → Token Usage

# संगठन-स्तरीय सीमाएँ config.yaml में सेट करें
MAX_BUDGET_TOKENS: 100000  # प्रति सेशन सॉफ्ट लिमिट
```

चूंकि Clore.ai घंटे के हिसाब से शुल्क लेता है:

```bash
# इंस्टेंस बंद करने से पहले एजेंट कॉन्फ़िगरेशन सेव करें
docker compose exec superagi-backend \
  python -c "import json; from superagi.models import Agent; ..."

# PostgreSQL डेटाबेस का बैकअप
docker compose exec super__agi-db-1 \
  pg_dump -U super_agi super_agi | gzip > superagi-db-$(date +%Y%m%d).sql.gz

# बैकअप को सर्वर से बाहर कॉपी करें
scp -P <ssh-port> root@<server-ip>:~/SuperAGI/superagi-db-*.sql.gz ./
```

### SuperAGI की सुरक्षा

```bash
# config.yaml में प्रमाणीकरण सक्षम करें
AUTH_SECRET_KEY: "your-strong-random-secret"

# API को localhost तक सीमित करें (SSH टनल का उपयोग करें)
# external पोर्ट बाइंडिंग हटाने के लिए docker-compose.yml संशोधित करें:
# ports:
#   - "127.0.0.1:8001:8001"  # केवल स्थानीय API
#   - "127.0.0.1:3000:3000"  # केवल स्थानीय UI

# फिर SSH टनल के माध्यम से पहुंचें:
# ssh -L 3000:localhost:3000 -L 8001:localhost:8001 root@<server-ip> -p <port>
```

### Clore.ai सेशन्स के बीच स्थायी स्टोरेज

```bash
# पूर्ण बैकअप स्क्रिप्ट बनाएं
cat > /root/backup-superagi.sh << 'EOF'
#!/bin/bash
cd ~/SuperAGI

# डेटाबेस बैकअप
docker compose exec -T super__agi-db-1 \
  pg_dump -U super_agi super_agi | \
  gzip > ~/backups/superagi-db-$(date +%Y%m%d-%H%M).sql.gz

# कॉन्फ़िग और वर्कस्पेसेस का बैकअप
tar -czf ~/backups/superagi-files-$(date +%Y%m%d-%H%M).tar.gz \
  config.yaml \
  workspace/ \
  .env 2>/dev/null || true

echo "Backup complete: $(ls -lh ~/backups/ | tail -2)"
EOF

chmod +x /root/backup-superagi.sh
mkdir -p ~/backups
```

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

```bash
cd ~/SuperAGI

# वर्तमान कॉन्फ़िग सेव करें
cp config.yaml config.yaml.backup

# नवीनतम परिवर्तन पुल करें
git pull origin main

# पुनर्निर्माण और पुनःप्रारंभ करें
docker compose down
docker compose up -d --build

# सुनिश्चित करें कि सभी सेवाएँ स्वस्थ हैं
docker compose ps
docker compose logs superagi-backend --tail 20
```

***

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

### बिल्ड विफल हो जाता है दौरान `docker compose up --build`

```bash
# विस्तृत रूप से बिल्ड लॉग्स जाँचें
docker compose build superagi-backend --no-cache 2>&1 | tail -50

# सामान्य सुधार: डिस्क स्पेस खाली करें
docker system prune -f
df -h  # सुनिश्चित करें कम से कम 10 GB खाली हो

# यदि फ्रंटएंड के लिए npm बिल्ड विफल हो
docker compose build superagi-frontend --no-cache

# बिल्ड के दौरान Node.js मेमोरी जाँचें
docker compose build superagi-frontend \
  --build-arg NODE_OPTIONS="--max-old-space-size=4096"
```

### बैकएंड स्टार्टअप पर क्रैश होता है

```bash
# बैकएंड लॉग्स जाँचें
docker compose logs superagi-backend --tail 50

# सामान्य कारण:
# 1. Invalid config.yaml syntax
python3 -c "import yaml; yaml.safe_load(open('config.yaml'))" && echo "YAML OK"

# 2. डेटाबेस तैयार नहीं है
docker compose restart superagi-backend  # पहले DB के शुरू होने का इंतजार करें

# 3. API कुंजी गायब है
grep OPENAI_API_KEY config.yaml  # सुनिश्चित करें यह सेट है और खाली नहीं है
```

### फ्रंटएंड लोड नहीं हो रहा (पोर्ट 3000)

```bash
# फ्रंटएंड कंटेनर जाँचें
docker compose ps superagi-frontend
docker compose logs superagi-frontend --tail 30

# पोर्ट मैपिंग सत्यापित करें
ss -tlnp | grep 3000

# जाँचें कि फ्रंटएंड से API बैकएंड पहुँचा जा सकता है
docker compose exec superagi-frontend \
  curl -s http://superagi-backend:8001/health
```

### एजेंट अनंत रूप से लूप करते हैं

```bash
# SuperAGI UI में एजेंट लॉग्स जाँचें:
# Dashboard → Agent → View Logs

# API के माध्यम से चल रहे एजेंट को फोर्स-स्टॉप करें
curl -X POST "http://localhost:8001/v1/agent/<agent-id>/stop" \
  -H "Content-Type: application/json"

# या DB के माध्यम से सभी एजेंट रोकें
docker compose exec super__agi-db-1 \
  psql -U super_agi -c "UPDATE agent_executions SET status='COMPLETED' WHERE status='RUNNING';"
```

### Redis कनेक्शन त्रुटियाँ

```bash
# Redis स्थिति जाँचें
docker compose ps super__agi-redis-1
docker compose logs super__agi-redis-1

# Redis कनेक्शन का परीक्षण करें
docker compose exec superagi-backend \
  python3 -c "import redis; r=redis.from_url('redis://super__agi-redis-1:6379/0'); print(r.ping())"

# Redis पुनरारंभ करें
docker compose restart super__agi-redis-1
```

### Ollama SuperAGI कंटेनर से पहुँच योग्य नहीं

```bash
# Docker ब्रिज IP खोजें
docker network inspect bridge | grep Gateway

# बैकएंड कंटेनर से परीक्षण करें
docker compose exec superagi-backend \
  curl -s http://172.17.0.1:11434/v1/models

# यदि होस्ट नेटवर्किंग का उपयोग कर रहे हैं
docker run -d --network host ...  #docker compose के साथ आसानी से संगत नहीं

# विकल्प: Ollama को उसी compose नेटवर्क में जोड़ें
# docker-compose.yml में सेवाओं के अंतर्गत जोड़ें:
# ollama:
#   image: ollama/ollama
#   deploy:
#     resources:
#       reservations:
#         devices:
#           - driver: nvidia
#             count: all
#             capabilities: [gpu]
```

### डेटाबेस कनेक्शन पूल समाप्त

```bash
# docker-compose.yml में PostgreSQL अधिकतम कनेक्शन बढ़ाएँ
# db सर्विस के अंतर्गत:
command: postgres -c max_connections=200

# डेटाबेस पुनरारंभ करें
docker compose restart super__agi-db-1
docker compose restart superagi-backend
```

***

## अधिक पढ़ने के लिए

* [SuperAGI दस्तावेज़ीकरण](https://superagi.com/docs) — आधिकारिक गाइड्स, API संदर्भ
* [SuperAGI GitHub](https://github.com/TransformerOptimus/SuperAGI) — स्रोत कोड, इशूज़, समुदाय
* [Clore.ai पर Ollama चलाना](/guides/guides_v2-hi/language-models/ollama.md) — एजेंट्स के लिए स्थानीय LLM बैकएंड
* [Clore.ai पर vLLM चलाना](/guides/guides_v2-hi/language-models/vllm.md) — समवर्ती एजेंट्स के लिए उच्च-थ्रूपुट इन्फरेंस
* [GPU तुलना मार्गदर्शिका](/guides/guides_v2-hi/getting-started/gpu-comparison.md) — सही Clore.ai टियर चुनना
* [SuperAGI टूल मार्केटप्लेस](https://superagi.com/marketplace/) — समुदाय-निर्मित एजेंट टूल्स
* [SuperAGI Discord](https://discord.gg/dXbRe5BHJC) — समुदाय समर्थन और चर्चा
* [FastAPI Docs (SuperAGI API)](http://localhost:8001/docs) — आपकी इंस्टेंस पर इंटरैक्टिव 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/superagi.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.