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

# CrewAI मल्टी-एजेंट फ़्रेमवर्क

Clore.ai पर CrewAI डिप्लॉय करें — किसी भी LLM प्रदाता का उपयोग करके जटिल बहु-चरणीय कार्यों के लिए रोल-प्लेइंग स्वायत्त AI एजेंट्स की टीमों का संचालन करें।

## अवलोकन

[CrewAI](https://github.com/crewAIInc/crewAI) एक अत्याधुनिक फ्रेमवर्क है जो समन्वय के लिए **भूमिका-निभाने वाले स्वायत्त एआई एजेंट**, साथ **44K+ GitHub स्टार्स**एकल-एजेंट प्रणालियों के विपरीत, CrewAI आपको विशेषीकृत एजेंट (Researcher, Writer, Coder, Analyst...) परिभाषित करने देता है जो जटिल कार्यों को पूरा करने के लिए एक "क्रू" के रूप में सहयोग करते हैं — प्रत्येक एजेंट की अपनी भूमिका, लक्ष्य, पृष्ठभूमि और टूलकिट होती है।

पर **Clore.ai**, CrewAI को Dockerized वातावरण में केवल **$0.05–0.20/घंटा**हालाँकि CrewAI स्वयं CPU-आधारित है (यह API कॉल्स का समन्वय करता है), इसे उसी GPU नोड पर एक स्थानीय Ollama या vLLM सर्वर के साथ जोड़ने से आपको पूरी तरह निजी, ऑफ़लाइन-सक्षम मल्टी-एजेंट सिस्टम मिलता है।

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

* 👥 **बहु-एजेंट क्रू** — भूमिकाओं, लक्ष्यों और पृष्ठभूमियों के साथ एजेंट व्यक्तित्व परिभाषित करें
* 🎯 **कार्य सौंपना** — प्रबंधक एजेंट स्वचालित रूप से कार्यों को सही विशेषज्ञ को सौंपता है
* 🛠️ **टूल इकोसिस्टम** — वेब खोज, फ़ाइल I/O, कोड निष्पादन, डेटाबेस एक्सेस, कस्टम टूल्स
* 🔁 **क्रमिक और समानांतर** — कार्यों को क्रम में चलाएँ या स्वतंत्र कार्यों को एक साथ निष्पादित करें
* 🧠 **एजेंट मेमोरी** — अल्पकालिक, दीर्घकालिक, एंटिटी और प्रासंगिक मेमोरी प्रकार
* 🔌 **LLM-स्वतंत्र** — OpenAI, Anthropic, Google, Ollama, Groq, Azure और अन्य के साथ काम करता है
* 📊 **CrewAI Studio** — बिना कोड के क्रू बनाने के लिए विज़ुअल इंटरफ़ेस (एंटरप्राइज़)
* 🚀 **पाइपलाइन** — जटिल बहु-चरणीय वर्कफ़्लोज़ के लिए कई क्रू को श्रृंखलाबद्ध करें

***

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

CrewAI एक Python लाइब्रेरी है। यह CPU पर चलता है और केवल सिस्टम Python 3.10+ वातावरण या Docker की आवश्यकता होती है। GPU वैकल्पिक है, लेकिन यह शक्तिशाली स्थानीय मॉडल इनफ़ेरेंस को सक्षम करता है।

| कॉन्फ़िगरेशन                    | GPU             | VRAM  | System RAM | डिस्क  | Clore.ai मूल्य                            |
| ------------------------------- | --------------- | ----- | ---------- | ------ | ----------------------------------------- |
| **न्यूनतम** (क्लाउड APIs)       | कोई नहीं / CPU  | —     | 2 GB       | 10 GB  | \~$0.03/घंटा (CPU)                        |
| **मानक**                        | कोई नहीं / CPU  | —     | 4 GB       | 20 GB  | \~$0.05/घंटा                              |
| **+ स्थानीय LLM (छोटा)**        | RTX 3080        | 10 GB | 8 GB       | 40 GB  | $0.05–0.19/घंटा                           |
| **+ स्थानीय LLM (बड़ा)**        | RTX 3090 / 4090 | 24 GB | 16 GB      | 60 GB  | $0.07–0.21/hr                             |
| **+ उच्च-गुणवत्ता स्थानीय LLM** | A100 40 GB      | 40 GB | 32 GB      | 100 GB | [bare metal](https://clore.ai/bare-metal) |

### API कुंजियाँ

CrewAI अधिकांश प्रमुख LLM प्रदाताओं के साथ काम करता है। आपको कम से कम एक की आवश्यकता है:

* **OpenAI** — GPT-4o (जटिल कार्यों के लिए सर्वश्रेष्ठ तर्कशीलता)
* **Anthropic** — Claude 3.5 Sonnet (लेखन-प्रधान क्रू के लिए उत्कृष्ट)
* **Groq** — निःशुल्क स्तर, तेज़ इनफ़ेरेंस (Llama 3 70B)
* **Ollama** — पूरी तरह स्थानीय, API कुंजी की आवश्यकता नहीं (देखें [GPU त्वरण](#gpu-acceleration))

***

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

### 1. Clore.ai सर्वर किराए पर लें

में लॉग इन करें [clore.ai](https://clore.ai):

* **केवल CPU** यदि क्लाउड LLM APIs का उपयोग कर रहे हों
* **RTX 3090/4090** स्थानीय Ollama इनफ़ेरेंस के लिए
* SSH एक्सेस सक्षम
* CLI उपयोग के लिए किसी विशेष पोर्ट आवश्यकता की जरूरत नहीं (पोर्ट केवल वेब UIs के लिए एक्सपोज़ करें)

### 2. कनेक्ट करें और तैयार करें

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

# सिस्टम अपडेट करें
apt-get update && apt-get upgrade -y

# Python 3.11 इंस्टॉल करें (यदि मौजूद न हो)
apt-get install -y python3.11 python3.11-venv python3-pip
python3 --version   # 3.10+ होना चाहिए

# Docker सत्यापित करें
docker --version
```

### 3. विकल्प A — प्रत्यक्ष pip इंस्टॉल (सबसे तेज़)

```bash
# एक वर्चुअल एनवायरनमेंट बनाएँ
python3 -m venv crewai-env
source crewai-env/bin/activate

# सभी टूल्स के साथ CrewAI इंस्टॉल करें
pip install crewai crewai-tools

# इंस्टॉलेशन सत्यापित करें
python -c "import crewai; print(crewai.__version__)"
crewai --version
```

### 4. विकल्प B — Docker कंटेनर (पुनरुत्पादनशीलता के लिए अनुशंसित)

```bash
# प्रोजेक्ट डायरेक्टरी बनाएँ
mkdir my-crew && cd my-crew

# Dockerfile लिखें
cat > Dockerfile << 'EOF'
FROM python:3.11-slim

# सिस्टम निर्भरताएँ इंस्टॉल करें
RUN apt-get update && apt-get install -y \\
    curl \\
    git \\
    && rm -rf /var/lib/apt/lists/*

# वर्किंग डायरेक्टरी सेट करें
WORKDIR /app

# CrewAI और सामान्य टूल्स इंस्टॉल करें
RUN pip install --no-cache-dir \
    crewai \
    crewai-tools \
    langchain-openai \
    langchain-anthropic \
    python-dotenv

# एप्लिकेशन कोड कॉपी करें
COPY . .

# डिफ़ॉल्ट कमांड
CMD ["python", "main.py"]
EOF

# इमेज बनाएँ
docker build -t my-crewai-app .
```

### 5. अपना पहला क्रू बनाएँ

```bash
# CLI का उपयोग करके नया CrewAI प्रोजेक्ट प्रारंभ करें
source crewai-env/bin/activate
crewai create crew my-research-crew
cd my-research-crew

# API कुंजियाँ कॉन्फ़िगर करें
cat > .env << 'EOF'
OPENAI_API_KEY=sk-...
# या Anthropic के लिए:
# ANTHROPIC_API_KEY=sk-ant-...
# या Ollama के लिए (कुंजी की आवश्यकता नहीं):
# OPENAI_API_BASE=http://localhost:11434/v1
# OPENAI_API_KEY=ollama
EOF

# प्रोजेक्ट निर्भरताएँ इंस्टॉल करें
crewai install

# क्रू चलाएँ
crewai run
```

***

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

### प्रोजेक्ट संरचना (से `crewai create`)

```
my-research-crew/
├── .env                    # API कुंजियाँ और सेटिंग्स
├── pyproject.toml          # निर्भरताएँ
├── src/
│   └── my_research_crew/
│       ├── config/
│       │   ├── agents.yaml   # एजेंट परिभाषाएँ
│       │   └── tasks.yaml    # कार्य परिभाषाएँ
│       ├── tools/
│       │   └── custom_tool.py  # आपके कस्टम टूल्स
│       ├── crew.py           # क्रू संयोजन
│       └── main.py           # प्रवेश बिंदु
```

### agents.yaml — अपने एजेंट परिभाषित करें

```yaml
researcher:
  भूमिका: >
    वरिष्ठ अनुसंधान विश्लेषक
  लक्ष्य: >
    {topic} में अत्याधुनिक विकासों का पता लगाएँ और कार्रवाई योग्य अंतर्दृष्टियाँ संक्षेपित करें
  पृष्ठभूमि: >
    आप एक विशेषज्ञ शोधकर्ता हैं, जिन्हें विविध स्रोतों से जानकारी खोजने और जोड़ने की प्रतिभा है
    । आपके पास विश्वसनीयता और प्रासंगिकता के लिए तेज़ दृष्टि है।
  उपकरण:
    - SerperDevTool
    - ScrapeWebsiteTool
  llm: gpt-4o                # प्रति-एजेंट सेट किया जा सकता है
  verbose: true
  max_iter: 15               # अधिकतम तर्क/विचार पुनरावृत्तियाँ
  memory: true               # एजेंट मेमोरी सक्षम करें

writer:
  भूमिका: >
    विशेषज्ञ तकनीकी लेखक
  लक्ष्य: >
    जटिल शोध को स्पष्ट, आकर्षक और सटीक सामग्री में रूपांतरित करें
  पृष्ठभूमि: >
    आप ऐसी व्याख्याएँ तैयार करते हैं जो गहराई से समझौता किए बिना जटिल विषयों को सुलभ बनाती हैं।
    आप स्रोतों का हवाला देते हैं और अधिकतम पठनीयता के लिए सामग्री की संरचना करते हैं।
  llm: claude-3-5-sonnet-20241022
  verbose: true
```

### tasks.yaml — कार्य परिभाषित करें

```yaml
research_task:
  विवरण: >
    पिछले 6 महीनों में {topic} में नवीनतम विकासों पर शोध करें।
    मुख्य रुझानों, सफलताओं और निहितार्थों की पहचान करें।
    कम से कम 10 विश्वसनीय स्रोत संकलित करें।
  अपेक्षित आउटपुट: >
    थीम के अनुसार व्यवस्थित निष्कर्षों के साथ एक विस्तृत शोध रिपोर्ट,
    जिसमें स्रोत URL और प्रकाशन तिथियाँ शामिल हों।
  एजेंट: researcher

writing_task:
  विवरण: >
    शोध रिपोर्ट का उपयोग करके, {topic} पर एक व्यापक ब्लॉग पोस्ट लिखें।
    लक्षित लंबाई: 1500-2000 शब्द। शीर्षक, परिचय, मुख्य अनुभाग शामिल करें,
    और भविष्य दृष्टि के साथ एक निष्कर्ष।
  अपेक्षित आउटपुट: >
    Markdown प्रारूप में एक प्रकाशन-तैयार ब्लॉग पोस्ट।
  एजेंट: writer
  context:
    - research_task    # लेखन कार्य को शोधकर्ता का आउटपुट मिलता है
  output_file: output/blog_post.md
```

### crew\.py — क्रू संयोजित करें

```python
from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from crewai_tools import SerperDevTool, ScrapeWebsiteTool

@CrewBase
class MyResearchCrew():
    """शोध और लेखन क्रू"""
    agents_config = 'config/agents.yaml'
    tasks_config = 'config/tasks.yaml'

    @agent
    def researcher(self) -> Agent:
        return Agent(
            config=self.agents_config['researcher'],
            tools=[SerperDevTool(), ScrapeWebsiteTool()],
            verbose=True
        )

    @agent
    def writer(self) -> Agent:
        return Agent(
            config=self.agents_config['writer'],
            verbose=True
        )

    @task
    def research_task(self) -> Task:
        return Task(config=self.tasks_config['research_task'])

    @task
    def writing_task(self) -> Task:
        return Task(
            config=self.tasks_config['writing_task'],
            output_file='output/blog_post.md'
        )

    @crew
    def crew(self) -> Crew:
        return Crew(
            agents=self.agents,
            tasks=self.tasks,
            process=Process.sequential,  # or Process.hierarchical
            verbose=True,
            memory=True,
            max_rpm=10   # API कॉल्स की दर सीमित करें
        )
```

### Docker Compose के साथ चलाना (Ollama के साथ)

```yaml
# docker-compose.yml
version: "3.8"

services:
  crewai:
    build: .
    volumes:
      - ./src:/app/src
      - ./output:/app/output
    environment:
      - OPENAI_API_BASE=http://ollama:11434/v1
      - OPENAI_API_KEY=ollama
      - OPENAI_MODEL_NAME=llama3.1:70b
      - SERPER_API_KEY=${SERPER_API_KEY}
    depends_on:
      - ollama

  ollama:
    image: ollama/ollama:latest
    volumes:
      - ollama_data:/root/.ollama
    ports:
      - "11434:11434"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

volumes:
  ollama_data:
```

```bash
# स्टैक शुरू करें
docker compose up -d ollama

# अपना मॉडल पुल करें
docker compose exec ollama ollama pull llama3.1:70b

# अपना क्रू चलाएँ
docker compose run --rm crewai python src/my_research_crew/main.py
```

***

## GPU त्वरण

CrewAI स्वयं GPU का उपयोग नहीं करता — लेकिन जिस LLM को यह कॉल करता है, वह करता है। GPU-त्वरित स्थानीय इनफ़ेरेंस के लिए उसी Clore सर्वर पर Ollama या vLLM चलाएँ।

### Ollama सेटअप (सुविधा के लिए अनुशंसित)

```bash
# होस्ट पर Ollama इंस्टॉल करें
curl -fsSL https://ollama.com/install.sh | sh

# GPU पहचान सत्यापित करें
nvidia-smi
ollama run llama3:8b "Test"   # GPU का उपयोग करना चाहिए

# विभिन्न एजेंट आवश्यकताओं के लिए मॉडल पुल करें
ollama pull llama3.1:8b          # तेज़, हल्का तर्क
ollama pull llama3.1:70b         # जटिल तर्क (A100+ की आवश्यकता)
ollama pull codestral:latest     # कोड एजेंटों के लिए विशेष
ollama pull nomic-embed-text     # मेमोरी/RAG एम्बेडिंग के लिए

# Ollama का उपयोग करने के लिए CrewAI कॉन्फ़िगर करें
export OPENAI_API_BASE=http://localhost:11434/v1
export OPENAI_API_KEY=ollama
export OPENAI_MODEL_NAME=llama3.1:8b
```

### एजेंट-वार CrewAI LLM कॉन्फ़िगर करें

```python
from crewai import Agent, LLM

# किसी विशिष्ट एजेंट के लिए Ollama का उपयोग करें
local_llm = LLM(
    model="ollama/llama3.1:8b",
    base_url="http://localhost:11434"
)

# दूसरे एजेंट के लिए क्लाउड API का उपयोग करें (जैसे, जटिल तर्क)
cloud_llm = LLM(
    model="gpt-4o",
    api_key="sk-..."
)

researcher = Agent(
    role="Researcher",
    goal="जानकारी खोजें",
    backstory="विशेषज्ञ शोधकर्ता",
    llm=local_llm    # स्थानीय GPU का उपयोग करता है
)

strategist = Agent(
    role="Strategist",
    goal="कार्रवाइयों की योजना बनाएँ",
    backstory="रणनीतिक विचारक",
    llm=cloud_llm    # क्लाउड API का उपयोग करता है
)
```

### एजेंट कार्यों के लिए मॉडल अनुशंसाएँ

| कार्य प्रकार       | अनुशंसित मॉडल    | VRAM   | नोट्स                    |
| ------------------ | ---------------- | ------ | ------------------------ |
| शोध + वेब खोज      | Llama 3.1 70B    | 40 GB  | सर्वश्रेष्ठ स्थानीय तर्क |
| कोड जनरेशन         | Codestral 22B    | 13 GB  | कोड-विशेषीकृत            |
| लेखन               | Llama 3.1 8B     | 6 GB   | तेज़, अच्छी गुणवत्ता     |
| जटिल समन्वय        | GPT-4o (API)     | —      | कुल मिलाकर सर्वश्रेष्ठ   |
| एम्बेडिंग्स/मेमोरी | nomic-embed-text | < 1 GB | मेमोरी के लिए आवश्यक     |

> देखें [Clore.ai पर Ollama](/guides/guides_v2-hi/language-models/ollama.md) और [Clore.ai पर vLLM](/guides/guides_v2-hi/language-models/vllm.md) पूर्ण इनफ़ेरेंस सेटअप गाइड्स के लिए।

***

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

### लागत अनुकूलन

```bash
# CrewAI की अंतर्निहित उपयोग ट्रैकिंग के साथ LLM API लागतें ट्रैक करें
# अपने क्रू में जोड़ें:
result = crew.kickoff(inputs={"topic": "AI agents"})
print(f"कुल उपयोग किए गए टोकन: {result.token_usage}")

# सरल कार्यों के लिए सस्ते मॉडल, जटिल कार्यों के लिए प्रीमियम मॉडल उपयोग करें
# Ollama पर Llama 3.1 8B = $0 API लागत
# GPT-4o = ~$0.005/1K input tokens

# भागते हुए एजेंटों को रोकने के लिए max_iter सेट करें
Agent(max_iter=10, max_execution_time=120)  # 2-मिनट का टाइमआउट

# विकास के दौरान LLM प्रतिक्रियाओं को कैश करें
os.environ["CREWAI_DISABLE_CACHE"] = "false"
```

### क्रू को एक स्थायी सेवा के रूप में चलाना

```bash
# FastAPI endpoint के माध्यम से क्रू को सेवा दें
pip install fastapi uvicorn

cat > server.py << 'EOF'
from fastapi import FastAPI, BackgroundTasks
from my_research_crew.crew import MyResearchCrew
import asyncio

app = FastAPI()
results = {}

@app.post("/run/{topic}")
async def run_crew(topic: str, background_tasks: BackgroundTasks):
    job_id = f"job-{topic}-{len(results)}"
    background_tasks.add_task(execute_crew, job_id, topic)
    return {"job_id": job_id, "status": "started"}

async def execute_crew(job_id: str, topic: str):
    crew = MyResearchCrew().crew()
    result = crew.kickoff(inputs={"topic": topic})
    results[job_id] = str(result)

@app.get("/result/{job_id}")
async def get_result(job_id: str):
    return {"result": results.get(job_id, "pending") }

EOF

# सर्वर चलाएँ
uvicorn server:app --host 0.0.0.0 --port 8080 &

# एक क्रू रन ट्रिगर करें
curl -X POST http://<clore-ip>:8080/run/quantum-computing
```

### उपयोगी अंतर्निहित CrewAI टूल

```python
from crewai_tools import (
    SerperDevTool,        # Serper API के माध्यम से Google खोज
    ScrapeWebsiteTool,    # वेब स्क्रैपिंग
    FileReadTool,         # स्थानीय फ़ाइलें पढ़ें
    FileWriterTool,       # फ़ाइलें लिखें
    DirectoryReadTool,    # डायरेक्टरी की सामग्री सूचीबद्ध करें
    CodeInterpreterTool,  # Python कोड निष्पादित करें
    GithubSearchTool,     # GitHub रिपॉज़ खोजें
    YoutubeVideoSearchTool, # YouTube खोजें
    PGSearchTool,         # PostgreSQL क्वेरी करें
)
```

### human-in-the-loop लागू करना

```python
# किसी विशिष्ट कार्य पर मानव इनपुट मांगें
task = Task(
    description="अनुसंधान {topic}",
    expected_output="अनुसंधान रिपोर्ट",
    agent=researcher,
    human_input=True    # रुकता है और उपयोगकर्ता से प्रतिक्रिया मांगता है
)
```

***

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

### "openai.AuthenticationError" वैध कुंजी होने पर भी

```bash
# जाँचें कि आपकी API कुंजी लोड हुई है
python3 -c "import os; from dotenv import load_dotenv; load_dotenv(); print(os.getenv('OPENAI_API_KEY')[:10])"

# यदि Ollama का उपयोग कर रहे हैं, तो सुनिश्चित करें कि ये सेट हैं:
export OPENAI_API_BASE=http://localhost:11434/v1
export OPENAI_API_KEY=ollama
export OPENAI_MODEL_NAME=llama3.1:8b

# सत्यापित करें कि Ollama उपलब्ध है
curl http://localhost:11434/v1/models
```

### एजेंट तर्क लूप में फँस गया है

```bash
# पुनरावृत्तियों की सख्त सीमा निर्धारित करें
Agent(
    max_iter=10,            # अधिकतम तर्क चरण
    max_execution_time=300  # 5-मिनट का सख्त टाइमआउट
)

# यह देखने के लिए verbose सक्षम करें कि यह कहाँ लूप कर रहा है
Agent(verbose=True)

# जाँचें कि क्या मॉडल टूल कॉलिंग का समर्थन करता है
# कुछ छोटे मॉडल ऐसा नहीं करते; llama3.1 या mistral-nemo का उपयोग करें
```

### CrewAI टूल विफल हो जाते हैं (SerperDevTool 403)

```bash
# SerperDevTool को serper.dev से एक निःशुल्क API कुंजी चाहिए
export SERPER_API_KEY=your-serper-key

# विकल्प: DuckDuckGo का उपयोग करें (API कुंजी की आवश्यकता नहीं)
from langchain_community.tools import DuckDuckGoSearchRun
from crewai import tool

@tool("DuckDuckGo Search")
def ddg_search(query: str) -> str:
    """DuckDuckGo का उपयोग करके वेब खोजें।"""
    return DuckDuckGoSearchRun().run(query)
```

### मेमोरी त्रुटियाँ (ChromaDB / embeddings)

```bash
# CrewAI मेमोरी वेक्टर स्टोरेज के लिए ChromaDB का उपयोग करती है
# यदि यह विफल हो, तो डिस्क स्थान और अनुमतियाँ जाँचें
df -h
ls -la ~/.local/share/crewai/

# दूषित मेमोरी साफ़ करें
rm -rf ~/.local/share/crewai/

# या यदि आवश्यकता न हो तो मेमोरी अक्षम करें
Crew(memory=False)

# यदि Ollama embeddings का उपयोग कर रहे हैं, तो सुनिश्चित करें कि मॉडल डाउनलोड किया गया है
docker exec ollama ollama pull nomic-embed-text
```

### ARM/x86 असंगति पर Docker build विफल होता है

```bash
# Clore.ai सर्वर x86_64 हैं; platform स्पष्ट रूप से निर्दिष्ट करें:
docker build --platform linux/amd64 -t my-crewai-app .

# या docker-compose.yml में:
services:
  crewai:
    platform: linux/amd64
    build: .
```

### LLM APIs से दर-सीमा

```bash
# प्रति मिनट अनुरोध कम करें
Crew(max_rpm=5)   # प्रति मिनट 5 अनुरोध

# LLM कॉन्फ़िगरेशन में पुनःप्रयास लॉजिक जोड़ें
LLM(
    model="gpt-4o",
    max_retries=3,
    timeout=60
)
```

***

## अधिक पढ़ें

* [CrewAI आधिकारिक दस्तावेज़](https://docs.crewai.com)
* [CrewAI GitHub रिपॉज़िटरी](https://github.com/crewAIInc/crewAI)
* [CrewAI टूल्स दस्तावेज़](https://docs.crewai.com/concepts/tools)
* [CrewAI उदाहरण रिपॉज़िटरी](https://github.com/crewAIInc/crewAI-examples)
* [Clore.ai पर Ollama चलाना](/guides/guides_v2-hi/language-models/ollama.md)
* [Clore.ai पर vLLM चलाना](/guides/guides_v2-hi/language-models/vllm.md)
* [Clore.ai GPU तुलना](/guides/guides_v2-hi/getting-started/gpu-comparison.md)
* [CrewAI सामुदायिक Discord](https://discord.com/invite/X4JWnZnxPb)


---

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