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

# SuperAGI एजेंट फ़्रेमवर्क

Clore.ai पर SuperAGI डिप्लॉय करें — GUI डैशबोर्ड, टूल मार्केटप्लेस, concurrent एजेंट, और शक्तिशाली GPU क्लाउड सर्वरों पर वैकल्पिक लोकल LLM सपोर्ट के साथ एक डेवलपर-प्रथम स्वायत्त AI एजेंट फ़्रेमवर्क।

## अवलोकन

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

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

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

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

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

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

```
┌────────────────────────────────────────────────────┐
│              SuperAGI स्टैक                        │
│                                                    │
│  ┌─────────────────────┐   ┌───────────────────┐   │
│  │  फ्रंटएंड (पोर्ट 3000)│   │  API (पोर्ट 8001) │   │
│  │   Next.js UI         │   │  FastAPI बैकएंड   │   │
│  └──────────┬──────────┘   └─────────┬─────────┘   │
│             └──────────┬─────────────┘             │
│                        ▼                           │
│  ┌─────────────────────────────────────────────┐   │
│  │              एजेंट निष्पादक                 │   │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  │   │
│  │  │  एजेंट 1  │  │  एजेंट 2  │  │  एजेंट N  │  │   │
│  │  └──────────┘  └──────────┘  └──────────┘  │   │
│  └───────┬─────────────┬─────────────┬─────────┘   │
│          ▼             ▼             ▼             │
│  ┌───────────┐  ┌───────────┐  ┌───────────┐      │
│  │ PostgreSQL │  │  Redis    │  │  वेक्टर   │      │
│  │  (स्थिति)  │  │  (कतार)   │  │    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.07–0.21/hr                             | SuperAGI + Ollama 13B स्थानीय मॉडल      |
| RTX 4090 (24 GB)    | $0.14–0.42/hr                             | SuperAGI + Ollama, तेज़ इन्फ़रेंस       |
| 2× RTX 3090         | $0.14–0.42/hr                             | SuperAGI + 70B मॉडल (Q4 क्वांटाइज़्ड)   |
| A100 80 GB          | [bare metal](https://clore.ai/bare-metal) | SuperAGI + बड़े मॉडल, उच्च समवर्तीता    |
| H100 80 GB          | \~$1.04/घंटा                              | प्रोडक्शन-ग्रेड स्वायत्त एजेंट सिस्टम   |

> 💡 **लागत सुझाव:** विकास और परीक्षण के लिए, OpenAI या Anthropic APIs का उपयोग करें (GPU की आवश्यकता नहीं)। केवल तब GPU instance पर जाएँ जब आपको गोपनीयता या लागत कारणों से स्थानीय LLM इन्फ़रेंस की आवश्यकता हो। देखें [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

# न्यूनतम config बनाएँ
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 प्रदाता
# ============================================================
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"

# ============================================================
# डेटाबेस
# ============================================================
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 token)      |
| ईमेल          | ईमेल भेजें/पढ़ें            | हाँ (SMTP कॉन्फ़िगरेशन) |
| कोड लेखक      | कोड लिखें और निष्पादित करें | नहीं                    |
| फ़ाइल प्रबंधक | स्थानीय फ़ाइलें पढ़ें/लिखें | नहीं                    |
| ब्राउज़र      | हेडलेस वेब ब्राउज़िंग       | नहीं                    |
| Jira          | इश्यू ट्रैकिंग              | हाँ                     |
| Notion        | ज्ञान आधार                  | हाँ                     |
| छवि निर्माण   | DALL-E 3, Stable Diffusion  | हाँ (OpenAI key)        |

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

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": "अनुसंधान एजेंट",
    "description": "विषयों पर शोध करता है और सारांश लिखता है",
    "goal": [
      "प्रदान किए गए विषय पर शोध करें",
      "एक व्यापक सारांश लिखें",
      "सारांश को एक फ़ाइल में सहेजें"
    ],
    "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**
* Provider: OpenAI-compatible
* Base URL: `http://172.17.0.1:11434/v1`
* API Key: `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               |

***

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

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

* **लक्ष्यों के साथ विशिष्ट रहें** — "do research" जैसे अस्पष्ट लक्ष्य एजेंटों को लूप में फँसा देते हैं। "Research X and write a 500-word summary to 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
# instance रोकने से पहले एजेंट कॉन्फ़िगरेशन सहेजें
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 टनल का उपयोग करें)
# बाहरी पोर्ट बाइंडिंग हटाने के लिए 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 "बैकअप पूरा हुआ: $(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 build विफल हो
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. config.yaml का गलत सिंटैक्स
python3 -c "import yaml; yaml.safe_load(open('config.yaml'))" && echo "YAML OK"

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

# 3. API key गायब है
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 में एजेंट लॉग्स जाँचें:
# डैशबोर्ड → एजेंट → लॉग्स देखें

# 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
```

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

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

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

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

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

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

```bash
# docker-compose.yml में PostgreSQL max connections बढ़ाएँ
# 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) — स्रोत कोड, issues, समुदाय
* [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/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.
