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

# MetaGPT Software Company

## अवलोकन

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

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

1. **प्रोडक्ट मैनेजर** — एक प्रोडक्ट रिक्वायरमेंट्स डॉक्यूमेंट (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/घं पर, व्यापक MetaGPT सत्र GPT-4o API कॉल्स की तुलना में सस्ते चलाए जा सकते हैं
* **आइसोलेटेड वातावरण** — जेनरेट किया गया कोड नियंत्रित सर्वर वातावरण में चलता है
* **टीम सहयोग** — विकास टीम में एक साझा 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.20/घंटा      |
| **+ Ollama (DeepSeek Coder 33B)**  | RTX 4090  | 24 GB | 32 GB | 60 GB   | \~$0.35/घंटा      |
| **+ vLLM (Qwen2.5-Coder 32B)**     | RTX 4090  | 24 GB | 32 GB | 80 GB   | \~$0.35/घंटा      |
| **+ vLLM (Llama 3.1 70B)**         | A100 80GB | 80 GB | 64 GB | 100 GB  | \~$1.10/घंटा      |

> **सिफारिश:** 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 कंटेनर टूलकिट (केवल स्थानीय LLM विकल्प के लिए)
* 20+ GB खाली डिस्क स्पेस (MetaGPT इमेज + जेनरेट की गई प्रोजेक्ट फाइलें)
* आउटबाउंड इंटरनेट एक्सेस (Docker इमेज खींचने और LLM APIs तक पहुँचने के लिए)

***

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

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

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

* केवल API के लिए: किसी भी सर्वर में ≥4 GB RAM होना चाहिए
* स्थानीय LLM के लिए: GPU में ≥24 GB VRAM होना चाहिए

```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 गेम जेनरेट करें (क्लासिक डेमो)
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 "Create a snake game with Python"
```

एजेंट्स के काम को देखें: आप 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 "Build a REST API for a todo list app with FastAPI" \
  --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 "Add user authentication to the existing 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 \
    "Analyze /data/sales.csv and find top-performing products, create visualization"
```

### स्थायी सेटअप के लिए 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 "Create a Flask web app with user registration"
```

***

## 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  # वैकल्पिक
# छोटे GPUs (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 एक्सेस के लिए होस्ट नेटवर्क के साथ 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 "Create a Python CLI tool for file organization"
```

> पूर्ण देखें [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 "Waiting for 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 "Build a complete e-commerce backend with FastAPI and 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 टोकन (~GPT-4o के साथ ~$0.25)
# - मध्यम वेबऐप: ~200K टोकन (~GPT-4o के साथ ~$1.00)
# - जटिल सिस्टम: ~500K+ टोकन (~GPT-4o के साथ ~$2.50+)

# कॉन्फ़िग में बजट सीमा सेट करें:
# 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
# वर्कस्पेस में git इनिशियलाइज़ करें
cd /opt/metagpt/workspace
git init
git add .
git commit -m "Initial MetaGPT generation"

# प्रत्येक पुनरावृत्ति के बाद
git add .
git commit -m "MetaGPT: Added authentication feature"
```

### 6. कई परियोजनाएँ बैच में चलाएँ

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

```bash
#!/bin/bash
# /opt/metagpt/batch-run.sh
PROJECTS=(
  "Create a URL shortener service with Python and Redis"
  "Build a Markdown to PDF converter CLI tool"
  "Create a REST API for a blog with comments and tags"
)

for project in "${PROJECTS[@]}"; do
  echo "Starting: $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 "Completed: $project"
done
```

***

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

### इमेज पुल विफल होता है

```bash
# यदि Docker Hub रेट लिमिट हिट हो
docker login  # अपने Docker Hub अकाउंट से लॉग इन करें
docker pull metagpt/metagpt:latest

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

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

```bash
# सुनिश्चित करें कि पाथ मैपिंग सही है
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 की की स्वतंत्र रूप से जांच करें
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"

# सामान्य समस्याएँ:
# - की के साथ अतिरिक्त व्हाइटस्पेस कॉपी हुआ
# - की समाप्त हो गई या कोटा पार हो गया
# - कॉन्फ़िग में गलत 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 लॉग्स जाँचें
docker logs ollama --tail 20
```

### जनरेशन अटक जाता है या टाइमआउट होता है

```bash
# जांचें कि LLM वास्तव में प्रतिक्रिया दे रहा है
# किस एजेंट के अटके होने को देखने के लिए डिबग लॉगिंग जोड़ें
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

# सामान्य कारण:
# - स्थानीय मॉडल बहुत धीमा (छोटे क्वांटाइज़्ड मॉडल का प्रयास करें)
# - API रेट लिमिटिंग (डिले जोड़ें या टियर बदलें)
# - मॉडल संदर्भ विंडो अधिक हो गया (max_auto_summarize_code घटाएँ)
```

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

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

# Docker बिल्ड कैश भी साफ़ करें
docker system prune -f

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

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

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

***

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

* [MetaGPT GitHub रिपॉजिटरी](https://github.com/geekan/MetaGPT) — स्रोत कोड, उदाहरण, रोडमैप
* [MetaGPT दस्तावेज़ीकरण](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: Meta Programming for a Multi-Agent Collaborative Framework"


---

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