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

# CrewAI Multi-Agent Framework

## अवलोकन

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

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

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

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

***

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

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

| कॉन्फ़िगरेशन                 | GPU                 | VRAM  | सिस्टम 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.15/घंटा       |
| **+ लोकल LLM (बड़ा)**        | RTX 3090 / 4090     | 24 GB | 16 GB      | 60 GB  | $0.20–0.35/घंटा    |
| **+ उच्च-गुणवत्ता लोकल LLM** | A100 40 GB          | 40 GB | 32 GB      | 100 GB | \~$0.80/घंटा       |

### 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 उपयोग के लिए कोई विशिष्ट पोर्ट आवश्यकताएँ नहीं (वेब UI के लिए ही पोर्ट खोलें)

### 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 install (सबसे तेज़)

```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:
  role: >
    सीनियर रिसर्च एनालिस्ट
  goal: >
    {topic} में अत्याधुनिक विकासों का पता लगाना और कार्रवाई योग्य अंतर्दृष्टियाँ संकलित करना
  backstory: >
    आप एक विशेषज्ञ शोधकर्ता हैं जिनमें विविध स्रोतों से जानकारी खोजने और जोड़ने की क्षमता है
    from diverse sources. You have a keen eye for credibility and relevance.
  tools:
    - SerperDevTool
    - ScrapeWebsiteTool
  llm: gpt-4o                # प्रति-एजेंट सेट किया जा सकता है
  verbose: true
  max_iter: 15               # अधिकतम तर्क इटरेशन
  memory: true               # एजेंट मेमोरी सक्षम करें

writer:
  role: >
    Expert Technical Writer
  goal: >
    Transform complex research into clear, compelling, and accurate content
  backstory: >
    You craft explanations that make complex topics accessible without sacrificing depth.
    You cite sources and structure content for maximum readability.
  llm: claude-3-5-sonnet-20241022
  verbose: true
```

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

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

writing_task:
  description: >
    शोध रिपोर्ट का उपयोग करते हुए, {topic} पर एक व्यापक ब्लॉग पोस्ट लिखें।
    लक्ष्य लंबाई: 1500-2000 शब्द। शीर्षक, परिचय, मुख्य अनुभाग,
    और भविष्य के दृष्टिकोण के साथ निष्कर्ष शामिल करें।
  expected_output: >
    प्रकाशन-तैयार ब्लॉग पोस्ट Markdown फ़ॉर्मेट में।
  agent: 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,  # या 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-त्वरित लोकल इन्फ़रेंस के लिए Ollama या vLLM को उसी Clore सर्वर पर चलाएँ।

### 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 एम्बेडिंग के लिए

# CrewAI को Ollama उपयोग करने के लिए कॉन्फ़िगर करें
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="Expert researcher",
    llm=local_llm    # लोकल GPU का उपयोग करता है
)

strategist = Agent(
    role="Strategist",
    goal="कार्रवाइयों की योजना बनाना",
    backstory="Strategic thinker",
    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 इनपुट टोकन

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

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

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

```bash
# FastAPI एंडपॉइंट के माध्यम से क्रू सर्व करें
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 क्वेरी
)
```

### मानव-इन-द-लूप लागू करना

```python
# किसी विशिष्ट कार्य पर मानव इनपुट माँगें
task = Task(
    description="Research {topic}",
    expected_output="Research report",
    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 / एम्बेडिंग)

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

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

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

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

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

```bash
# Clore.ai सर्वर x86_64 होते हैं; प्लेटफ़ॉर्म स्पष्ट रूप से निर्दिष्ट करें:
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 कॉन्फ़िग में retry तर्क जोड़ें
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:

```
GET https://docs.clore.ai/guides/guides_v2-hi/ai-platforms-and-agents/crewai.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.