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

# MetaGPT सॉफ़्टवेयर कंपनी

Clore.ai पर MetaGPT डिप्लॉय करें — किफ़ायती GPU क्लाउड सर्वरों पर पूरी तरह स्वायत्त बहु-एजेंट AI सॉफ़्टवेयर कंपनी चलाएँ ताकि एक सिंग

## अवलोकन

[MetaGPT](https://github.com/geekan/MetaGPT) एक बहु-एजेंट AI फ्रेमवर्क है जो एक **सॉफ्टवेयर कंपनी** — जिसमें एक Product Manager, Architect, Engineer, और QA Engineer एजेंट शामिल हैं — जो सभी मिलकर एक-पंक्ति के विचार को पूरी तरह कार्यात्मक सॉफ्टवेयर प्रोजेक्ट में बदलते हैं। 45K+ GitHub स्टार्स के साथ, MetaGPT AI-संचालित सॉफ्टवेयर विकास के सबसे नवोन्मेषी दृष्टिकोणों में से एक है।

एक अकेले कोडिंग एजेंट के विपरीत, MetaGPT वास्तविक टीम वर्कफ़्लो की नकल करता है। जब आप इसे "Build a Snake game in Python" जैसा कोई कार्य देते हैं, तो यह:

1. **प्रोडक्ट मैनेजर** — एक Product Requirements Document (PRD) लिखता है
2. **आर्किटेक्ट** — सिस्टम आर्किटेक्चर और टेक स्टैक डिज़ाइन करता है
3. **प्रोजेक्ट मैनेजर** — कार्यों को विभाजित करता है और उन्हें असाइन करता है
4. **इंजीनियर** — प्रत्येक घटक के लिए वास्तविक कार्यशील कोड लिखते हैं
5. **QA इंजीनियर** — यूनिट टेस्ट लिखता है और इम्प्लीमेंटेशन को सत्यापित करता है

परिणाम एक पूर्ण प्रोजेक्ट डायरेक्टरी होती है जिसमें कोड, दस्तावेज़, और टेस्ट होते हैं — जो स्वायत्त रूप से जनरेट होते हैं।

**मुख्य क्षमताएँ:**

* **पूर्ण सॉफ्टवेयर जीवनचक्र** — आवश्यकताओं से लेकर एक ही कमांड में कार्यशील कोड तक
* **भूमिका-आधारित एजेंट** — विशिष्ट जिम्मेदारियों वाले विशेषीकृत एजेंट
* **दस्तावेज़ निर्माण** — PRD, सिस्टम डिज़ाइन, API स्पेक्स स्वतः बनाता है
* **बहु-भाषा समर्थन** — Python, Node.js, Go, और भी बहुत कुछ
* **डेटा इंटरप्रेटर** — स्वायत्त डेटा विश्लेषण और विज़ुअलाइज़ेशन एजेंट
* **क्रमिक विकास** — मौजूदा प्रोजेक्ट्स में फीचर्स जोड़ें
* **मानव इंटरैक्शन मोड** — प्रमुख चरणों पर मानव समीक्षा के लिए रोकें

**MetaGPT के लिए Clore.ai क्यों?**

MetaGPT स्वयं CPU-आधारित है, लेकिन Clore.ai कुछ महत्वपूर्ण लाभ देता है:

* **लंबे समय तक चलने वाले कार्य** — MetaGPT जनरेशन में 10–60 मिनट लग सकते हैं; डेडिकेटेड सर्वर टाइमआउट के बिना इसे संभालते हैं
* **लोकल LLM बैकएंड** — बड़े प्रोजेक्ट्स के लिए प्रति-टोकन API लागत हटाने हेतु Ollama या vLLM का उपयोग करें
* **लागत नियंत्रण** — $0.20–0.35/घंटा पर, GPT-4o API कॉल्स की तुलना में व्यापक MetaGPT सत्र सस्ते में चलाएँ
* **अलग-थलग वातावरण** — जनरेट किया गया कोड नियंत्रित सर्वर वातावरण में चलता है
* **टीम सहयोग** — विकास टीम के साथ एक MetaGPT सर्वर एंडपॉइंट साझा करें

***

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

MetaGPT LLM API कॉल्स को ऑर्केस्ट्रेट करता है — GPU केवल तब चाहिए जब आप लोकल LLM बैकएंड चलाते हैं।

| कॉन्फ़िगरेशन                       | GPU       | VRAM  | RAM   | स्टोरेज | अनुमानित कीमत                             |
| ---------------------------------- | --------- | ----- | ----- | ------- | ----------------------------------------- |
| **MetaGPT + OpenAI/Anthropic API** | कोई नहीं  | —     | 4 GB  | 20 GB   | \~$0.03–0.08/घंटा                         |
| **+ Ollama (Qwen2.5-Coder 7B)**    | RTX 3090  | 24 GB | 16 GB | 40 GB   | $0.07–0.21/hr                             |
| **+ Ollama (DeepSeek Coder 33B)**  | RTX 4090  | 24 GB | 32 GB | 60 GB   | $0.14–0.42/hr                             |
| **+ vLLM (Qwen2.5-Coder 32B)**     | RTX 4090  | 24 GB | 32 GB | 80 GB   | $0.14–0.42/hr                             |
| **+ vLLM (Llama 3.1 70B)**         | A100 80GB | 80 GB | 64 GB | 100 GB  | [bare metal](https://clore.ai/bare-metal) |

> **सिफारिश:** सुसंगत बहु-चरणीय तर्क के लिए MetaGPT मॉडल की गुणवत्ता पर बहुत अधिक निर्भर करता है। जटिल प्रोजेक्ट्स के लिए GPT-4o या Claude Sonnet 3.5 APIs का उपयोग करें, या लोकली Qwen2.5-Coder-32B / DeepSeek-Coder-V2। देखें [GPU तुलना गाइड](/guides/guides_v2-hi/getting-started/gpu-comparison.md).

**Clore.ai सर्वर पर सॉफ्टवेयर आवश्यकताएँ:**

* Docker Engine (सभी Clore.ai इमेजेज़ पर पहले से इंस्टॉल)
* NVIDIA Container Toolkit (केवल लोकल LLM विकल्प के लिए)
* 20+ GB खाली डिस्क स्पेस (MetaGPT इमेज + जनरेट की गई प्रोजेक्ट फ़ाइलें)
* आउटबाउंड इंटरनेट एक्सेस (Docker इमेज खींचने और LLM APIs तक पहुँचने के लिए)

***

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

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

पर एक सर्वर बुक करें [Clore.ai मार्केटप्लेस](https://clore.ai):

* केवल API के लिए: ≥4 GB RAM वाला कोई भी सर्वर
* लोकल LLM के लिए: ≥24 GB VRAM वाला GPU

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

### चरण 2: MetaGPT Docker इमेज खींचें

```bash
docker pull metagpt/metagpt:latest
```

> MetaGPT इमेज लगभग \~3 GB की है। पहली बार खींचने में इसमें 2–5 मिनट लग सकते हैं।

### चरण 3: कॉन्फ़िगरेशन सेट करें

MetaGPT को आपके LLM API क्रेडेंशियल्स वाली एक YAML कॉन्फ़िगरेशन फ़ाइल की आवश्यकता होती है:

```bash
# डायरेक्टरी बनाएं
mkdir -p /opt/metagpt/{config,workspace}

# इमेज से डिफ़ॉल्ट कॉन्फ़िग टेम्पलेट निकालें
docker run --rm metagpt/metagpt:latest \\
  cat /app/metagpt/config/config2.yaml \\
  > /opt/metagpt/config/config2.yaml

# कॉन्फ़िग देखें
cat /opt/metagpt/config/config2.yaml
```

### चरण 4: अपने LLM प्रदाता को कॉन्फ़िगर करें

कॉन्फ़िगरेशन फ़ाइल संपादित करें:

```bash
nano /opt/metagpt/config/config2.yaml
```

**OpenAI (GPT-4o) के लिए:**

```yaml
llm:
  api_type: "openai"
  model: "gpt-4o"
  base_url: "https://api.openai.com/v1"
  api_key: "sk-your-openai-key-here"

repair_llm_output: true
max_auto_summarize_code: 1
```

**Anthropic (Claude) के लिए:**

```yaml
llm:
  api_type: "anthropic"
  model: "claude-3-5-sonnet-20241022"
  api_key: "sk-ant-your-key-here"

repair_llm_output: true
```

**लोकल Ollama के लिए (GPU सेक्शन देखें):**

```yaml
llm:
  api_type: "ollama"
  model: "ollama/qwen2.5-coder:32b"
  base_url: "http://host.docker.internal:11434"
  api_key: "ollama"

repair_llm_output: true
```

### चरण 5: अपना पहला MetaGPT प्रोजेक्ट चलाएँ

```bash
# एक Snake game जनरेट करें (क्लासिक डेमो)
docker run --rm --privileged \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  metagpt/metagpt:latest \\
  metagpt "Python में एक snake game बनाएं"
```

एजेंट्स के काम को देखें: आपको क्रम से PRD जनरेशन, सिस्टम डिज़ाइन, कोड लेखन, और परीक्षण दिखाई देगा। अपने LLM के अनुसार 5–15 मिनट की अपेक्षा करें।

### चरण 6: आउटपुट देखें

```bash
ls -la /opt/metagpt/workspace/
# आपको अपने प्रोजेक्ट के नाम वाली एक डायरेक्टरी दिखाई देगी

find /opt/metagpt/workspace -type f | head -30
# सभी जनरेट की गई फ़ाइलें सूचीबद्ध करता है: .py, .md, requirements.txt, tests/
```

***

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

### पूर्ण कॉन्फ़िगरेशन संदर्भ

```yaml
# /opt/metagpt/config/config2.yaml

# प्राथमिक LLM कॉन्फ़िगरेशन
llm:
  api_type: "openai"          # openai | anthropic | ollama | azure | gemini
  model: "gpt-4o"
  base_url: "https://api.openai.com/v1"
  api_key: "your-api-key"
  temperature: 0.0            # कम = अधिक नियतात्मक कोड जनरेशन
  max_token: 4096

# MetaGPT व्यवहार सेटिंग्स
repair_llm_output: true       # गलत LLM प्रतिक्रियाओं को स्वतः ठीक करें
max_auto_summarize_code: 1    # कोड सारांश पुनरावृत्तियाँ (0 = निष्क्रिय)
max_project_auto_run: 5       # अधिकतम ऑटो-एक्ज़ीक्यूशन चक्र

# प्रोजेक्ट सेटिंग्स
project_name: ""              # वैकल्पिक: जनरेट किए गए प्रोजेक्ट नाम को ओवरराइड करें
inc: false                    # क्रमिक मोड (मौजूदा प्रोजेक्ट में जोड़ें)
reqa_file: ""                 # किसी विशिष्ट फ़ाइल पर QA चलाएँ

# लागत ट्रैकिंग
max_budget: 10.0              # अधिकतम $ खर्च (केवल API कॉल्स)
```

### इंटरैक्टिव मोड में चलाना

अधिक नियंत्रण के लिए, मानव समीक्षा चेकपॉइंट्स के साथ MetaGPT चलाएँ:

```bash
docker run --rm -it --privileged \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  metagpt/metagpt:latest \\
  metagpt "FastAPI के साथ todo list ऐप के लिए एक REST API बनाएं" \\
  --human-review
```

के साथ `--human-review`, MetaGPT PRD और सिस्टम डिज़ाइन चरणों के बाद रुकता है, जिससे इंजीनियरिंग शुरू होने से पहले आप प्रतिक्रिया दे सकते हैं।

### क्रमिक विकास (मौजूदा प्रोजेक्ट में जोड़ें)

```bash
# मौजूदा प्रोजेक्ट पर विकास जारी रखें
docker run --rm -it --privileged \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  -v /opt/metagpt/workspace/my-project:/app/metagpt/workspace/my-project \\
  metagpt/metagpt:latest \\
  metagpt "मौजूदा todo API में उपयोगकर्ता प्रमाणीकरण जोड़ें" \\
  --project-path /app/metagpt/workspace/my-project \\
  --inc
```

### डेटा इंटरप्रेटर चलाना

MetaGPT में डेटा विश्लेषण के लिए एक विशेषीकृत Data Interpreter एजेंट शामिल है:

```bash
# इंटरैक्टिव Python डेटा विश्लेषण
docker run --rm -it --privileged \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  -v /path/to/your/data:/data:ro \\
  metagpt/metagpt:latest \\
  python -m metagpt.roles.di.data_interpreter \\
    "/data/sales.csv का विश्लेषण करें और सबसे बेहतर प्रदर्शन करने वाले उत्पाद खोजें, विज़ुअलाइज़ेशन बनाएं"
```

### स्थायी सेटअप के लिए Docker Compose

```yaml
# /opt/metagpt/docker-compose.yml
version: "3.9"

services:
  metagpt:
    image: metagpt/metagpt:latest
    privileged: true
    volumes:
      - /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml:ro
      - /opt/metagpt/workspace:/app/metagpt/workspace
      - /opt/metagpt/logs:/app/metagpt/logs
    environment:
      - PYTHONUNBUFFERED=1
    stdin_open: true
    tty: true
    # नोट: MetaGPT कार्य-आधारित है, कोई स्थायी सेवा नहीं।
    # निष्पादन के लिए 'docker compose run metagpt metagpt "your task"' का उपयोग करें
    entrypoint: ["bash"]
```

```bash
# docker-compose के माध्यम से एक कार्य चलाएँ
docker compose -f /opt/metagpt/docker-compose.yml \\
  run --rm metagpt \\
  metagpt "उपयोगकर्ता पंजीकरण के साथ एक Flask वेब ऐप बनाएं"
```

***

## GPU एक्सेलेरेशन (लोकल LLM इंटीग्रेशन)

### MetaGPT + Ollama

स्थानीय कोडिंग मॉडल का उपयोग करके MetaGPT पूरी तरह मुफ्त चलाएँ (कोई API लागत नहीं):

```bash
# चरण 1: GPU के साथ Ollama शुरू करें
docker run -d \\
  --name ollama \
  --gpus all \\
  --restart unless-stopped \\
  -p 11434:11434 \
  -v ollama-models:/root/.ollama \
  ollama/ollama:latest

# चरण 2: एक उच्च-गुणवत्ता वाला कोडिंग मॉडल खींचें
# RTX 3090/4090 (24 GB VRAM) के लिए:
docker exec ollama ollama pull qwen2.5-coder:32b      # कोड के लिए सर्वोत्तम
docker exec ollama ollama pull deepseek-coder-v2:16b  # विकल्प
# छोटे GPU (8–16 GB VRAM) के लिए:
docker exec ollama ollama pull qwen2.5-coder:7b
docker exec ollama ollama pull codellama:13b

# चरण 3: Ollama के लिए MetaGPT कॉन्फ़िगर करें
cat > /opt/metagpt/config/config2.yaml << 'EOF'
llm:
  api_type: "ollama"
  model: "ollama/qwen2.5-coder:32b"
  base_url: "http://host.docker.internal:11434"
  api_key: "ollama"
  temperature: 0.0
  max_token: 4096

repair_llm_output: true
max_auto_summarize_code: 0
EOF

# चरण 4: Ollama एक्सेस के लिए host नेटवर्क के साथ MetaGPT चलाएँ
docker run --rm --privileged \\
  --add-host host.docker.internal:host-gateway \
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  metagpt/metagpt:latest \\
  metagpt "फ़ाइल संगठन के लिए एक Python CLI टूल बनाएं"
```

> पूरा [Ollama गाइड](/guides/guides_v2-hi/language-models/ollama.md) मॉडल सेटअप और GPU अनुकूलन के लिए।

### MetaGPT + vLLM (उच्च थ्रूपुट)

बड़े, जटिल प्रोजेक्ट्स पर अधिकतम टोकन थ्रूपुट के लिए:

```bash
# चरण 1: एक कोडिंग मॉडल के साथ vLLM शुरू करें
docker run -d \\
  --name vllm \\
  --gpus all \\
  --restart unless-stopped \\
  -p 8000:8000 \
  --ipc=host \\
  vllm/vllm-openai:latest \
  --model Qwen/Qwen2.5-Coder-32B-Instruct \
  --max-model-len 32768 \\
  --gpu-memory-utilization 0.90

# मॉडल लोड होने की प्रतीक्षा करें
until curl -s http://localhost:8000/health | grep -q ok; do
  echo "vLLM की प्रतीक्षा कर रहे हैं..."; sleep 10
done

# चरण 2: vLLM के लिए MetaGPT कॉन्फ़िगर करें
cat > /opt/metagpt/config/config2.yaml << 'EOF'
llm:
  api_type: "openai"
  model: "Qwen/Qwen2.5-Coder-32B-Instruct"
  base_url: "http://host.docker.internal:8000/v1"
  api_key: "none"
  temperature: 0.0
  max_token: 8192

repair_llm_output: true
EOF

# चरण 3: MetaGPT चलाएँ
docker run --rm --privileged \\
  --add-host host.docker.internal:host-gateway \
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  metagpt/metagpt:latest \\
  metagpt "FastAPI और PostgreSQL के साथ एक पूर्ण ई-कॉमर्स बैकएंड बनाएं"
```

> देखें [vLLM गाइड](/guides/guides_v2-hi/language-models/vllm.md) क्वांटाइज़ेशन विकल्पों और मल्टी-GPU सेटअप्स के लिए।

### कार्य के अनुसार अनुशंसित मॉडल

| कार्य प्रकार      | मॉडल                           | न्यूनतम VRAM | नोट्स                         |
| ----------------- | ------------------------------ | ------------ | ----------------------------- |
| सरल स्क्रिप्ट्स   | `qwen2.5-coder:7b`             | 8 GB         | तेज़, CLI टूल्स के लिए अच्छा  |
| मध्यम प्रोजेक्ट्स | `qwen2.5-coder:14b`            | 12 GB        | अच्छा संतुलन                  |
| जटिल सिस्टम्स     | `qwen2.5-coder:32b`            | 24 GB        | सर्वोत्तम लोकल विकल्प         |
| बड़े कोडबेस       | `gpt-4o` / `claude-3-5-sonnet` | API          | जटिल PRD के लिए सबसे भरोसेमंद |

> **सुझाव:** लोकल मॉडल कोड जनरेशन के लिए अच्छी तरह काम करते हैं, लेकिन कभी-कभी जटिल आर्किटेक्चरल तर्क में संघर्ष करते हैं। प्रोडक्शन-गुणवत्ता वाले PRD और सिस्टम डिज़ाइनों के लिए, योजना चरण के लिए GPT-4o या Claude का उपयोग करने पर विचार करें और कोड जनरेशन के लिए स्थानीय मॉडल का।

***

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

### 1. प्रभावी टास्क प्रॉम्प्ट लिखें

MetaGPT का प्रदर्शन आपके प्रारंभिक प्रॉम्प्ट की गुणवत्ता पर बहुत निर्भर करता है:

```
✅ अच्छे प्रॉम्प्ट्स:
"FastAPI का उपयोग करके एक Python REST API बनाएं जो एक लाइब्रेरी कैटलॉग को प्रबंधित करे.
विशेषताएँ: किताबें जोड़ना/खोजना/हटाना, JWT के साथ उपयोगकर्ता प्रमाणीकरण, 
SQLite डेटाबेस, OpenAPI दस्तावेज़। लक्ष्य: टेस्ट्स के साथ प्रोडक्शन-रेडी।"

"Python में एक CLI डेटा पाइपलाइन टूल बनाएं जो CSV फ़ाइलें पढ़े,
सांख्यिकीय विश्लेषण करे, और matplotlib का उपयोग करके चार्ट आउटपुट करे."

❌ अस्पष्ट प्रॉम्प्ट्स:
"एक वेब ऐप बनाएं"
"Python के साथ कुछ बनाएं"
```

### 2. चलाने से पहले API लागत का अनुमान लगाएँ

```bash
# MetaGPT प्रति प्रोजेक्ट कई टोकन प्रोसेस करता है:
# - सरल स्क्रिप्ट: ~50K टोकन (~$0.25 GPT-4o के साथ)
# - मध्यम वेबऐप: ~200K टोकन (~$1.00 GPT-4o के साथ)
# - जटिल सिस्टम: ~500K+ टोकन (~$2.50+ GPT-4o के साथ)

# कॉन्फ़िग में बजट सीमा सेट करें:
# max_budget: 2.0  # $2 खर्च होने के बाद रोकें
```

### 3. पहले जनरेटेड PRD की समीक्षा करें

उपयोग करें `--human-review` महत्वपूर्ण प्रोजेक्ट्स के लिए। PRD चरण वह है जहाँ आवश्यकताएँ लॉक की जाती हैं — यहाँ समस्याएँ पकड़ना, कोड जनरेशन के बाद संशोधन करने की तुलना में काफी टोकन लागत बचाता है।

### 4. जनरेटेड कोड का परीक्षण करें

MetaGPT यूनिट टेस्ट जनरेट करता है, लेकिन हमेशा सत्यापित करें:

```bash
# जनरेट किए गए प्रोजेक्ट पर जाएँ
cd /opt/metagpt/workspace/<your-project>

# निर्भरताएँ इंस्टॉल करें
pip install -r requirements.txt

# जनरेट किए गए टेस्ट चलाएँ
pytest tests/ -v

# मुख्य एप्लिकेशन चलाने की कोशिश करें
python main.py
```

### 5. वर्शन नियंत्रण का उपयोग करें

```bash
# workspace में git प्रारंभ करें
cd /opt/metagpt/workspace
git init
git add .
git commit -m "प्रारंभिक MetaGPT जनरेशन"

# प्रत्येक पुनरावृत्ति के बाद
git add .
git commit -m "MetaGPT: प्रमाणीकरण फीचर जोड़ा"
```

### 6. कई प्रोजेक्ट्स को बैच में चलाएँ

अधिकतम मूल्य के लिए Clore.ai पर रात भर कई प्रोजेक्ट्स चलाएँ:

```bash
#!/bin/bash
# /opt/metagpt/batch-run.sh
PROJECTS=(
  "Python और Redis के साथ एक URL shortener सेवा बनाएं"
  "Markdown से PDF कन्वर्टर CLI टूल बनाएं"
  "टिप्पणियों और टैग्स के साथ एक ब्लॉग के लिए REST API बनाएं"
)

for project in "${PROJECTS[@]}"; do
  echo "शुरू कर रहे हैं: $project"
  docker run --rm --privileged \\
    -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
    -v /opt/metagpt/workspace:/app/metagpt/workspace \\
    metagpt/metagpt:latest \\
    metagpt "$project"
  echo "पूर्ण हुआ: $project"
done
```

***

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

### इमेज पुल विफल

```bash
# यदि Docker Hub rate limit लग जाए
docker login  # अपने Docker Hub खाते से लॉग इन करें
docker pull metagpt/metagpt:latest

# उपलब्ध डिस्क स्पेस जाँचें
df -h
# MetaGPT इमेज ~3 GB की है; workspace कई GB तक बढ़ सकता है
```

### कॉन्फ़िग फ़ाइल नहीं मिली

```bash
# सत्यापित करें कि path mapping सही है
docker run --rm \
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  metagpt/metagpt:latest \\
  ls -la /app/metagpt/config/

# यह भी सत्यापित करें कि आपका YAML वैध है
python3 -c "import yaml; yaml.safe_load(open('/opt/metagpt/config/config2.yaml'))"
```

### LLM API प्रमाणीकरण त्रुटि

```bash
# अपनी API key को स्वतंत्र रूप से परीक्षण करें
curl https://api.openai.com/v1/models \\
  -H "Authorization: Bearer sk-your-key"

# Anthropic के लिए:
curl https://api.anthropic.com/v1/models \\
  -H "x-api-key: sk-ant-your-key" \\
  -H "anthropic-version: 2023-06-01"

# सामान्य समस्याएँ:
# - अतिरिक्त whitespace के साथ key कॉपी की गई
# - key समाप्त हो गई या quota पार हो गई
# - कॉन्फ़िग में गलत api_type (जैसे, "openai" बनाम "anthropic")
```

### कंटेनर से Ollama कनेक्शन अस्वीकार

```bash
# सत्यापित करें कि Ollama चल रहा है
docker ps | grep ollama
curl http://localhost:11434/api/tags

# MetaGPT कंटेनर के दृष्टिकोण से परीक्षण करें
docker run --rm \
  --add-host host.docker.internal:host-gateway \
  metagpt/metagpt:latest \\
  curl http://host.docker.internal:11434/api/tags

# अगर फिर भी विफल हो, तो Ollama logs जाँचें
docker logs ollama --tail 20
```

### जनरेशन अटक जाती है या timeout हो जाता है

```bash
# जाँचें कि LLM वास्तव में प्रतिक्रिया दे रहा है या नहीं
# देखें कि कौन सा agent अटका है, इसके लिए debug logging जोड़ें
docker run --rm --privileged \\
  -e PYTHONUNBUFFERED=1 \\
  -v /opt/metagpt/config/config2.yaml:/app/metagpt/config/config2.yaml \\
  -v /opt/metagpt/workspace:/app/metagpt/workspace \\
  metagpt/metagpt:latest \\
  metagpt "Simple task" 2>&1 | tee /opt/metagpt/logs/debug.log

# सामान्य कारण:
# - लोकल मॉडल बहुत धीमा है (छोटा quantized model आज़माएँ)
# - API rate limiting (देरी जोड़ें या tier बदलें)
# - मॉडल context window पार हो गई (max_auto_summarize_code कम करें)
```

### डिस्क स्पेस समाप्त

```bash
# जनरेट किए गए प्रोजेक्ट बड़े हो सकते हैं; पुराने प्रोजेक्ट साफ़ करें
du -sh /opt/metagpt/workspace/*
rm -rf /opt/metagpt/workspace/old-project/

# Docker build cache भी साफ़ करें
docker system prune -f

# कुल उपयोग जाँचें
df -h /opt/metagpt/
```

### "Repair LLM Output" लूप्स

```bash
# यदि गलत LLM आउटपुट के कारण MetaGPT बार-बार पुनः प्रयास करता है:
# 1. अधिक सक्षम मॉडल आज़माएँ (GPT-4o, Claude Sonnet)
# 2. temperature कम करें (निश्चितता के लिए 0.0 सेट करें)
# 3. repair निष्क्रिय करें (यदि सक्षम मॉडल उपयोग कर रहे हैं):
#    repair_llm_output: false
```

***

## अधिक पढ़ें

* [MetaGPT GitHub Repository](https://github.com/geekan/MetaGPT) — स्रोत कोड, उदाहरण, रोडमैप
* [MetaGPT Documentation](https://docs.deepwisdom.ai/main/en/) — आधिकारिक दस्तावेज़, कॉन्फ़िगरेशन संदर्भ, ट्यूटोरियल्स
* [MetaGPT Discord](https://discord.gg/DYn29wFk9z) — सामुदायिक सहायता, उपयोग के मामले, मॉडल सुझाव
* [Docker Hub: metagpt/metagpt](https://hub.docker.com/r/metagpt/metagpt) — उपलब्ध इमेज टैग
* [Clore.ai पर Ollama](/guides/guides_v2-hi/language-models/ollama.md) — MetaGPT को मुफ्त में चलाने के लिए स्थानीय LLMs चलाएँ
* [Clore.ai पर vLLM](/guides/guides_v2-hi/language-models/vllm.md) — बड़े पैमाने पर MetaGPT के लिए उच्च-थ्रूपुट स्थानीय LLM
* [GPU तुलना गाइड](/guides/guides_v2-hi/getting-started/gpu-comparison.md) — अपने वर्कलोड के लिए सही Clore.ai GPU चुनें
* [SWE-bench लीडरबोर्ड](https://www.swebench.com) — मल्टी-एजेंट कोडिंग फ्रेमवर्क्स का बेंचमार्क
* [MetaGPT पेपर](https://arxiv.org/abs/2308.00352) — मूल शोध: "MetaGPT: एक मल्टी-एजेंट सहयोगी फ्रेमवर्क के लिए मेटा प्रोग्रामिंग"


---

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