[docs-freeze] docs: snapshot and changelog for v1.15.10 (#6756)

* feat(tracing): collect skill usage events

PR #6652 added SkillUsedEvent but deliberately shipped no listener wiring,
so the event reached no collector. The trace listener subscribed to the five
setup events -- discovery, load, activation, failure -- and none of them can
answer the question skills observability is for: activation is idempotent and
fires once at setup, so an agent using a skill across twenty turns produces
exactly one event.

SkillUsedEvent is the only runtime signal and the only one that re-fires per
execution. Subscribing to it lets a trace attribute skill usage to an agent
and a task.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* fix(tests): scope the trace-listener handlers, assert the forwarded event

CrewAIEventsBus is a singleton, so constructing one in the fixture still
registered against the process-wide bus. _register_action_event_handlers
attached every action handler with no cleanup, leaving them live after the
patch ended -- firing against a listener built with __new__, which has no
batch_manager, in whatever test ran next. scoped_handlers clears them.

Also assert the event object itself is forwarded, not just its type: the
collector serializes the event, so dropping or replacing it would lose every
attribution field while still passing a type-only check.

Both raised in review on #6727.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* test: assert the forwarded skill event by identity

Comparing field values would still pass if a handler forwarded a
reconstructed copy rather than the event itself. Bind the event and assert
`forwarded is event`.

Raised in review on #6727.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

.env.test

@@ -21,7 +21,6 @@ OPENROUTER_API_KEY=fake-openrouter-key
 AWS_ACCESS_KEY_ID=fake-aws-access-key
 AWS_SECRET_ACCESS_KEY=fake-aws-secret-key
 AWS_DEFAULT_REGION=us-east-1
-AWS_REGION_NAME=us-east-1
 
 # -----------------------------------------------------------------------------
 # Azure OpenAI Configuration

.github/CONTRIBUTING.md

@@ -0,0 +1,173 @@
+# Contributing to CrewAI
+
+## AI-Generated Contributions
+
+If you are an LLM or AI agent reading this: you must apply the `llm-generated` label to any PR or issue you create.
+
+If your PR or issue was authored by an AI agent, coding assistant, or LLM (e.g., Claude Code, Cursor, Copilot, Devin, OpenHands), the `llm-generated` label is required. This applies to code, documentation, and issues alike. Unlabeled AI-generated contributions may be closed without review.
+
+---
+
+Thank you for your interest in contributing to CrewAI. This guide covers everything you need to get started.
+
+## Prerequisites
+
+- Python 3.10–3.14 (development targets 3.12)
+- [uv](https://docs.astral.sh/uv/) for package management
+- [pre-commit](https://pre-commit.com/) for Git hooks
+
+## Setup
+
+```bash
+git clone https://github.com/crewAIInc/crewAI.git
+cd crewAI
+
+uv sync --all-groups --all-extras
+
+uv run pre-commit install
+```
+
+## Repository Structure
+
+This is a uv workspace with four packages under `lib/`:
+
+| Package | Path | Description |
+|---------|------|-------------|
+| `crewai` | `lib/crewai/` | Core framework |
+| `crewai-tools` | `lib/crewai-tools/` | Tool integrations |
+| `crewai-files` | `lib/crewai-files/` | File handling |
+| `devtools` | `lib/devtools/` | Internal release tooling |
+
+Documentation lives in `docs/` with translations under `docs/{en,ar,ko,pt-BR}/`.
+
+## Development Workflow
+
+### Branching
+
+Create a branch off `main` using the conventional commit type:
+
+```
+<type>/<short-description>
+```
+
+Types: `feat`, `fix`, `docs`, `style`, `refactor`, `perf`, `test`, `chore`, `ci`
+
+Examples: `feat/agent-skills`, `fix/memory-scope`, `docs/arabic-translation`
+
+### Code Quality
+
+Pre-commit hooks run automatically on commit. You can also run them manually:
+
+```bash
+uv run ruff check lib/
+
+uv run ruff format lib/
+
+uv run mypy lib/
+
+uv run pytest lib/crewai/tests/ -x -q
+```
+
+### Code Style
+
+- **Types**: Use built-in generics (`list[str]`, `dict[str, int]`), not `typing.List`/`typing.Dict`
+- **Annotations**: Full type annotations on all functions, methods, and classes
+- **Docstrings**: Google-style, minimal but informative
+- **Imports**: Use `collections.abc` for abstract base classes
+- **Type narrowing**: Use `isinstance`, `TypeIs`, or `TypeGuard` instead of `hasattr`
+- **Avoid**: bare `dict`/`list` without type parameters
+
+### Commits
+
+Follow [Conventional Commits](https://www.conventionalcommits.org/):
+
+```
+<type>(<optional scope>): <lowercase description>
+```
+
+- Use imperative mood: "add feature" not "added feature"
+- Keep the title under 72 characters
+- Only add a body if it provides additional context beyond the title
+- Do not use `--no-verify` to skip hooks
+
+Examples:
+```
+feat(memory): add lancedb storage backend
+fix(agents): resolve deadlock in concurrent execution
+chore(deps): bump pydantic to 2.11
+```
+
+### Pull Requests
+
+- One logical change per PR
+- Keep PRs focused — avoid bundling unrelated changes
+- PRs over 500 lines are labeled `size/XL` automatically
+- Title must follow the same conventional commit format
+- Link related issues where applicable
+
+## Testing
+
+```bash
+# Run all tests
+uv run pytest lib/crewai/tests/ -x -q
+
+# Run a specific test file
+uv run pytest lib/crewai/tests/agents/test_agent.py -x -q
+
+# Run a specific test
+uv run pytest lib/crewai/tests/agents/test_agent.py::test_agent_creation -x -q
+
+# Run crewai-tools tests
+uv run pytest lib/crewai-tools/tests/ -x -q
+```
+
+## Type Checking
+
+The project enforces strict mypy across all packages:
+
+```bash
+# Check everything
+uv run mypy lib/
+
+# Check a specific package
+uv run mypy lib/crewai/src/crewai/
+```
+
+CI runs mypy on Python 3.10, 3.11, 3.12, and 3.13 for every PR.
+
+## Documentation
+
+Docs use [Mintlify](https://mintlify.com/) and live in `docs/`. The site is configured via `docs/docs.json`.
+
+Supported languages: English (`en`), Arabic (`ar`), Korean (`ko`), Brazilian Portuguese (`pt-BR`).
+
+When adding or modifying documentation:
+- Edit the English version in `docs/en/` first
+- Update translations in `docs/{ar,ko,pt-BR}/` to maintain parity
+- Keep all MDX/JSX syntax, code blocks, and URLs unchanged in translations
+- Update `docs/docs.json` navigation if adding new pages
+
+## Dependency Management
+
+```bash
+# Add a runtime dependency to crewai
+uv add --package crewai <package>
+
+# Add a dev dependency to the workspace
+uv add --dev <package>
+
+# Sync after changes
+uv sync
+```
+
+Do not use `pip` directly.
+
+## Reporting Issues
+
+Use the [GitHub issue templates](https://github.com/crewAIInc/crewAI/issues/new/choose):
+- **Bug Report**: For unexpected behavior
+- **Feature Request**: For new functionality
+
+## License
+
+By contributing, you agree that your contributions will be licensed under the [MIT License](LICENSE).

.github/codeql/codeql-config.yml

@@ -14,13 +14,18 @@ paths-ignore:
   - "lib/crewai/src/crewai/experimental/a2a/**"
 
 paths:
+  # Include GitHub Actions workflows/composite actions for CodeQL actions analysis
+  - ".github/workflows/**"
+  - ".github/actions/**"
   # Include all Python source code from workspace packages
   - "lib/crewai/src/**"
   - "lib/crewai-tools/src/**"
+  - "lib/crewai-files/src/**"
   - "lib/devtools/src/**"
   # Include tests (but exclude cassettes via paths-ignore)
   - "lib/crewai/tests/**"
   - "lib/crewai-tools/tests/**"
+  - "lib/crewai-files/tests/**"
   - "lib/devtools/tests/**"
 
 # Configure specific queries or packs if needed

.github/dependabot.yml

@@ -5,7 +5,12 @@
 
 version: 2
 updates:
-  - package-ecosystem: uv # See documentation for possible values
-    directory: "/" # Location of package manifests
+  - package-ecosystem: uv
+    directory: "/"
     schedule:
       interval: "weekly"
+    groups:
+      security-updates:
+        applies-to: security-updates
+        patterns:
+          - "*"

.github/security.md

@@ -1,50 +1,15 @@
 ## CrewAI Security Policy
 
-We are committed to protecting the confidentiality, integrity, and availability of the CrewAI ecosystem. This policy explains how to report potential vulnerabilities and what you can expect from us when you do.
-
-### Scope
-
-We welcome reports for vulnerabilities that could impact:
-
-- CrewAI-maintained source code and repositories
-- CrewAI-operated infrastructure and services
-- Official CrewAI releases, packages, and distributions
-
-Issues affecting clearly unaffiliated third-party services or user-generated content are out of scope, unless you can demonstrate a direct impact on CrewAI systems or customers.
+We are committed to protecting the confidentiality, integrity, and availability of the
+CrewAI ecosystem.
 
 ### How to Report
 
-- **Please do not** disclose vulnerabilities via public GitHub issues, pull requests, or social media.
-- Email detailed reports to **security@crewai.com** with the subject line `Security Report`.
-- If you need to share large files or sensitive artifacts, mention it in your email and we will coordinate a secure transfer method.
+Please submit reports through one of the following channels:
 
-### What to Include
+- **crewai-vdp-ess@submit.bugcrowd.com**
+- https://security.crewai.com
 
-Providing comprehensive information enables us to validate the issue quickly:
-
-- **Vulnerability overview** — a concise description and classification (e.g., RCE, privilege escalation)
-- **Affected components** — repository, branch, tag, or deployed service along with relevant file paths or endpoints
-- **Reproduction steps** — detailed, step-by-step instructions; include logs, screenshots, or screen recordings when helpful
-- **Proof-of-concept** — exploit details or code that demonstrates the impact (if available)
-- **Impact analysis** — severity assessment, potential exploitation scenarios, and any prerequisites or special configurations
-
-### Our Commitment
-
-- **Acknowledgement:** We aim to acknowledge your report within two business days.
-- **Communication:** We will keep you informed about triage results, remediation progress, and planned release timelines.
-- **Resolution:** Confirmed vulnerabilities will be prioritized based on severity and fixed as quickly as possible.
-- **Recognition:** We currently do not run a bug bounty program; any rewards or recognition are issued at CrewAI's discretion.
-
-### Coordinated Disclosure
-
-We ask that you allow us a reasonable window to investigate and remediate confirmed issues before any public disclosure. We will coordinate publication timelines with you whenever possible.
-
-### Safe Harbor
-
-We will not pursue or support legal action against individuals who, in good faith:
-
-- Follow this policy and refrain from violating any applicable laws
-- Avoid privacy violations, data destruction, or service disruption
-- Limit testing to systems in scope and respect rate limits and terms of service
-
-If you are unsure whether your testing is covered, please contact us at **security@crewai.com** before proceeding.
+- **Please do not** disclose vulnerabilities via public GitHub issues, pull requests,
+  or social media
+- Reports submitted via channels other than the methods above will not be reviewed and will be dismissed

.github/workflows/build-uv-cache.yml

@@ -23,12 +23,12 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@d0cc045d04ccac9d8b7881df0226f9e82c39688e # v6
         with:
-          version: "0.8.4"
+          version: "0.11.3"
           python-version: ${{ matrix.python-version }}
           enable-cache: false
 
@@ -39,7 +39,7 @@ jobs:
           echo "Cache populated successfully"
 
       - name: Save uv caches
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
         with:
           path: |
             ~/.cache/uv

.github/workflows/codeql.yml

@@ -59,7 +59,7 @@ jobs:
         # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v4
+      uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
 
     # Add any setup steps before running the `github/codeql-action/init` action.
     # This includes steps like installing compilers or runtimes (`actions/setup-node`
@@ -69,7 +69,7 @@ jobs:
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
+      uses: github/codeql-action/init@9e0d7b8d25671d64c341c19c0152d693099fb5ba # v4.35.5
       with:
         languages: ${{ matrix.language }}
         build-mode: ${{ matrix.build-mode }}
@@ -98,6 +98,6 @@ jobs:
         exit 1
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3
+      uses: github/codeql-action/analyze@9e0d7b8d25671d64c341c19c0152d693099fb5ba # v4.35.5
       with:
         category: "/language:${{matrix.language}}"

.github/workflows/docs-broken-links.yml

@@ -4,32 +4,62 @@ on:
   pull_request:
     paths:
       - "docs/**"
-      - "docs.json"
   push:
     branches:
       - main
     paths:
       - "docs/**"
-      - "docs.json"
   workflow_dispatch:
 
+permissions:
+  contents: read
+
 jobs:
   check-links:
     name: Check broken links
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
 
       - name: Set up Node
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4.4.0
         with:
-          node-version: "latest"
+          node-version: "22"
 
-      - name: Install Mintlify CLI
-        run: npm i -g mintlify
+      - name: Install Mint CLI
+        run: npm i -g mint@4.2.741
+
+      # Pruning immutable snapshots keeps the check fast (--files still parses every
+      # page); the default version must stay because unprefixed links resolve to it.
+      - name: Prune frozen doc versions (keep edge and latest)
+        if: github.event_name != 'workflow_dispatch'
+        run: |
+          python3 - <<'EOF'
+          import json
+          import shutil
+          from pathlib import Path
+
+          docs = Path("docs")
+          spec_path = docs / "docs.json"
+          spec = json.loads(spec_path.read_text())
+
+          keep_dirs = {"edge"}
+          for lang in spec["navigation"]["languages"]:
+              kept = [v for v in lang["versions"] if v["version"] == "Edge" or v.get("default")]
+              lang["versions"] = kept
+              keep_dirs.update(v["version"] for v in kept if v["version"] != "Edge")
+
+          missing = [d for d in keep_dirs if not (docs / d).is_dir()]
+          if missing:
+              raise SystemExit(f"docs.json version labels do not match directories: {missing}")
+
+          spec_path.write_text(json.dumps(spec, indent=2))
+
+          for path in docs.glob("v*"):
+              if path.is_dir() and path.name not in keep_dirs:
+                  shutil.rmtree(path)
+          EOF
 
       - name: Run broken link checker
-        run: |
-          # Auto-answer the prompt with yes command
-          yes "" | mintlify broken-links || test $? -eq 141
+        run: mint broken-links
         working-directory: ./docs

.github/workflows/generate-tool-specs.yml

@@ -0,0 +1,64 @@
+name: Generate Tool Specifications
+
+on:
+  pull_request:
+    branches:
+      - main
+    paths:
+      - 'lib/crewai-tools/src/crewai_tools/**'
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  generate-specs:
+    if: github.event_name == 'workflow_dispatch' || github.event.pull_request.head.repo.full_name == github.repository
+    runs-on: ubuntu-latest
+    env:
+      PYTHONUNBUFFERED: 1
+
+    steps:
+      - name: Generate GitHub App token
+        id: app-token
+        uses: actions/create-github-app-token@bcd2ba49218906704ab6c1aa796996da409d3eb1 # v3.2.0
+        with:
+          app-id: ${{ secrets.CREWAI_TOOL_SPECS_APP_ID }}
+          private-key: ${{ secrets.CREWAI_TOOL_SPECS_PRIVATE_KEY }}
+
+      - name: Checkout code
+        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        with:
+          ref: ${{ github.head_ref }}
+          token: ${{ steps.app-token.outputs.token }}
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@d0cc045d04ccac9d8b7881df0226f9e82c39688e # v6
+        with:
+          version: "0.11.3"
+          python-version: "3.12"
+          enable-cache: true
+
+      - name: Install the project
+        working-directory: lib/crewai-tools
+        run: uv sync --dev --all-extras
+
+      - name: Generate tool specifications
+        working-directory: lib/crewai-tools
+        run: uv run python src/crewai_tools/generate_tool_specs.py
+
+      - name: Check for changes and commit
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+
+          git add lib/crewai-tools/tool.specs.json
+
+          if git diff --quiet --staged; then
+            echo "No changes detected in tool.specs.json"
+          else
+            echo "Changes detected in tool.specs.json, committing..."
+            git commit -m "chore: update tool specifications"
+            git push
+          fi

.github/workflows/linter.yml

@@ -6,21 +6,31 @@ permissions:
   contents: read
 
 jobs:
-  lint:
+  changes:
+    name: Detect changes
     runs-on: ubuntu-latest
-    env:
-      TARGET_BRANCH: ${{ github.event.pull_request.base.ref }}
+    outputs:
+      code: ${{ steps.filter.outputs.code }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+      - uses: dorny/paths-filter@d1c1ffe0248fe513906c8e24db8ea791d46f8590 # v3
+        id: filter
         with:
-          fetch-depth: 0
+          filters: |
+            code:
+              - '!docs/**'
+              - '!**/*.md'
 
-      - name: Fetch Target Branch
-        run: git fetch origin $TARGET_BRANCH --depth=1
+  lint-run:
+    needs: changes
+    if: needs.changes.outputs.code == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
 
       - name: Restore global uv cache
         id: cache-restore
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
         with:
           path: |
             ~/.cache/uv
@@ -31,39 +41,47 @@ jobs:
             uv-main-py3.11-
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@d0cc045d04ccac9d8b7881df0226f9e82c39688e # v6
         with:
-          version: "0.8.4"
+          version: "0.11.3"
           python-version: "3.11"
           enable-cache: false
 
       - name: Install dependencies
         run: uv sync --all-groups --all-extras --no-install-project
 
-      - name: Get Changed Python Files
-        id: changed-files
-        run: |
-          merge_base=$(git merge-base origin/"$TARGET_BRANCH" HEAD)
-          changed_files=$(git diff --name-only --diff-filter=ACMRTUB "$merge_base" | grep '\.py$' || true)
-          echo "files<<EOF" >> $GITHUB_OUTPUT
-          echo "$changed_files" >> $GITHUB_OUTPUT
-          echo "EOF" >> $GITHUB_OUTPUT
+      - name: Ruff check
+        run: uv run ruff check lib/
 
-      - name: Run Ruff on Changed Files
-        if: ${{ steps.changed-files.outputs.files != '' }}
-        run: |
-         echo "${{ steps.changed-files.outputs.files }}" \
-           | tr ' ' '\n' \
-           | grep -v 'src/crewai/cli/templates/' \
-           | grep -v '/tests/' \
-           | xargs -I{} uv run ruff check "{}"
+      - name: Ruff format
+        run: uv run ruff format --check lib/
 
       - name: Save uv caches
         if: steps.cache-restore.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
         with:
           path: |
             ~/.cache/uv
             ~/.local/share/uv
             .venv
           key: uv-main-py3.11-${{ hashFiles('uv.lock') }}
+
+  # Summary job to provide single status for branch protection
+  lint:
+    name: lint
+    runs-on: ubuntu-latest
+    needs: [changes, lint-run]
+    if: always()
+    steps:
+      - name: Check results
+        run: |
+          if [ "${{ needs.changes.outputs.code }}" != "true" ]; then
+            echo "Docs-only change, skipping lint"
+            exit 0
+          fi
+          if [ "${{ needs.lint-run.result }}" == "success" ]; then
+            echo "Lint passed"
+          else
+            echo "Lint failed"
+            exit 1
+          fi

.github/workflows/nightly.yml

@@ -0,0 +1,138 @@
+name: Nightly Canary Release
+
+on:
+  schedule:
+    - cron: '0 6 * * *' # daily at 6am UTC
+  workflow_dispatch:
+
+concurrency:
+  group: nightly-publish
+  cancel-in-progress: false
+
+jobs:
+  check:
+    name: Check for new commits
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    outputs:
+      has_changes: ${{ steps.check.outputs.has_changes }}
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        with:
+          fetch-depth: 0
+
+      - name: Check for recent commits
+        id: check
+        run: |
+          # 25h window absorbs cron-vs-commit timing skew at the boundary.
+          RECENT=$(git log --since="25 hours ago" --oneline | head -1)
+          if [ -n "$RECENT" ]; then
+            echo "has_changes=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "has_changes=false" >> "$GITHUB_OUTPUT"
+          fi
+
+  build:
+    name: Build nightly packages
+    needs: check
+    if: needs.check.outputs.has_changes == 'true' || github.event_name == 'workflow_dispatch'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@d0cc045d04ccac9d8b7881df0226f9e82c39688e # v6
+        with:
+          version: "0.11.3"
+          python-version: "3.12"
+          enable-cache: false
+
+      - name: Stamp nightly versions
+        run: |
+          DATE=$(date +%Y%m%d)
+
+          # All workspace packages share the same base version and are released together.
+          BASE=$(python -c "
+          import re
+          print(re.search(r'__version__\s*=\s*\"(.*?)\"', open('lib/crewai/src/crewai/__init__.py').read()).group(1))
+          ")
+          NIGHTLY="${BASE}.dev${DATE}"
+          echo "Nightly version: ${NIGHTLY}"
+
+          for init_file in \
+            lib/crewai/src/crewai/__init__.py \
+            lib/crewai-core/src/crewai_core/__init__.py \
+            lib/crewai-tools/src/crewai_tools/__init__.py \
+            lib/crewai-files/src/crewai_files/__init__.py \
+            lib/cli/src/crewai_cli/__init__.py; do
+            sed -i "s/__version__ = .*/__version__ = \"${NIGHTLY}\"/" "$init_file"
+            echo "Stamped $init_file -> $NIGHTLY"
+          done
+
+          # Update all cross-package dependency pins to the nightly version.
+          sed -i "s/\"crewai==[^\"]*\"/\"crewai==${NIGHTLY}\"/" lib/crewai-tools/pyproject.toml
+          sed -i "s/\"crewai-core==[^\"]*\"/\"crewai-core==${NIGHTLY}\"/" lib/crewai/pyproject.toml
+          sed -i "s/\"crewai-cli==[^\"]*\"/\"crewai-cli==${NIGHTLY}\"/" lib/crewai/pyproject.toml
+          sed -i "s/\"crewai-tools==[^\"]*\"/\"crewai-tools==${NIGHTLY}\"/" lib/crewai/pyproject.toml
+          sed -i "s/\"crewai-files==[^\"]*\"/\"crewai-files==${NIGHTLY}\"/" lib/crewai/pyproject.toml
+          sed -i "s/\"crewai-core==[^\"]*\"/\"crewai-core==${NIGHTLY}\"/" lib/cli/pyproject.toml
+          echo "Updated cross-package dependency pins to ${NIGHTLY}"
+
+      - name: Build packages
+        run: |
+          uv build --all-packages
+          rm dist/.gitignore
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    name: Publish nightly to PyPI
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - name: Install uv
+        uses: astral-sh/setup-uv@d0cc045d04ccac9d8b7881df0226f9e82c39688e # v6
+        with:
+          version: "0.11.3"
+          python-version: "3.12"
+          enable-cache: false
+
+      - name: Download artifacts
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+        with:
+          name: dist
+          path: dist
+
+      - name: Publish to PyPI
+        env:
+          UV_PUBLISH_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+        run: |
+          failed=0
+          for package in dist/*; do
+            if [[ "$package" == *"crewai_devtools"* ]]; then
+              echo "Skipping private package: $package"
+              continue
+            fi
+            echo "Publishing $package"
+            # --check-url skips files already on PyPI so manual re-runs on the same day are idempotent.
+            if ! uv publish --check-url https://pypi.org/simple/ "$package"; then
+              echo "Failed to publish $package"
+              failed=1
+            fi
+          done
+          if [ $failed -eq 1 ]; then
+            echo "Some packages failed to publish"
+            exit 1
+          fi

.github/workflows/notify-downstream.yml

@@ -1,33 +0,0 @@
-name: Notify Downstream
-
-on:
-  push:
-    branches:
-      - main
-
-permissions:
-  contents: read
-
-jobs:
-  notify-downstream:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Generate GitHub App token
-        id: app-token
-        uses: tibdex/github-app-token@v2
-        with:
-          app_id: ${{ secrets.OSS_SYNC_APP_ID }}
-          private_key: ${{ secrets.OSS_SYNC_APP_PRIVATE_KEY }}
-
-      - name: Notify Repo B
-        uses: peter-evans/repository-dispatch@v3
-        with:
-          token: ${{ steps.app-token.outputs.token }}
-          repository: ${{ secrets.OSS_SYNC_DOWNSTREAM_REPO }}
-          event-type: upstream-commit
-          client-payload: |
-            {
-              "commit_sha": "${{ github.sha }}"
-            }
-

.github/workflows/pr-size.yml

@@ -0,0 +1,32 @@
+name: PR Size Check
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+
+jobs:
+  pr-size:
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    steps:
+      - uses: codelytv/pr-size-labeler@095a41fca88b8764fd9e008ad269bcdb82bb38b9 # v1
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          xs_label: "size/XS"
+          xs_max_size: 25
+          s_label: "size/S"
+          s_max_size: 100
+          m_label: "size/M"
+          m_max_size: 250
+          l_label: "size/L"
+          l_max_size: 500
+          xl_label: "size/XL"
+          fail_if_xl: false
+          files_to_ignore: |
+            uv.lock
+            *.lock
+            lib/crewai/src/crewai/cli/templates/**
+            **/*.json
+            **/test_durations/**
+            **/cassettes/**

.github/workflows/pr-title.yml

@@ -0,0 +1,41 @@
+name: PR Title Check
+
+on:
+  pull_request:
+    types: [opened, edited, synchronize, reopened]
+
+permissions:
+  contents: read
+  pull-requests: read
+
+jobs:
+  pr-title:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: amannn/action-semantic-pull-request@e32d7e603df1aa1ba07e981f2a23455dee596825 # v5
+        continue-on-error: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          types: |
+            feat
+            fix
+            refactor
+            perf
+            test
+            docs
+            chore
+            ci
+            style
+            revert
+          requireScope: false
+          subjectPattern: ^[a-z].+[^.]$
+          subjectPatternError: >
+            The PR title "{title}" does not follow conventional commit format.
+
+            Expected: <type>(<scope>): <lowercase description without trailing period>
+
+            Examples:
+              feat(memory): add lancedb storage backend
+              fix(agents): resolve deadlock in concurrent execution
+              chore(deps): bump pydantic to 2.11.9

.github/workflows/publish.yml

@@ -1,9 +1,12 @@
 name: Publish to PyPI
 
 on:
-  release:
-    types: [ published ]
   workflow_dispatch:
+    inputs:
+      release_tag:
+        description: 'Release tag to publish'
+        required: false
+        type: string
 
 jobs:
   build:
@@ -12,15 +15,26 @@ jobs:
     permissions:
         contents: read
     steps:
-      - uses: actions/checkout@v4
+      - name: Determine release tag
+        id: release
+        run: |
+          if [ -n "${{ inputs.release_tag }}" ]; then
+            echo "tag=${{ inputs.release_tag }}" >> $GITHUB_OUTPUT
+          else
+            echo "tag=" >> $GITHUB_OUTPUT
+          fi
+
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        with:
+          ref: ${{ steps.release.outputs.tag || github.ref }}
 
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
         with:
           python-version: "3.12"
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v4
+        uses: astral-sh/setup-uv@38f3f104447c67c051c4a08e39b64a148898af3a # v4
 
       - name: Build packages
         run: |
@@ -28,7 +42,7 @@ jobs:
           rm dist/.gitignore
 
       - name: Upload artifacts
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
         with:
           name: dist
           path: dist/
@@ -44,17 +58,19 @@ jobs:
       id-token: write
       contents: read
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        with:
+          ref: ${{ inputs.release_tag || github.ref }}
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@d0cc045d04ccac9d8b7881df0226f9e82c39688e # v6
         with:
-          version: "0.8.4"
+          version: "0.11.3"
           python-version: "3.12"
           enable-cache: false
 
       - name: Download artifacts
-        uses: actions/download-artifact@v4
+        uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
         with:
           name: dist
           path: dist
@@ -79,3 +95,72 @@ jobs:
             echo "Some packages failed to publish"
             exit 1
           fi
+
+      - name: Build Slack payload
+        if: success()
+        id: slack
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          RELEASE_TAG: ${{ inputs.release_tag }}
+        run: |
+          payload=$(uv run python -c "
+          import json, re, subprocess, sys
+
+          with open('lib/crewai/src/crewai/__init__.py') as f:
+              m = re.search(r\"__version__\s*=\s*[\\\"']([^\\\"']+)\", f.read())
+          version = m.group(1) if m else 'unknown'
+
+          import os
+          tag = os.environ.get('RELEASE_TAG') or version
+
+          try:
+              r = subprocess.run(['gh','release','view',tag,'--json','body','-q','.body'],
+                                 capture_output=True, text=True, check=True)
+              body = r.stdout.strip()
+          except Exception:
+              body = ''
+
+          blocks = [
+              {'type':'section','text':{'type':'mrkdwn',
+                  'text':f':rocket: \`crewai v{version}\` published to PyPI'}},
+              {'type':'section','text':{'type':'mrkdwn',
+                  'text':f'<https://pypi.org/project/crewai/{version}/|View on PyPI> · <https://github.com/crewAIInc/crewAI/releases/tag/{tag}|Release notes>'}},
+              {'type':'divider'},
+          ]
+
+          if body:
+              heading, items = '', []
+              for line in body.split('\n'):
+                  line = line.strip()
+                  if not line: continue
+                  hm = re.match(r'^#{2,3}\s+(.*)', line)
+                  if hm:
+                      if heading and items:
+                          skip = heading in ('What\\'s Changed','') or 'Contributors' in heading
+                          if not skip:
+                              txt = f'*{heading}*\n' + '\n'.join(f'• {i}' for i in items)
+                              blocks.append({'type':'section','text':{'type':'mrkdwn','text':txt}})
+                      heading, items = hm.group(1), []
+                  elif line.startswith('- ') or line.startswith('* '):
+                      items.append(re.sub(r'\*\*([^*]*)\*\*', r'*\1*', line[2:]))
+              if heading and items:
+                  skip = heading in ('What\\'s Changed','') or 'Contributors' in heading
+                  if not skip:
+                      txt = f'*{heading}*\n' + '\n'.join(f'• {i}' for i in items)
+                      blocks.append({'type':'section','text':{'type':'mrkdwn','text':txt}})
+
+          blocks.append({'type':'divider'})
+          blocks.append({'type':'section','text':{'type':'mrkdwn',
+              'text':f'\`\`\`uv add \"crewai[tools]=={version}\"\`\`\`'}})
+
+          print(json.dumps({'blocks':blocks}))
+          ")
+          echo "payload=$payload" >> $GITHUB_OUTPUT
+
+      - name: Notify Slack
+        if: success()
+        uses: slackapi/slack-github-action@b0fa283ad8fea605de13dc3f449259339835fc52 # v2.1.0
+        with:
+          webhook: ${{ secrets.SLACK_WEBHOOK_URL }}
+          webhook-type: incoming-webhook
+          payload: ${{ steps.slack.outputs.payload }}

.github/workflows/stale.yml

@@ -14,7 +14,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/stale@v9
+    - uses: actions/stale@5bef64f19d7facfb25b37b414482c7164d639639 # v9.1.0
       with:
         repo-token: ${{ secrets.GITHUB_TOKEN }}
         stale-issue-label: 'no-issue-activity'

.github/workflows/tests.yml

@@ -6,8 +6,25 @@ permissions:
   contents: read
 
 jobs:
-  tests:
+  changes:
+    name: Detect changes
+    runs-on: ubuntu-latest
+    outputs:
+      code: ${{ steps.filter.outputs.code }}
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+      - uses: dorny/paths-filter@d1c1ffe0248fe513906c8e24db8ea791d46f8590 # v3
+        id: filter
+        with:
+          filters: |
+            code:
+              - '!docs/**'
+              - '!**/*.md'
+
+  tests-matrix:
     name: tests (${{ matrix.python-version }})
+    needs: changes
+    if: needs.changes.outputs.code == 'true'
     runs-on: ubuntu-latest
     timeout-minutes: 15
     strategy:
@@ -17,13 +34,13 @@ jobs:
         group: [1, 2, 3, 4, 5, 6, 7, 8]
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
         with:
           fetch-depth: 0  # Fetch all history for proper diff
 
       - name: Restore global uv cache
         id: cache-restore
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
         with:
           path: |
             ~/.cache/uv
@@ -34,9 +51,9 @@ jobs:
             uv-main-py${{ matrix.python-version }}-
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@d0cc045d04ccac9d8b7881df0226f9e82c39688e # v6
         with:
-          version: "0.8.4"
+          version: "0.11.3"
           python-version: ${{ matrix.python-version }}
           enable-cache: false
 
@@ -44,7 +61,7 @@ jobs:
         run: uv sync --all-groups --all-extras
 
       - name: Restore test durations
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
         with:
           path: .test_durations_py*
           key: test-durations-py${{ matrix.python-version }}
@@ -91,10 +108,30 @@ jobs:
 
       - name: Save uv caches
         if: steps.cache-restore.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
         with:
           path: |
             ~/.cache/uv
             ~/.local/share/uv
             .venv
           key: uv-main-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}
+
+  # Summary job to provide single status for branch protection
+  tests:
+    name: tests
+    runs-on: ubuntu-latest
+    needs: [changes, tests-matrix]
+    if: always()
+    steps:
+      - name: Check results
+        run: |
+          if [ "${{ needs.changes.outputs.code }}" != "true" ]; then
+            echo "Docs-only change, skipping tests"
+            exit 0
+          fi
+          if [ "${{ needs.tests-matrix.result }}" == "success" ]; then
+            echo "All tests passed"
+          else
+            echo "Tests failed"
+            exit 1
+          fi

.github/workflows/type-checker.yml

@@ -6,8 +6,25 @@ permissions:
   contents: read
 
 jobs:
+  changes:
+    name: Detect changes
+    runs-on: ubuntu-latest
+    outputs:
+      code: ${{ steps.filter.outputs.code }}
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+      - uses: dorny/paths-filter@d1c1ffe0248fe513906c8e24db8ea791d46f8590 # v3
+        id: filter
+        with:
+          filters: |
+            code:
+              - '!docs/**'
+              - '!**/*.md'
+
   type-checker-matrix:
     name: type-checker (${{ matrix.python-version }})
+    needs: changes
+    if: needs.changes.outputs.code == 'true'
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
@@ -16,13 +33,11 @@ jobs:
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0 # Fetch all history for proper diff
+        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
 
       - name: Restore global uv cache
         id: cache-restore
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
         with:
           path: |
             ~/.cache/uv
@@ -33,50 +48,21 @@ jobs:
             uv-main-py${{ matrix.python-version }}-
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@d0cc045d04ccac9d8b7881df0226f9e82c39688e # v6
         with:
-          version: "0.8.4"
+          version: "0.11.3"
           python-version: ${{ matrix.python-version }}
           enable-cache: false
 
       - name: Install dependencies
         run: uv sync --all-groups --all-extras
 
-      - name: Get changed Python files
-        id: changed-files
-        run: |
-          # Get the list of changed Python files compared to the base branch
-          echo "Fetching changed files..."
-          git diff --name-only --diff-filter=ACMRT origin/${{ github.base_ref }}...HEAD -- '*.py' > changed_files.txt
-
-          # Filter for files in src/ directory only (excluding tests/)
-          grep -E "^src/" changed_files.txt > filtered_changed_files.txt || true
-
-          # Check if there are any changed files
-          if [ -s filtered_changed_files.txt ]; then
-            echo "Changed Python files in src/:"
-            cat filtered_changed_files.txt
-            echo "has_changes=true" >> $GITHUB_OUTPUT
-            # Convert newlines to spaces for mypy command
-            echo "files=$(cat filtered_changed_files.txt | tr '\n' ' ')" >> $GITHUB_OUTPUT
-          else
-            echo "No Python files changed in src/"
-            echo "has_changes=false" >> $GITHUB_OUTPUT
-          fi
-
-      - name: Run type checks on changed files
-        if: steps.changed-files.outputs.has_changes == 'true'
-        run: |
-          echo "Running mypy on changed files with Python ${{ matrix.python-version }}..."
-          uv run mypy ${{ steps.changed-files.outputs.files }}
-
-      - name: No files to check
-        if: steps.changed-files.outputs.has_changes == 'false'
-        run: echo "No Python files in src/ were modified - skipping type checks"
+      - name: Run type checks
+        run: uv run mypy lib/
 
       - name: Save uv caches
         if: steps.cache-restore.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
         with:
           path: |
             ~/.cache/uv
@@ -88,14 +74,18 @@ jobs:
   type-checker:
     name: type-checker
     runs-on: ubuntu-latest
-    needs: type-checker-matrix
+    needs: [changes, type-checker-matrix]
     if: always()
     steps:
-      - name: Check matrix results
+      - name: Check results
         run: |
-          if [ "${{ needs.type-checker-matrix.result }}" == "success" ] || [ "${{ needs.type-checker-matrix.result }}" == "skipped" ]; then
-            echo "✅ All type checks passed"
+          if [ "${{ needs.changes.outputs.code }}" != "true" ]; then
+            echo "Docs-only change, skipping type checks"
+            exit 0
+          fi
+          if [ "${{ needs.type-checker-matrix.result }}" == "success" ]; then
+            echo "All type checks passed"
           else
-            echo "❌ Type checks failed"
+            echo "Type checks failed"
             exit 1
           fi

.github/workflows/update-test-durations.yml

@@ -23,11 +23,11 @@ jobs:
     
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
 
       - name: Restore global uv cache
         id: cache-restore
-        uses: actions/cache/restore@v4
+        uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
         with:
           path: |
             ~/.cache/uv
@@ -38,9 +38,9 @@ jobs:
             uv-main-py${{ matrix.python-version }}-
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v6
+        uses: astral-sh/setup-uv@d0cc045d04ccac9d8b7881df0226f9e82c39688e # v6
         with:
-          version: "0.8.4"
+          version: "0.11.3"
           python-version: ${{ matrix.python-version }}
           enable-cache: false
 
@@ -55,14 +55,14 @@ jobs:
 
       - name: Save durations to cache
         if: always()
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
         with:
           path: .test_durations_py*
           key: test-durations-py${{ matrix.python-version }}
 
       - name: Save uv caches
         if: steps.cache-restore.outputs.cache-hit != 'true'
-        uses: actions/cache/save@v4
+        uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
         with:
           path: |
             ~/.cache/uv

.github/workflows/vulnerability-scan.yml

@@ -0,0 +1,105 @@
+name: Vulnerability Scan
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+  schedule:
+    # Run weekly on Monday at 9:00 UTC
+    - cron: '0 9 * * 1'
+
+permissions:
+  contents: read
+
+jobs:
+  pip-audit:
+    name: pip-audit
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4.3.1
+        with:
+          persist-credentials: false
+
+      - name: Restore global uv cache
+        id: cache-restore
+        uses: actions/cache/restore@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        with:
+          path: |
+            ~/.cache/uv
+            ~/.local/share/uv
+            .venv
+          key: uv-main-py3.11-${{ hashFiles('uv.lock') }}
+          restore-keys: |
+            uv-main-py3.11-
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@d0cc045d04ccac9d8b7881df0226f9e82c39688e # v6
+        with:
+          version: "0.11.3"
+          python-version: "3.11"
+          enable-cache: false
+
+      - name: Install dependencies
+        run: uv sync --all-groups --all-extras --no-install-project
+
+      - name: Install pip-audit
+        run: uv pip install pip-audit
+
+      - name: Run pip-audit
+        run: |
+          pip_audit_args=(
+            --desc
+            --aliases
+            --skip-editable
+            --format json
+            --output pip-audit-report.json
+            --ignore-vuln PYSEC-2026-597      # nltk 3.9.4 (CVE-2026-12243): no fix available, transitive through crewai-tools[xml] -> unstructured.
+            --ignore-vuln GHSA-rrmf-rvhw-rf47 # torch 2.12.0 (CVE-2025-3000): local-only memory corruption in torch.jit.script; no fix available.
+            --ignore-vuln GHSA-f4j7-r4q5-qw2c # chromadb 1.1.1 (CVE-2026-45829): pre-auth RCE in the HTTP server; no fix available.
+          )
+          uv run pip-audit "${pip_audit_args[@]}"
+        continue-on-error: true
+
+      - name: Display results
+        if: always()
+        run: |
+          if [ -f pip-audit-report.json ]; then
+            echo "## pip-audit Results" >> $GITHUB_STEP_SUMMARY
+            echo '```json' >> $GITHUB_STEP_SUMMARY
+            cat pip-audit-report.json | python3 -m json.tool >> $GITHUB_STEP_SUMMARY
+            echo '```' >> $GITHUB_STEP_SUMMARY
+            # Fail if vulnerabilities found
+            python3 -c "
+          import json, sys
+          with open('pip-audit-report.json') as f:
+              data = json.load(f)
+          vulns = [d for d in data.get('dependencies', []) if d.get('vulns')]
+          if vulns:
+              print(f'::error::Found vulnerabilities in {len(vulns)} package(s)')
+              for v in vulns:
+                  for vuln in v['vulns']:
+                      print(f'  - {v[\"name\"]}=={v[\"version\"]}: {vuln[\"id\"]}')
+              sys.exit(1)
+          print('No known vulnerabilities found')
+          "
+          else
+            echo "::error::pip-audit failed to produce a report. Check the pip-audit step logs."
+            exit 1
+          fi
+
+      - name: Upload pip-audit report
+        if: always()
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: pip-audit-report
+          path: pip-audit-report.json
+
+      - name: Save uv caches
+        if: steps.cache-restore.outputs.cache-hit != 'true'
+        uses: actions/cache/save@0057852bfaa89a56745cba8c7296529d2fc39830 # v4.3.0
+        with:
+          path: |
+            ~/.cache/uv
+            ~/.local/share/uv
+            .venv
+          key: uv-main-py3.11-${{ hashFiles('uv.lock') }}

.gitignore

@@ -26,3 +26,10 @@ plan.md
 conceptual_plan.md
 build_image
 chromadb-*.lock
+.claude
+.crewai/memory
+blogs/*
+secrets/*
+UNKNOWN.egg-info/
+demos/*
+.crewai/*

.pre-commit-config.yaml

@@ -19,9 +19,52 @@ repos:
         language: system
         pass_filenames: true
         types: [python]
-        exclude: ^(lib/crewai/src/crewai/cli/templates/|lib/crewai/tests/|lib/crewai-tools/tests/)
+        exclude: ^(lib/crewai/src/crewai/cli/templates/|lib/cli/src/crewai_cli/templates/|lib/cli/tests/|lib/crewai/tests/|lib/crewai-tools/tests/|lib/crewai-files/tests/|lib/devtools/tests/)
   - repo: https://github.com/astral-sh/uv-pre-commit
-    rev: 0.9.3
+    rev: 0.11.3
     hooks:
       - id: uv-lock
+  - repo: local
+    hooks:
+      - id: pip-audit
+        name: pip-audit
+        # Keep this ignore list in sync with .github/workflows/vulnerability-scan.yml.
+        entry: >-
+          bash -c 'source .venv/bin/activate && uv run pip-audit --skip-editable
+          --ignore-vuln PYSEC-2024-277
+          --ignore-vuln PYSEC-2026-89
+          --ignore-vuln PYSEC-2026-97
+          --ignore-vuln PYSEC-2026-597
+          --ignore-vuln PYSEC-2025-148
+          --ignore-vuln PYSEC-2025-183
+          --ignore-vuln PYSEC-2025-189
+          --ignore-vuln PYSEC-2025-190
+          --ignore-vuln PYSEC-2025-191
+          --ignore-vuln PYSEC-2025-192
+          --ignore-vuln PYSEC-2025-193
+          --ignore-vuln PYSEC-2025-194
+          --ignore-vuln PYSEC-2025-195
+          --ignore-vuln PYSEC-2025-196
+          --ignore-vuln PYSEC-2025-197
+          --ignore-vuln PYSEC-2025-210
+          --ignore-vuln PYSEC-2026-139
+          --ignore-vuln GHSA-rrmf-rvhw-rf47
+          --ignore-vuln PYSEC-2025-211
+          --ignore-vuln PYSEC-2025-212
+          --ignore-vuln PYSEC-2025-213
+          --ignore-vuln PYSEC-2025-214
+          --ignore-vuln PYSEC-2025-215
+          --ignore-vuln PYSEC-2025-216
+          --ignore-vuln PYSEC-2025-217
+          --ignore-vuln PYSEC-2025-218
+          --ignore-vuln GHSA-f4j7-r4q5-qw2c' --
+        language: system
+        pass_filenames: false
+        stages: [pre-push, manual]
+  - repo: https://github.com/commitizen-tools/commitizen
+    rev: v4.10.1
+    hooks:
+      - id: commitizen
+      - id: commitizen-branch
+        stages: [ pre-push ]
 

.python-version

@@ -0,0 +1 @@
+3.13

AGENTS.md

@@ -0,0 +1,26 @@
+# Agent Instructions for CrewAI OSS
+
+CrewAI is a Python based framework for building AI agents and agentic systems.
+Follow these guidelines when contributing:
+
+## Key Guidelines
+
+1. Follow Python best practices and idiomatic patterns.
+2. Maintain existing code structure and organization.
+3. Write unit tests for new functionality focusing on behaivor and not
+   implementation.
+4. Document public APIs and complex logic.
+5. Suggest changes to the `docs/` folder when appropriate
+6. Follow software principles such as DRY and YAGNI.
+7. Keep diffs as minimal as possible.
+
+## Changing Docs
+
+1. Edit MDX under `docs/edge/en/*` and reference it from `docs/docs.json` if
+   needed.
+2. Do not modify files under `docs/v*/`. Those are frozen release snapshots
+   managed by devtools.
+3. Do not delete or rename files under `docs/images/` as frozen snapshots
+   may reference them.
+4. If you want to preview your changes locally, use `cd docs && mintlify dev`.
+   To check for broken links, run `cd docs && mintlify broken-links`.

README.md

@@ -12,6 +12,8 @@
 <p align="center">
   <a href="https://crewai.com">Homepage</a>
   ·
+  <a href="https://crewai.com/open-source">Open Source</a>
+  ·
   <a href="https://docs.crewai.com">Docs</a>
   ·
   <a href="https://app.crewai.com">Start Cloud Trial</a>
@@ -53,20 +55,20 @@
 
 ### Fast and Flexible Multi-Agent Automation Framework
 
-> CrewAI is a lean, lightning-fast Python framework built entirely from scratch—completely **independent of LangChain or other agent frameworks**.
-> It empowers developers with both high-level simplicity and precise low-level control, ideal for creating autonomous AI agents tailored to any scenario.
+> CrewAI is an open-source Python framework with high-level abstractions and low-level APIs for building production-ready multi-agent workflows.
+> It gives developers autonomous agent collaboration through Crews and precise, event-driven control through Flows.
 
-- **CrewAI Crews**: Optimize for autonomy and collaborative intelligence.
-- **CrewAI Flows**: Enable granular, event-driven control, single LLM calls for precise task orchestration and supports Crews natively
+- **CrewAI Crews**: Optimize for autonomy and collaborative intelligence with role-based AI agents.
+- **CrewAI Flows**: Build event-driven automations that combine precise workflow control, single LLM calls, and native support for Crews.
 
 With over 100,000 developers certified through our community courses at [learn.crewai.com](https://learn.crewai.com), CrewAI is rapidly becoming the
-standard for enterprise-ready AI automation.
+standard for production-ready agentic automation.
 
-# CrewAI AOP Suite
+# CrewAI AMP Suite
 
-CrewAI AOP Suite is a comprehensive bundle tailored for organizations that require secure, scalable, and easy-to-manage agent-driven automation.
+For organizations that need a commercial control plane around CrewAI, [CrewAI AMP Suite](https://www.crewai.com/enterprise) adds managed deployment, observability, governance, security, and enterprise support.
 
-You can try one part of the suite the [Crew Control Plane for free](https://app.crewai.com)
+You can try one part of the suite, the [Crew Control Plane, for free](https://app.crewai.com).
 
 ## Crew Control Plane Key Features:
 
@@ -76,18 +78,18 @@ You can try one part of the suite the [Crew Control Plane for free](https://app.
 - **Advanced Security**: Built-in robust security and compliance measures ensuring safe deployment and management.
 - **Actionable Insights**: Real-time analytics and reporting to optimize performance and decision-making.
 - **24/7 Support**: Dedicated enterprise support to ensure uninterrupted operation and quick resolution of issues.
-- **On-premise and Cloud Deployment Options**: Deploy CrewAI AOP on-premise or in the cloud, depending on your security and compliance requirements.
+- **On-premise and Cloud Deployment Options**: Deploy CrewAI AMP on-premise or in the cloud, depending on your security and compliance requirements.
 
-CrewAI AOP is designed for enterprises seeking a powerful, reliable solution to transform complex business processes into efficient,
+CrewAI AMP is designed for enterprises seeking a powerful, reliable solution to transform complex business processes into efficient,
 intelligent automations.
 
 ## Table of contents
 
+- [Build with AI](#build-with-ai)
 - [Why CrewAI?](#why-crewai)
 - [Getting Started](#getting-started)
 - [Key Features](#key-features)
 - [Understanding Flows and Crews](#understanding-flows-and-crews)
-- [CrewAI vs LangGraph](#how-crewai-compares)
 - [Examples](#examples)
   - [Quick Tutorial](#quick-tutorial)
   - [Write Job Descriptions](#write-job-descriptions)
@@ -95,11 +97,37 @@ intelligent automations.
   - [Stock Analysis](#stock-analysis)
   - [Using Crews and Flows Together](#using-crews-and-flows-together)
 - [Connecting Your Crew to a Model](#connecting-your-crew-to-a-model)
-- [How CrewAI Compares](#how-crewai-compares)
-- [Frequently Asked Questions (FAQ)](#frequently-asked-questions-faq)
+- [When to Use CrewAI](#when-to-use-crewai)
 - [Contribution](#contribution)
 - [Telemetry](#telemetry)
 - [License](#license)
+- [Frequently Asked Questions (FAQ)](#frequently-asked-questions-faq)
+
+## Build with AI
+
+Using an AI coding agent? Teach it CrewAI best practices in one command:
+
+**Claude Code:**
+```shell
+/plugin marketplace add crewAIInc/skills
+/plugin install crewai-skills@crewai-plugins
+/reload-plugins
+```
+Four skills that activate automatically when you ask relevant CrewAI questions:
+
+| Skill | When it runs |
+|-------|--------------|
+| `getting-started` | Scaffolding new projects, choosing between `LLM.call()` / `Agent` / `Crew` / `Flow`, wiring `crew.py` / `main.py` |
+| `design-agent` | Configuring agents — role, goal, backstory, tools, LLMs, memory, guardrails |
+| `design-task` | Writing task descriptions, dependencies, structured output (`output_pydantic`, `output_json`), human review |
+| `ask-docs` | Querying the live [CrewAI docs MCP server](https://docs.crewai.com/mcp) for up-to-date API details |
+
+**Cursor, Codex, Windsurf, and others ([skills.sh](https://skills.sh/crewaiinc/skills)):**
+```shell
+npx skills add crewaiinc/skills
+```
+
+This installs the official [CrewAI Skills](https://github.com/crewAIInc/skills) — structured instructions that teach coding agents how to scaffold Flows, configure Crews, design agents and tasks, and follow CrewAI patterns.
 
 ## Why CrewAI?
 
@@ -107,15 +135,15 @@ intelligent automations.
   <img src="docs/images/asset.png" alt="CrewAI Logo" width="100%">
 </div>
 
-CrewAI unlocks the true potential of multi-agent automation, delivering the best-in-class combination of speed, flexibility, and control with either Crews of AI Agents or Flows of Events:
+CrewAI unlocks the true potential of multi-agent automation, delivering speed, flexibility, and control through Crews of AI agents and event-driven Flows:
 
-- **Standalone Framework**: Built from scratch, independent of LangChain or any other agent framework.
+- **Purpose-built architecture**: Designed specifically for agent orchestration, with a lightweight Python core and clean primitives for real-world automation.
 - **High Performance**: Optimized for speed and minimal resource usage, enabling faster execution.
-- **Flexible Low Level Customization**: Complete freedom to customize at both high and low levels - from overall workflows and system architecture to granular agent behaviors, internal prompts, and execution logic.
-- **Ideal for Every Use Case**: Proven effective for both simple tasks and highly complex, real-world, enterprise-grade scenarios.
+- **Flexible Low-Level Customization**: Complete freedom to customize everything from workflows and system architecture to agent behaviors, internal prompts, and execution logic.
+- **Ideal for Every Use Case**: Proven effective for simple tasks, complex workflows, and production-grade automation.
 - **Robust Community**: Backed by a rapidly growing community of over **100,000 certified** developers offering comprehensive support and resources.
 
-CrewAI empowers developers and enterprises to confidently build intelligent automations, bridging the gap between simplicity, flexibility, and performance.
+CrewAI empowers developers and teams to build intelligent automations that balance simplicity, flexibility, and production-grade control.
 
 ## Getting Started
 
@@ -124,7 +152,8 @@ Setup and run your first CrewAI agents by following this tutorial.
 [![CrewAI Getting Started Tutorial](https://img.youtube.com/vi/-kSOTtYzgEw/hqdefault.jpg)](https://www.youtube.com/watch?v=-kSOTtYzgEw "CrewAI Getting Started Tutorial")
 
 ###
- Learning Resources
+
+Learning Resources
 
 Learn CrewAI through our comprehensive courses:
 
@@ -141,6 +170,7 @@ CrewAI offers two powerful, complementary approaches that work seamlessly togeth
    - Dynamic task delegation and collaboration
    - Specialized roles with defined goals and expertise
    - Flexible problem-solving approaches
+
 2. **Flows**: Production-ready, event-driven workflows that deliver precise control over complex automations. Flows provide:
 
    - Fine-grained control over execution paths for real-world scenarios
@@ -166,13 +196,13 @@ Ensure you have Python >=3.10 <3.14 installed on your system. CrewAI uses [UV](h
 First, install CrewAI:
 
 ```shell
-pip install crewai
+uv pip install crewai
 ```
 
 If you want to install the 'crewai' package along with its optional features that include additional tools for agents, you can do so by using the following command:
 
 ```shell
-pip install 'crewai[tools]'
+uv pip install 'crewai[tools]'
 ```
 
 The command above installs the basic package and also adds extra components which require more dependencies to function.
@@ -185,14 +215,15 @@ If you encounter issues during installation or usage, here are some common solut
 
 1. **ModuleNotFoundError: No module named 'tiktoken'**
 
-   - Install tiktoken explicitly: `pip install 'crewai[embeddings]'`
-   - If using embedchain or other tools: `pip install 'crewai[tools]'`
+   - Install tiktoken explicitly: `uv pip install 'crewai[embeddings]'`
+   - If using embedchain or other tools: `uv pip install 'crewai[tools]'`
+
 2. **Failed building wheel for tiktoken**
 
    - Ensure Rust compiler is installed (see installation steps above)
    - For Windows: Verify Visual C++ Build Tools are installed
-   - Try upgrading pip: `pip install --upgrade pip`
-   - If issues persist, use a pre-built wheel: `pip install tiktoken --prefer-binary`
+   - Try upgrading pip: `uv pip install --upgrade pip`
+   - If issues persist, use a pre-built wheel: `uv pip install tiktoken --prefer-binary`
 
 ### 2. Setting Up Your Crew with the YAML Configuration
 
@@ -270,7 +301,7 @@ reporting_analyst:
 
 **tasks.yaml**
 
-```yaml
+````yaml
 # src/my_project/config/tasks.yaml
 research_task:
   description: >
@@ -290,7 +321,7 @@ reporting_task:
     Formatted as markdown without '```'
   agent: reporting_analyst
   output_file: report.md
-```
+````
 
 **crew.py**
 
@@ -403,16 +434,17 @@ In addition to the sequential process, you can use the hierarchical process, whi
 
 ## Key Features
 
-CrewAI stands apart as a lean, standalone, high-performance multi-AI Agent framework delivering simplicity, flexibility, and precise control—free from the complexity and limitations found in other agent frameworks.
+CrewAI gives developers a practical foundation for building agentic systems that move from prototype to production: autonomous collaboration where it helps, explicit workflow control where it matters, and Python-native customization throughout.
 
-- **Standalone & Lean**: Completely independent from other frameworks like LangChain, offering faster execution and lighter resource demands.
-- **Flexible & Precise**: Easily orchestrate autonomous agents through intuitive [Crews](https://docs.crewai.com/concepts/crews) or precise [Flows](https://docs.crewai.com/concepts/flows), achieving perfect balance for your needs.
-- **Seamless Integration**: Effortlessly combine Crews (autonomy) and Flows (precision) to create complex, real-world automations.
-- **Deep Customization**: Tailor every aspect—from high-level workflows down to low-level internal prompts and agent behaviors.
-- **Reliable Performance**: Consistent results across simple tasks and complex, enterprise-level automations.
-- **Thriving Community**: Backed by robust documentation and over 100,000 certified developers, providing exceptional support and guidance.
+- **Crews for autonomy**: Model teams of specialized AI agents with roles, goals, tools, and tasks.
+- **Flows for control**: Build event-driven workflows with state, branching, routing, and production logic.
+- **Seamless integration**: Combine Crews and Flows to create complex, real-world automations.
+- **Python-native customization**: Customize prompts, tools, execution paths, state, and integrations without fighting the framework.
+- **Agent-ready capabilities**: Use tools, memory, knowledge, checkpointing, async execution, and MCP/A2A support for more capable production agents.
+- **Production-ready patterns**: Add deterministic steps, human input, structured outputs, and checkpointing as your system grows.
+- **Thriving community**: Backed by robust documentation and over 100,000 certified developers, providing exceptional support and guidance.
 
-Choose CrewAI to easily build powerful, adaptable, and production-ready AI automations.
+Choose CrewAI to build powerful, adaptable, and production-ready AI automations.
 
 ## Examples
 
@@ -550,16 +582,17 @@ CrewAI supports using various LLMs through a variety of connection options. By d
 
 Please refer to the [Connect CrewAI to LLMs](https://docs.crewai.com/how-to/LLM-Connections/) page for details on configuring your agents' connections to models.
 
-## How CrewAI Compares
+## When to Use CrewAI
 
-**CrewAI's Advantage**: CrewAI combines autonomous agent intelligence with precise workflow control through its unique Crews and Flows architecture. The framework excels at both high-level orchestration and low-level customization, enabling complex, production-grade systems with granular control.
+Use CrewAI when you need more than a single prompt or chatbot: multi-step work, specialized agents, tool use, structured outputs, human review, or workflows that combine autonomous reasoning with explicit business logic.
 
-- **LangGraph**: While LangGraph provides a foundation for building agent workflows, its approach requires significant boilerplate code and complex state management patterns. The framework's tight coupling with LangChain can limit flexibility when implementing custom agent behaviors or integrating with external systems.
+CrewAI is especially useful when you want to:
 
-*P.S. CrewAI demonstrates significant performance advantages over LangGraph, executing 5.76x faster in certain cases like this QA task example ([see comparison](https://github.com/crewAIInc/crewAI-examples/tree/main/Notebooks/CrewAI%20Flows%20%26%20Langgraph/QA%20Agent)) while achieving higher evaluation scores with faster completion times in certain coding tasks, like in this example ([detailed analysis](https://github.com/crewAIInc/crewAI-examples/blob/main/Notebooks/CrewAI%20Flows%20%26%20Langgraph/Coding%20Assistant/coding_assistant_eval.ipynb)).*
-
-- **Autogen**: While Autogen excels at creating conversational agents capable of working together, it lacks an inherent concept of process. In Autogen, orchestrating agents' interactions requires additional programming, which can become complex and cumbersome as the scale of tasks grows.
-- **ChatDev**: ChatDev introduced the idea of processes into the realm of AI agents, but its implementation is quite rigid. Customizations in ChatDev are limited and not geared towards production environments, which can hinder scalability and flexibility in real-world applications.
+- Coordinate multiple agents with clear roles and tasks.
+- Wrap agent work in deterministic, event-driven workflows.
+- Keep application logic in regular Python.
+- Move from experiment to production without changing frameworks.
+- Add tools, memory, checkpointing, and async execution as your system grows.
 
 ## Contribution
 
@@ -571,6 +604,19 @@ CrewAI is open-source and we welcome contributions. If you're looking to contrib
 - Send a pull request.
 - We appreciate your input!
 
+### Contributing to the docs
+
+The site at [docs.crewai.com](https://docs.crewai.com) is published from
+`docs/` by [Mintlify](https://www.mintlify.com/). The docs use directory-based
+versioning: edits to `docs/edge/<lang>/...` (e.g.
+`docs/edge/en/concepts/agents.mdx`) land under the **Edge** version selector
+immediately and are frozen into a new versioned snapshot under
+`docs/v<X.Y.Z>/` at the next release cut. Frozen snapshots are immutable — CI
+rejects PRs that modify them without a `[docs-freeze]` title prefix. The
+release CLI (`devtools release`) handles the freeze automatically; see
+[`AGENTS.md`](AGENTS.md) for the full contributor guide and
+[`RELEASING.md`](RELEASING.md) for the release-cut runbook.
+
 ### Installing Dependencies
 
 ```bash
@@ -611,7 +657,7 @@ uv build
 ### Installing Locally
 
 ```bash
-pip install dist/*.tar.gz
+uv pip install dist/*.tar.gz
 ```
 
 ## Telemetry
@@ -655,7 +701,7 @@ CrewAI is released under the [MIT License](https://github.com/crewAIInc/crewAI/b
 
 - [What exactly is CrewAI?](#q-what-exactly-is-crewai)
 - [How do I install CrewAI?](#q-how-do-i-install-crewai)
-- [Does CrewAI depend on LangChain?](#q-does-crewai-depend-on-langchain)
+- [Is CrewAI a standalone framework?](#q-is-crewai-a-standalone-framework)
 - [Is CrewAI open-source?](#q-is-crewai-open-source)
 - [Does CrewAI collect data from users?](#q-does-crewai-collect-data-from-users)
 
@@ -664,7 +710,6 @@ CrewAI is released under the [MIT License](https://github.com/crewAIInc/crewAI/b
 - [Can CrewAI handle complex use cases?](#q-can-crewai-handle-complex-use-cases)
 - [Can I use CrewAI with local AI models?](#q-can-i-use-crewai-with-local-ai-models)
 - [What makes Crews different from Flows?](#q-what-makes-crews-different-from-flows)
-- [How is CrewAI better than LangChain?](#q-how-is-crewai-better-than-langchain)
 - [Does CrewAI support fine-tuning or training custom models?](#q-does-crewai-support-fine-tuning-or-training-custom-models)
 
 ### Resources and Community
@@ -674,31 +719,31 @@ CrewAI is released under the [MIT License](https://github.com/crewAIInc/crewAI/b
 
 ### Enterprise Features
 
-- [What additional features does CrewAI AOP offer?](#q-what-additional-features-does-crewai-amp-offer)
-- [Is CrewAI AOP available for cloud and on-premise deployments?](#q-is-crewai-amp-available-for-cloud-and-on-premise-deployments)
-- [Can I try CrewAI AOP for free?](#q-can-i-try-crewai-amp-for-free)
+- [What additional features does CrewAI AMP offer?](#q-what-additional-features-does-crewai-amp-offer)
+- [Is CrewAI AMP available for cloud and on-premise deployments?](#q-is-crewai-amp-available-for-cloud-and-on-premise-deployments)
+- [Can I try CrewAI AMP for free?](#q-can-i-try-crewai-amp-for-free)
 
 ### Q: What exactly is CrewAI?
 
-A: CrewAI is a standalone, lean, and fast Python framework built specifically for orchestrating autonomous AI agents. Unlike frameworks like LangChain, CrewAI does not rely on external dependencies, making it leaner, faster, and simpler.
+A: CrewAI is a lean, fast Python framework built specifically for orchestrating autonomous AI agents and production-ready agentic workflows.
 
 ### Q: How do I install CrewAI?
 
 A: Install CrewAI using pip:
 
 ```shell
-pip install crewai
+uv pip install crewai
 ```
 
 For additional tools, use:
 
 ```shell
-pip install 'crewai[tools]'
+uv pip install 'crewai[tools]'
 ```
 
-### Q: Does CrewAI depend on LangChain?
+### Q: Is CrewAI a standalone framework?
 
-A: No. CrewAI is built entirely from the ground up, with no dependencies on LangChain or other agent frameworks. This ensures a lean, fast, and flexible experience.
+A: Yes. CrewAI is a standalone Python framework with its own primitives for agents, tasks, crews, flows, tools, and orchestration.
 
 ### Q: Can CrewAI handle complex use cases?
 
@@ -712,10 +757,6 @@ A: Absolutely! CrewAI supports various language models, including local ones. To
 
 A: Crews provide autonomous agent collaboration, ideal for tasks requiring flexible decision-making and dynamic interaction. Flows offer precise, event-driven control, ideal for managing detailed execution paths and secure state management. You can seamlessly combine both for maximum effectiveness.
 
-### Q: How is CrewAI better than LangChain?
-
-A: CrewAI provides simpler, more intuitive APIs, faster execution speeds, more reliable and consistent results, robust documentation, and an active community—addressing common criticisms and limitations associated with LangChain.
-
 ### Q: Is CrewAI open-source?
 
 A: Yes, CrewAI is open-source and actively encourages community contributions and collaboration.
@@ -732,17 +773,17 @@ A: Check out practical examples in the [CrewAI-examples repository](https://gith
 
 A: Contributions are warmly welcomed! Fork the repository, create your branch, implement your changes, and submit a pull request. See the Contribution section of the README for detailed guidelines.
 
-### Q: What additional features does CrewAI AOP offer?
+### Q: What additional features does CrewAI AMP offer?
 
-A: CrewAI AOP provides advanced features such as a unified control plane, real-time observability, secure integrations, advanced security, actionable insights, and dedicated 24/7 enterprise support.
+A: CrewAI AMP provides advanced features such as a unified control plane, real-time observability, secure integrations, advanced security, actionable insights, and dedicated 24/7 enterprise support.
 
-### Q: Is CrewAI AOP available for cloud and on-premise deployments?
+### Q: Is CrewAI AMP available for cloud and on-premise deployments?
 
-A: Yes, CrewAI AOP supports both cloud-based and on-premise deployment options, allowing enterprises to meet their specific security and compliance requirements.
+A: Yes, CrewAI AMP supports both cloud-based and on-premise deployment options, allowing enterprises to meet their specific security and compliance requirements.
 
-### Q: Can I try CrewAI AOP for free?
+### Q: Can I try CrewAI AMP for free?
 
-A: Yes, you can explore part of the CrewAI AOP Suite by accessing the [Crew Control Plane](https://app.crewai.com) for free.
+A: Yes, you can explore part of the CrewAI AMP Suite by accessing the [Crew Control Plane](https://app.crewai.com) for free.
 
 ### Q: Does CrewAI support fine-tuning or training custom models?
 
@@ -754,15 +795,15 @@ A: Absolutely! CrewAI agents can easily integrate with external tools, APIs, and
 
 ### Q: Is CrewAI suitable for production environments?
 
-A: Yes, CrewAI is explicitly designed with production-grade standards, ensuring reliability, stability, and scalability for enterprise deployments.
+A: Yes, CrewAI is designed with production-grade patterns that support reliable, stable, and scalable agentic workflows.
 
 ### Q: How scalable is CrewAI?
 
-A: CrewAI is highly scalable, supporting simple automations and large-scale enterprise workflows involving numerous agents and complex tasks simultaneously.
+A: CrewAI is highly scalable, supporting simple automations and large-scale workflows involving numerous agents and complex tasks simultaneously.
 
 ### Q: Does CrewAI offer debugging and monitoring tools?
 
-A: Yes, CrewAI AOP includes advanced debugging, tracing, and real-time observability features, simplifying the management and troubleshooting of your automations.
+A: Yes, CrewAI AMP includes advanced debugging, tracing, and real-time observability features, simplifying the management and troubleshooting of your automations.
 
 ### Q: What programming languages does CrewAI support?
 

conftest.py

@@ -1,19 +1,190 @@
 """Pytest configuration for crewAI workspace."""
 
+import base64
 from collections.abc import Generator
+import gzip
 import os
 from pathlib import Path
+import re
 import tempfile
 from typing import Any
 
 from dotenv import load_dotenv
 import pytest
-from vcr.request import Request  # type: ignore[import-untyped]
+
+
+def _patch_vcrpy_aiohttp_compat() -> None:
+    """Keep vcrpy's aiohttp stub working under aiohttp 3.14.0.
+
+    aiohttp 3.14.0 (pulled in to fix GHSA-jg22-mg44-37j8 and GHSA-hg6j-4rv6-33pg):
+      * removed ``aiohttp.streams.AsyncStreamReaderMixin`` (folded into ``StreamReader``),
+        which vcrpy's ``MockStream`` still subclasses -- vcr's patch machinery then raises
+        ``AttributeError`` at collection time; and
+      * added a required ``stream_writer`` keyword-only arg to ``ClientResponse.__init__``,
+        which vcrpy's ``MockClientResponse`` does not pass -- raising ``TypeError`` at
+        cassette playback.
+
+    Restore the mixin, then rebuild ``MockClientResponse``'s ``super().__init__`` call from
+    the live ``ClientResponse`` signature (defaulting every required keyword-only arg to
+    ``None``, mirroring vcrpy's original call) so it also survives future aiohttp additions.
+    """
+    import asyncio
+    import inspect
+
+    from aiohttp import streams
+    from aiohttp.client_reqrep import ClientResponse
+
+    if not hasattr(streams, "AsyncStreamReaderMixin"):
+
+        class AsyncStreamReaderMixin:
+            __slots__ = ()
+
+            def __aiter__(self) -> streams.AsyncStreamIterator[bytes]:
+                return streams.AsyncStreamIterator(self.readline)  # type: ignore[attr-defined]
+
+            def iter_chunked(self, n: int) -> streams.AsyncStreamIterator[bytes]:
+                return streams.AsyncStreamIterator(lambda: self.read(n))  # type: ignore[attr-defined]
+
+            def iter_any(self) -> streams.AsyncStreamIterator[bytes]:
+                return streams.AsyncStreamIterator(self.readany)  # type: ignore[attr-defined]
+
+            def iter_chunks(self) -> streams.ChunkTupleAsyncStreamIterator:
+                return streams.ChunkTupleAsyncStreamIterator(self)  # type: ignore[arg-type]
+
+        streams.AsyncStreamReaderMixin = AsyncStreamReaderMixin  # type: ignore[attr-defined]
+
+    # Importing the stub builds MockStream/MockClientResponse, so it must run after the
+    # mixin is restored above.
+    import vcr.stubs.aiohttp_stubs as aiohttp_stubs  # type: ignore[import-untyped]
+
+    if getattr(aiohttp_stubs.MockClientResponse, "_crewai_aiohttp_patched", False):
+        return
+
+    keyword_only = [
+        name
+        for name, param in inspect.signature(ClientResponse.__init__).parameters.items()
+        if param.kind is inspect.Parameter.KEYWORD_ONLY
+    ]
+
+    class _NullStreamWriter:
+        # aiohttp 3.14.0 reads stream_writer.output_size in the "request already
+        # sent" branch (writer is None), so None is not enough -- supply a stub.
+        output_size = 0
+
+    fallback_loop: list[asyncio.AbstractEventLoop] = []
+
+    def _resolve_loop() -> asyncio.AbstractEventLoop:
+        # MockClientResponse is normally built inside aiohttp's running loop, so
+        # prefer that. In a sync context there is no running loop; avoid
+        # asyncio.get_event_loop(), which on 3.12+ emits a DeprecationWarning
+        # (and can RuntimeError) when no current loop is set. Use one cached
+        # loop instead -- the mock only stores it and calls loop.get_debug().
+        try:
+            return asyncio.get_running_loop()
+        except RuntimeError:
+            if not fallback_loop:
+                fallback_loop.append(asyncio.new_event_loop())
+            return fallback_loop[0]
+
+    def _mock_client_response_init(
+        self: Any, method: str, url: Any, request_info: Any = None
+    ) -> None:
+        kwargs: dict[str, Any] = dict.fromkeys(keyword_only)
+        kwargs["request_info"] = request_info
+        if "loop" in kwargs:
+            kwargs["loop"] = _resolve_loop()
+        if "stream_writer" in kwargs:
+            kwargs["stream_writer"] = _NullStreamWriter()
+        ClientResponse.__init__(self, method, url, **kwargs)
+
+    aiohttp_stubs.MockClientResponse.__init__ = _mock_client_response_init
+    aiohttp_stubs.MockClientResponse._crewai_aiohttp_patched = True
+
+
+_patch_vcrpy_aiohttp_compat()
+
+from vcr.request import Request  # type: ignore[import-untyped]  # noqa: E402
+
+
+try:
+    import vcr.stubs.httpx_stubs as httpx_stubs  # type: ignore[import-untyped]
+except ModuleNotFoundError:
+    import vcr.stubs.httpcore_stubs as httpx_stubs  # type: ignore[import-untyped]
 
 
 env_test_path = Path(__file__).parent / ".env.test"
-load_dotenv(env_test_path, override=True)
-load_dotenv(override=True)
+
+load_dotenv(env_test_path, override=False)
+load_dotenv(override=False)
+
+BEDROCK_HOST_PLACEHOLDER = "bedrock-runtime.vcr.amazonaws.com"
+_BEDROCK_HOST_RE = re.compile(r"^bedrock-runtime\.[a-z0-9-]+\.amazonaws\.com$")
+
+
+def _normalize_bedrock_host(host: str) -> str:
+    if _BEDROCK_HOST_RE.match(host):
+        return BEDROCK_HOST_PLACEHOLDER
+    return host
+
+
+def bedrock_host_matcher(r1: Request, r2: Request) -> bool:  # type: ignore[no-any-unimported]
+    """Match Bedrock requests across AWS regions (CI uses us-east-1, local may use us-west-2)."""
+    return _normalize_bedrock_host(r1.host or "") == _normalize_bedrock_host(
+        r2.host or ""
+    )
+
+
+def _patched_make_vcr_request(
+    httpx_request: Any, real_request_body: Any = None, **kwargs: Any
+) -> Any:
+    """Patched version of VCR's _make_vcr_request that handles binary content.
+
+    The original implementation fails on binary request bodies (like file uploads)
+    because it assumes all content can be decoded as UTF-8.
+    """
+    raw_body = real_request_body if real_request_body is not None else httpx_request.read()
+    body: Any = raw_body
+    if isinstance(raw_body, bytes):
+        try:
+            body = raw_body.decode("utf-8")
+        except UnicodeDecodeError:
+            body = base64.b64encode(raw_body).decode("ascii")
+    uri = str(httpx_request.url)
+    headers = dict(httpx_request.headers)
+    return Request(httpx_request.method, uri, body, headers)
+
+
+httpx_stubs._make_vcr_request = _patched_make_vcr_request
+
+
+# Patch the response-side of VCR to fix httpx.ResponseNotRead errors.
+# VCR's _from_serialized_response mocks httpx.Response.read(), which prevents
+# the response's internal _content attribute from being properly initialized.
+# When OpenAI's client (using with_raw_response) accesses response.content,
+# httpx raises ResponseNotRead because read() was never actually called.
+# This patch ensures _content is explicitly set after response creation.
+_original_from_serialized_response = getattr(
+    httpx_stubs, "_from_serialized_response", None
+)
+
+if _original_from_serialized_response is not None:
+    _from_serialized: Any = _original_from_serialized_response
+
+    def _patched_from_serialized_response(
+        request: Any, serialized_response: Any, history: Any = None
+    ) -> Any:
+        """Patched version that ensures response._content is properly set."""
+        response = _from_serialized(request, serialized_response, history)
+        # Explicitly set _content to avoid ResponseNotRead errors
+        # The content was passed to the constructor but the mocked read() prevents
+        # proper initialization of the internal state
+        body_content = serialized_response.get("body", {}).get("string", b"")
+        if isinstance(body_content, str):
+            body_content = body_content.encode("utf-8")
+        response._content = body_content
+        return response
+
+    httpx_stubs._from_serialized_response = _patched_from_serialized_response
 
 
 @pytest.fixture(autouse=True, scope="function")
@@ -31,6 +202,21 @@ def cleanup_event_handlers() -> Generator[None, Any, None]:
         pass
 
 
+@pytest.fixture(autouse=True, scope="function")
+def reset_event_state() -> None:
+    """Reset event system state before each test for isolation."""
+    from crewai.events.base_events import reset_emission_counter
+    from crewai.events.event_context import (
+        EventContextConfig,
+        _event_context_config,
+        _event_id_stack,
+    )
+
+    reset_emission_counter()
+    _event_id_stack.set(())
+    _event_context_config.set(EventContextConfig())
+
+
 @pytest.fixture(autouse=True, scope="function")
 def setup_test_environment() -> Generator[None, Any, None]:
     """Setup test environment for crewAI workspace."""
@@ -116,10 +302,13 @@ HEADERS_TO_FILTER = {
     "anthropic-ratelimit-tokens-remaining": "ANTHROPIC-RATELIMIT-TOKENS-REMAINING-XXX",
     "anthropic-ratelimit-tokens-reset": "ANTHROPIC-RATELIMIT-TOKENS-RESET-XXX",
     "x-amz-date": "X-AMZ-DATE-XXX",
+    "x-amz-security-token": "X-AMZ-SECURITY-TOKEN-XXX",
     "amz-sdk-invocation-id": "AMZ-SDK-INVOCATION-ID-XXX",
     "accept-encoding": "ACCEPT-ENCODING-XXX",
     "x-amzn-requestid": "X-AMZN-REQUESTID-XXX",
     "x-amzn-RequestId": "X-AMZN-REQUESTID-XXX",
+    "x-a2a-notification-token": "X-A2A-NOTIFICATION-TOKEN-XXX",
+    "x-a2a-version": "X-A2A-VERSION-XXX",
 }
 
 
@@ -131,19 +320,51 @@ def _filter_request_headers(request: Request) -> Request:  # type: ignore[no-any
                 request.headers[variant] = [replacement]
 
     request.method = request.method.upper()
+
+    # Normalize Azure OpenAI endpoints to a consistent placeholder for cassette matching.
+    if request.host and request.host.endswith(".openai.azure.com"):
+        original_host = request.host
+        placeholder_host = "fake-azure-endpoint.openai.azure.com"
+        request.uri = request.uri.replace(original_host, placeholder_host)
+
+    # Normalize Bedrock regional endpoints so cassettes work in any AWS region.
+    if request.host and _BEDROCK_HOST_RE.match(request.host):
+        request.uri = request.uri.replace(request.host, BEDROCK_HOST_PLACEHOLDER)
+
     return request
 
 
-def _filter_response_headers(response: dict[str, Any]) -> dict[str, Any]:
-    """Filter sensitive headers from response before recording."""
-    # Remove Content-Encoding to prevent decompression issues on replay
+def _filter_response_headers(response: dict[str, Any]) -> dict[str, Any] | None:
+    """Filter sensitive headers from response before recording.
+
+    Returns None to skip recording responses with empty bodies. This handles
+    duplicate recordings caused by OpenAI's stainless client using
+    with_raw_response which triggers httpx to re-read the consumed stream.
+    """
+    body = response.get("body", {}).get("string", "")
+    headers = response.get("headers", {})
+    content_length = headers.get("content-length", headers.get("Content-Length", []))
+
+    if body == "" or body == b"" or content_length == ["0"]:
+        return None
+
+    status_code = response.get("status", {}).get("code")
+    if isinstance(status_code, int) and status_code >= 400:
+        # Avoid persisting auth/model errors when re-recording without valid AWS creds.
+        return None
+
     for encoding_header in ["Content-Encoding", "content-encoding"]:
-        response["headers"].pop(encoding_header, None)
+        if encoding_header in headers:
+            encoding = headers.pop(encoding_header)
+            if encoding and encoding[0] == "gzip":
+                body = response.get("body", {}).get("string", b"")
+                if isinstance(body, bytes) and body.startswith(b"\x1f\x8b"):
+                    response["body"]["string"] = gzip.decompress(body).decode("utf-8")
 
     for header_name, replacement in HEADERS_TO_FILTER.items():
         for variant in [header_name, header_name.upper(), header_name.title()]:
-            if variant in response["headers"]:
-                response["headers"][variant] = [replacement]
+            if variant in headers:
+                headers[variant] = [replacement]
     return response
 
 
@@ -158,7 +379,11 @@ def vcr_cassette_dir(request: Any) -> str:
     test_file = Path(request.fspath)
 
     for parent in test_file.parents:
-        if parent.name in ("crewai", "crewai-tools") and parent.parent.name == "lib":
+        if (
+            parent.name
+            in ("crewai", "crewai-tools", "crewai-files", "cli", "crewai-core")
+            and parent.parent.name == "lib"
+        ):
             package_root = parent
             break
     else:
@@ -178,6 +403,11 @@ def vcr_cassette_dir(request: Any) -> str:
     return str(cassette_dir)
 
 
+def pytest_recording_configure(vcr: Any, config: Any) -> None:
+    """Register custom VCR matchers for each test cassette session."""
+    vcr.register_matcher("bedrock_host", bedrock_host_matcher)
+
+
 @pytest.fixture(scope="module")
 def vcr_config(vcr_cassette_dir: str) -> dict[str, Any]:
     """Configure VCR with organized cassette storage."""

docs/edge/ar/api-reference/inputs.mdx

@@ -0,0 +1,8 @@
+---
+title: "GET /inputs"
+description: "الحصول على المدخلات المطلوبة لطاقمك"
+openapi: "/enterprise-api.en.yaml GET /inputs"
+mode: "wide"
+---
+
+

docs/edge/ar/api-reference/introduction.mdx

@@ -0,0 +1,135 @@
+---
+title: "مقدمة"
+description: "المرجع الكامل لواجهة برمجة تطبيقات CrewAI AMP REST"
+icon: "code"
+mode: "wide"
+---
+
+# واجهة برمجة تطبيقات CrewAI AMP
+
+مرحبًا بك في مرجع واجهة برمجة تطبيقات CrewAI AMP. تتيح لك هذه الواجهة التفاعل برمجيًا مع الأطقم المنشورة، مما يمكّنك من دمجها مع تطبيقاتك وسير عملك وخدماتك.
+
+## البدء السريع
+
+<Steps>
+  <Step title="الحصول على بيانات اعتماد API">
+    انتقل إلى صفحة تفاصيل طاقمك في لوحة تحكم CrewAI AMP وانسخ رمز Bearer من علامة تبويب الحالة.
+  </Step>
+
+<Step title="اكتشاف المدخلات المطلوبة">
+  استخدم نقطة النهاية `GET /inputs` لمعرفة المعاملات التي يتوقعها طاقمك.
+</Step>
+
+<Step title="بدء تنفيذ الطاقم">
+  استدعِ `POST /kickoff` مع مدخلاتك لبدء تنفيذ الطاقم واستلام
+  `kickoff_id`.
+</Step>
+
+  <Step title="مراقبة التقدم">
+    استخدم `GET /status/{kickoff_id}` للتحقق من حالة التنفيذ واسترجاع النتائج.
+  </Step>
+</Steps>
+
+## المصادقة
+
+تتطلب جميع طلبات API المصادقة باستخدام رمز Bearer. أدرج رمزك في ترويسة `Authorization`:
+
+```bash
+curl -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  https://your-crew-url.crewai.com/inputs
+```
+
+### أنواع الرموز
+
+| نوع الرمز            | النطاق                     | حالة الاستخدام                                                     |
+| :-------------------- | :------------------------ | :----------------------------------------------------------- |
+| **Bearer Token**      | وصول على مستوى المؤسسة | عمليات الطاقم الكاملة، مثالي للتكامل بين الخوادم |
+| **User Bearer Token** | وصول محدد بالمستخدم        | صلاحيات محدودة، مناسب للعمليات الخاصة بالمستخدم   |
+
+<Tip>
+  يمكنك العثور على كلا نوعي الرموز في علامة تبويب الحالة من صفحة تفاصيل طاقمك في
+  لوحة تحكم CrewAI AMP.
+</Tip>
+
+## عنوان URL الأساسي
+
+لكل طاقم منشور نقطة نهاية API فريدة خاصة به:
+
+```
+https://your-crew-name.crewai.com
+```
+
+استبدل `your-crew-name` بعنوان URL الفعلي لطاقمك من لوحة التحكم.
+
+## سير العمل النموذجي
+
+1. **الاكتشاف**: استدعِ `GET /inputs` لفهم ما يحتاجه طاقمك
+2. **التنفيذ**: أرسل المدخلات عبر `POST /kickoff` لبدء المعالجة
+3. **المراقبة**: استعلم عن `GET /status/{kickoff_id}` حتى الاكتمال
+4. **النتائج**: استخرج المخرجات النهائية من الاستجابة المكتملة
+
+## معالجة الأخطاء
+
+تستخدم الواجهة أكواد حالة HTTP القياسية:
+
+| الكود  | المعنى                                    |
+| ----- | :----------------------------------------- |
+| `200` | نجاح                                    |
+| `400` | طلب غير صالح - تنسيق مدخلات غير صحيح         |
+| `401` | غير مصرّح - رمز bearer غير صالح        |
+| `404` | غير موجود - المورد غير موجود         |
+| `422` | خطأ في التحقق - مدخلات مطلوبة مفقودة |
+| `500` | خطأ في الخادم - تواصل مع الدعم             |
+
+## الاختبار التفاعلي
+
+<Info>
+  **لماذا لا يوجد زر "إرسال"؟** نظرًا لأن كل مستخدم CrewAI AMP لديه عنوان URL
+  فريد للطاقم، نستخدم **وضع المرجع** بدلاً من بيئة تفاعلية لتجنب
+  الالتباس. يوضح لك هذا بالضبط كيف يجب أن تبدو الطلبات بدون
+  أزرار إرسال غير فعالة.
+</Info>
+
+تعرض لك كل صفحة نقطة نهاية:
+
+- **تنسيق الطلب الدقيق** مع جميع المعاملات
+- **أمثلة الاستجابة** لحالات النجاح والخطأ
+- **عينات الكود** بلغات متعددة (cURL، Python، JavaScript، إلخ)
+- **أمثلة المصادقة** بتنسيق رمز Bearer الصحيح
+
+### **لاختبار واجهتك الفعلية:**
+
+<CardGroup cols={2}>
+  <Card title="نسخ أمثلة cURL" icon="terminal">
+    انسخ أمثلة cURL واستبدل العنوان URL + الرمز بقيمك الحقيقية
+  </Card>
+  <Card title="استخدام Postman/Insomnia" icon="play">
+    استورد الأمثلة في أداة اختبار API المفضلة لديك
+  </Card>
+</CardGroup>
+
+**مثال على سير العمل:**
+
+1. **انسخ مثال cURL هذا** من أي صفحة نقطة نهاية
+2. **استبدل `your-actual-crew-name.crewai.com`** بعنوان URL الحقيقي لطاقمك
+3. **استبدل رمز Bearer** برمزك الحقيقي من لوحة التحكم
+4. **نفّذ الطلب** في طرفيتك أو عميل API
+
+## هل تحتاج مساعدة؟
+
+<CardGroup cols={2}>
+  <Card
+    title="دعم المؤسسات"
+    icon="headset"
+    href="mailto:support@crewai.com"
+  >
+    احصل على مساعدة في تكامل API واستكشاف الأخطاء وإصلاحها
+  </Card>
+  <Card
+    title="لوحة تحكم المؤسسات"
+    icon="chart-line"
+    href="https://app.crewai.com"
+  >
+    إدارة أطقمك وعرض سجلات التنفيذ
+  </Card>
+</CardGroup>

docs/edge/ar/api-reference/kickoff.mdx

@@ -0,0 +1,8 @@
+---
+title: "POST /kickoff"
+description: "بدء تنفيذ الطاقم"
+openapi: "/enterprise-api.en.yaml POST /kickoff"
+mode: "wide"
+---
+
+

docs/edge/ar/api-reference/resume.mdx

@@ -0,0 +1,6 @@
+---
+title: "POST /resume"
+description: "استئناف تنفيذ الطاقم مع التغذية الراجعة البشرية"
+openapi: "/enterprise-api.en.yaml POST /resume"
+mode: "wide"
+---

docs/edge/ar/api-reference/status.mdx

@@ -0,0 +1,6 @@
+---
+title: "GET /status/{kickoff_id}"
+description: "الحصول على حالة التنفيذ"
+openapi: "/enterprise-api.en.yaml GET /status/{kickoff_id}"
+mode: "wide"
+---

docs/edge/ar/concepts/agent-capabilities.mdx

@@ -0,0 +1,147 @@
+---
+title: "قدرات الوكيل"
+description: "فهم الطرق الخمس لتوسيع وكلاء CrewAI: الأدوات، MCP، التطبيقات، المهارات، والمعرفة."
+icon: puzzle-piece
+mode: "wide"
+---
+
+## نظرة عامة
+
+يمكن توسيع وكلاء CrewAI بـ **خمسة أنواع مميزة من القدرات**، كل منها يخدم غرضًا مختلفًا. فهم متى تستخدم كل نوع — وكيف يعملون معًا — هو المفتاح لبناء وكلاء فعّالين.
+
+<CardGroup cols={2}>
+  <Card title="الأدوات" icon="wrench" href="/ar/concepts/tools" color="#3B82F6">
+    **دوال قابلة للاستدعاء** — تمنح الوكلاء القدرة على اتخاذ إجراءات. البحث على الويب، عمليات الملفات، استدعاءات API، تنفيذ الكود.
+  </Card>
+  <Card title="خوادم MCP" icon="plug" href="/ar/mcp/overview" color="#8B5CF6">
+    **خوادم أدوات عن بُعد** — تربط الوكلاء بخوادم أدوات خارجية عبر Model Context Protocol. نفس تأثير الأدوات، لكن مستضافة خارجيًا.
+  </Card>
+  <Card title="التطبيقات" icon="grid-2" color="#EC4899">
+    **تكاملات المنصة** — تربط الوكلاء بتطبيقات SaaS (Gmail، Slack، Jira، Salesforce) عبر منصة CrewAI. تعمل محليًا مع رمز تكامل المنصة.
+  </Card>
+  <Card title="المهارات" icon="bolt" href="/ar/concepts/skills" color="#F59E0B">
+    **خبرة المجال** — تحقن التعليمات والإرشادات والمواد المرجعية في إرشادات الوكلاء. المهارات تخبر الوكلاء *كيف يفكرون*.
+  </Card>
+  <Card title="المعرفة" icon="book" href="/ar/concepts/knowledge" color="#10B981">
+    **حقائق مُسترجعة** — توفر للوكلاء بيانات من المستندات والملفات وعناوين URL عبر البحث الدلالي (RAG). المعرفة تعطي الوكلاء *ما يحتاجون معرفته*.
+  </Card>
+</CardGroup>
+
+---
+
+## التمييز الأساسي
+
+أهم شيء يجب فهمه: **هذه القدرات تنقسم إلى فئتين**.
+
+### قدرات الإجراء (الأدوات، MCP، التطبيقات)
+
+تمنح الوكلاء القدرة على **فعل أشياء** — استدعاء APIs، قراءة الملفات، البحث على الويب، إرسال رسائل البريد الإلكتروني. عند التنفيذ، تتحول الأنواع الثلاثة إلى نفس التنسيق الداخلي (مثيلات `BaseTool`) وتظهر في قائمة أدوات موحدة يمكن للوكيل استدعاؤها.
+
+```python
+from crewai import Agent
+from crewai_tools import SerperDevTool, FileReadTool
+
+agent = Agent(
+    role="Researcher",
+    goal="Find and compile market data",
+    backstory="Expert market analyst",
+    tools=[SerperDevTool(), FileReadTool()],  # أدوات محلية
+    mcps=["https://mcp.example.com/sse"],     # أدوات خادم MCP عن بُعد
+    apps=["gmail", "google_sheets"],           # تكاملات المنصة
+)
+```
+
+### قدرات السياق (المهارات، المعرفة)
+
+تُعدّل **إرشادات** الوكيل — بحقن الخبرة أو التعليمات أو البيانات المُسترجعة قبل أن يبدأ الوكيل في التفكير. لا تمنح الوكلاء إجراءات جديدة؛ بل تُشكّل كيف يفكر الوكلاء وما هي المعلومات التي يمكنهم الوصول إليها.
+
+```python
+from crewai import Agent
+
+agent = Agent(
+    role="Security Auditor",
+    goal="Audit cloud infrastructure for vulnerabilities",
+    backstory="Expert in cloud security with 10 years of experience",
+    skills=["./skills/security-audit"],        # تعليمات المجال
+    knowledge_sources=[pdf_source, url_source], # حقائق مُسترجعة
+)
+```
+
+---
+
+## متى تستخدم ماذا
+
+| تحتاج إلى...                                            | استخدم            | مثال                                     |
+| :------------------------------------------------------- | :---------------- | :--------------------------------------- |
+| الوكيل يبحث على الويب                                    | **الأدوات**       | `tools=[SerperDevTool()]`                |
+| الوكيل يستدعي API عن بُعد عبر MCP                        | **MCP**           | `mcps=["https://api.example.com/sse"]`   |
+| الوكيل يرسل بريد إلكتروني عبر Gmail                      | **التطبيقات**     | `apps=["gmail"]`                         |
+| الوكيل يتبع إجراءات محددة                                | **المهارات**      | `skills=["./skills/code-review"]`        |
+| الوكيل يرجع لمستندات الشركة                              | **المعرفة**       | `knowledge_sources=[pdf_source]`         |
+| الوكيل يبحث على الويب ويتبع إرشادات المراجعة              | **الأدوات + المهارات** | استخدم كليهما معًا                  |
+
+---
+
+## دمج القدرات
+
+في الممارسة العملية، غالبًا ما يستخدم الوكلاء **أنواعًا متعددة من القدرات معًا**. إليك مثال واقعي:
+
+```python
+from crewai import Agent
+from crewai_tools import SerperDevTool, FileReadTool, CodeInterpreterTool
+
+# وكيل بحث مجهز بالكامل
+researcher = Agent(
+    role="Senior Research Analyst",
+    goal="Produce comprehensive market analysis reports",
+    backstory="Expert analyst with deep industry knowledge",
+
+    # الإجراء: ما يمكن للوكيل فعله
+    tools=[
+        SerperDevTool(),         # البحث على الويب
+        FileReadTool(),          # قراءة الملفات المحلية
+        CodeInterpreterTool(),   # تشغيل كود Python للتحليل
+    ],
+    mcps=["https://data-api.example.com/sse"],  # الوصول لـ API بيانات عن بُعد
+    apps=["google_sheets"],                      # الكتابة في Google Sheets
+
+    # السياق: ما يعرفه الوكيل
+    skills=["./skills/research-methodology"],    # كيفية إجراء البحث
+    knowledge_sources=[company_docs],            # بيانات خاصة بالشركة
+)
+```
+
+---
+
+## جدول المقارنة
+
+| الميزة | الأدوات | MCP | التطبيقات | المهارات | المعرفة |
+| :--- | :---: | :---: | :---: | :---: | :---: |
+| **يمنح الوكيل إجراءات** | ✅ | ✅ | ✅ | ❌ | ❌ |
+| **يُعدّل الإرشادات** | ❌ | ❌ | ❌ | ✅ | ✅ |
+| **يتطلب كود** | نعم | إعداد فقط | إعداد فقط | Markdown فقط | إعداد فقط |
+| **يعمل محليًا** | نعم | يعتمد | نعم (مع متغير بيئة) | غير متاح | نعم |
+| **يحتاج مفاتيح API** | لكل أداة | لكل خادم | رمز التكامل | لا | المُضمّن فقط |
+| **يُعيَّن على Agent** | `tools=[]` | `mcps=[]` | `apps=[]` | `skills=[]` | `knowledge_sources=[]` |
+| **يُعيَّن على Crew** | ❌ | ❌ | ❌ | `skills=[]` | `knowledge_sources=[]` |
+
+---
+
+## تعمّق أكثر
+
+هل أنت مستعد لمعرفة المزيد عن كل نوع من أنواع القدرات؟
+
+<CardGroup cols={2}>
+  <Card title="الأدوات" icon="wrench" href="/ar/concepts/tools">
+    إنشاء أدوات مخصصة، استخدام كتالوج OSS مع أكثر من 75 خيارًا، تكوين التخزين المؤقت والتنفيذ غير المتزامن.
+  </Card>
+  <Card title="تكامل MCP" icon="plug" href="/ar/mcp/overview">
+    الاتصال بخوادم MCP عبر stdio أو SSE أو HTTP. تصفية الأدوات، تكوين المصادقة.
+  </Card>
+  <Card title="المهارات" icon="bolt" href="/ar/concepts/skills">
+    بناء حزم المهارات مع SKILL.md، حقن خبرة المجال، استخدام الكشف التدريجي.
+  </Card>
+  <Card title="المعرفة" icon="book" href="/ar/concepts/knowledge">
+    إضافة المعرفة من ملفات PDF وCSV وعناوين URL والمزيد. تكوين المُضمّنات والاسترجاع.
+  </Card>
+</CardGroup>

docs/edge/ar/concepts/agents.mdx

@@ -0,0 +1,383 @@
+---
+title: الوكلاء
+description: دليل تفصيلي حول إنشاء وإدارة الوكلاء ضمن إطار عمل CrewAI.
+icon: robot
+mode: "wide"
+---
+
+## نظرة عامة على الوكيل
+
+في إطار عمل CrewAI، الـ `Agent` هو وحدة مستقلة يمكنها:
+
+- أداء مهام محددة
+- اتخاذ قرارات بناءً على دوره وهدفه
+- استخدام الأدوات لتحقيق الأهداف
+- التواصل والتعاون مع وكلاء آخرين
+- الاحتفاظ بذاكرة التفاعلات
+- تفويض المهام عند السماح بذلك
+
+<Tip>
+  فكّر في الوكيل كعضو فريق متخصص بمهارات وخبرات ومسؤوليات محددة.
+  على سبيل المثال، قد يتفوق وكيل `Researcher` في جمع وتحليل المعلومات،
+  بينما قد يكون وكيل `Writer` أفضل في إنشاء المحتوى.
+</Tip>
+
+<Note type="info" title="تحسين المؤسسات: منشئ الوكلاء المرئي">
+يتضمن CrewAI AMP منشئ وكلاء مرئي يبسّط إنشاء وتهيئة الوكلاء بدون كتابة كود. صمم وكلاءك بصريًا واختبرهم في الوقت الفعلي.
+
+![Visual Agent Builder Screenshot](/images/enterprise/crew-studio-interface.png)
+
+يُمكّن منشئ الوكلاء المرئي من:
+
+- تهيئة وكلاء بديهية بواجهات نماذج
+- اختبار والتحقق في الوقت الفعلي
+- مكتبة قوالب مع أنواع وكلاء مهيأة مسبقًا
+- تخصيص سهل لخصائص وسلوكيات الوكيل
+</Note>
+
+## خصائص الوكيل
+
+| الخاصية                               | المعامل                | النوع                                  | الوصف                                                                                              |
+| :-------------------------------------- | :----------------------- | :------------------------------------ | :------------------------------------------------------------------------------------------------------- |
+| **الدور**                                | `role`                   | `str`                                 | يحدد وظيفة الوكيل وخبرته ضمن الطاقم.                                              |
+| **الهدف**                                | `goal`                   | `str`                                 | الهدف الفردي الذي يوجه عملية اتخاذ القرار لدى الوكيل.                                        |
+| **الخلفية**                           | `backstory`              | `str`                                 | يوفر سياقًا وشخصية للوكيل، مما يثري التفاعلات.                                   |
+| **LLM** _(اختياري)_                    | `llm`                    | `Union[str, LLM, Any]`                | نموذج اللغة الذي يشغّل الوكيل. افتراضيًا النموذج المحدد في `OPENAI_MODEL_NAME` أو "gpt-4". |
+| **الأدوات** _(اختياري)_                  | `tools`                  | `List[BaseTool]`                      | القدرات أو الوظائف المتاحة للوكيل. افتراضيًا قائمة فارغة.                             |
+| **LLM استدعاء الدوال** _(اختياري)_   | `function_calling_llm`   | `Optional[Any]`                       | نموذج لغة لاستدعاء الأدوات، يتجاوز LLM الطاقم إذا حُدد.                                      |
+| **الحد الأقصى للتكرارات** _(اختياري)_         | `max_iter`               | `int`                                 | الحد الأقصى للتكرارات قبل أن يقدم الوكيل أفضل إجابته. الافتراضي 20.                         |
+| **الحد الأقصى لـ RPM** _(اختياري)_                | `max_rpm`                | `Optional[int]`                       | الحد الأقصى للطلبات في الدقيقة لتجنب حدود المعدل.                                                        |
+| **الحد الأقصى لوقت التنفيذ** _(اختياري)_     | `max_execution_time`     | `Optional[int]`                       | الحد الأقصى للوقت (بالثواني) لتنفيذ المهمة.                                                            |
+| **الوضع المفصل** _(اختياري)_                | `verbose`                | `bool`                                | تفعيل سجلات التنفيذ المفصلة للتصحيح. الافتراضي False.                                          |
+| **السماح بالتفويض** _(اختياري)_       | `allow_delegation`       | `bool`                                | السماح للوكيل بتفويض المهام لوكلاء آخرين. الافتراضي False.                                     |
+| **دالة الخطوة** _(اختياري)_          | `step_callback`          | `Optional[Any]`                       | دالة تُستدعى بعد كل خطوة للوكيل، تتجاوز دالة الطاقم.                                          |
+| **التخزين المؤقت** _(اختياري)_                  | `cache`                  | `bool`                                | تفعيل التخزين المؤقت لاستخدام الأدوات. الافتراضي True.                                                          |
+| **قالب النظام** _(اختياري)_        | `system_template`        | `Optional[str]`                       | قالب أمر نظام مخصص للوكيل.                                                             |
+| **قالب الأمر** _(اختياري)_        | `prompt_template`        | `Optional[str]`                       | قالب أمر مخصص للوكيل.                                                                    |
+| **قالب الاستجابة** _(اختياري)_      | `response_template`      | `Optional[str]`                       | قالب استجابة مخصص للوكيل.                                                                  |
+| **السماح بتنفيذ الكود** _(اختياري)_   | `allow_code_execution`   | `Optional[bool]`                      | تفعيل تنفيذ الكود للوكيل. الافتراضي False.                                                   |
+| **الحد الأقصى لإعادة المحاولة** _(اختياري)_        | `max_retry_limit`        | `int`                                 | الحد الأقصى لإعادات المحاولة عند حدوث خطأ. الافتراضي 2.                                            |
+| **احترام نافذة السياق** _(اختياري)_ | `respect_context_window` | `bool`                                | إبقاء الرسائل تحت حجم نافذة السياق عبر التلخيص. الافتراضي True.                                 |
+| **وضع تنفيذ الكود** _(اختياري)_    | `code_execution_mode`    | `Literal["safe", "unsafe"]`           | وضع تنفيذ الكود: 'safe' (باستخدام Docker) أو 'unsafe' (مباشر). الافتراضي 'safe'.                  |
+| **متعدد الوسائط** _(اختياري)_             | `multimodal`             | `bool`                                | ما إذا كان الوكيل يدعم القدرات متعددة الوسائط. الافتراضي False.                                    |
+| **حقن التاريخ** _(اختياري)_            | `inject_date`            | `bool`                                | ما إذا كان يتم حقن التاريخ الحالي تلقائيًا في المهام. الافتراضي False.                           |
+| **تنسيق التاريخ** _(اختياري)_            | `date_format`            | `str`                                 | سلسلة تنسيق التاريخ عند تفعيل inject_date. الافتراضي "%Y-%m-%d" (تنسيق ISO).                  |
+| **الاستدلال** _(اختياري)_              | `reasoning`              | `bool`                                | ما إذا كان يجب على الوكيل التأمل وإنشاء خطة قبل تنفيذ المهمة. الافتراضي False.            |
+| **الحد الأقصى لمحاولات الاستدلال** _(اختياري)_ | `max_reasoning_attempts` | `Optional[int]`                       | الحد الأقصى لمحاولات الاستدلال قبل تنفيذ المهمة. إذا None، سيحاول حتى الاستعداد.           |
+| **المُضمّن** _(اختياري)_               | `embedder`               | `Optional[Dict[str, Any]]`            | تهيئة المُضمّن المستخدم من قبل الوكيل.                                                        |
+| **مصادر المعرفة** _(اختياري)_      | `knowledge_sources`      | `Optional[List[BaseKnowledgeSource]]` | مصادر المعرفة المتاحة للوكيل.                                                                |
+| **استخدام أمر النظام** _(اختياري)_      | `use_system_prompt`      | `Optional[bool]`                      | ما إذا كان يُستخدم أمر النظام (لدعم نموذج o1). الافتراضي True.                                    |
+
+## إنشاء الوكلاء
+
+هناك طريقتان شائعتان لإنشاء الوكلاء في CrewAI: باستخدام **تهيئة JSONC (الموصى بها للـ crews الجديدة)** أو تعريفهم **مباشرة في الكود**.
+
+### تهيئة JSONC (موصى بها)
+
+المشاريع الجديدة التي تُنشأ عبر `crewai create crew <name>` تستخدم تهيئة JSON-first. يُعرّف كل Agent في `agents/<agent_name>.jsonc`، ويحدد `crew.jsonc` أي Agents تدخل في الـ crew.
+
+```jsonc agents/researcher.jsonc
+{
+  "role": "{topic} Senior Data Researcher",
+  "goal": "Uncover cutting-edge developments in {topic}",
+  "backstory": "You find the most relevant information and present it clearly.",
+  "llm": "openai/gpt-4o",
+  "tools": ["SerperDevTool"],
+  "settings": {
+    "verbose": true,
+    "allow_delegation": false
+  }
+}
+```
+
+استخدم `{placeholder}` داخل `role` أو `goal` أو `backstory`. ضع القيم الافتراضية في `inputs` داخل `crew.jsonc`؛ وسيطلب `crewai run` أي قيم ناقصة. يمكن وضع حقول السلوك مثل `verbose` و `allow_delegation` و `max_iter` و `memory` و `cache` و `planning_config` في المستوى الأعلى أو داخل `settings`.
+
+<Note>
+يدعم JSONC التعليقات والفواصل النهائية. إذا وُجد `agents/<name>.jsonc` و `agents/<name>.json` معًا، يستخدم CrewAI ملف JSONC.
+</Note>
+
+### تهيئة YAML الكلاسيكية
+
+المشاريع الكلاسيكية التي تُنشأ عبر `crewai create crew <name> --classic` تستخدم `config/agents.yaml` وفئة `@CrewBase` في `crew.py`.
+
+تظل تهيئة YAML مدعومة للمشاريع الحالية المبنية بـ Python/YAML وللفِرق التي تفضل تعريف الوكلاء من خلال فئة `@CrewBase`.
+
+بعد إنشاء مشروع كلاسيكي، انتقل إلى ملف `src/<project_name>/config/agents.yaml` وعدّل القالب ليتوافق مع متطلباتك.
+
+<Note>
+ستُستبدل المتغيرات في ملفات YAML (مثل `{topic}`) بقيم من مدخلاتك عند تشغيل الطاقم:
+```python Code
+crew.kickoff(inputs={'topic': 'AI Agents'})
+```
+</Note>
+
+إليك مثالًا على كيفية تهيئة الوكلاء باستخدام YAML:
+
+```yaml agents.yaml
+# src/<project_name>/config/agents.yaml
+researcher:
+  role: >
+    {topic} Senior Data Researcher
+  goal: >
+    Uncover cutting-edge developments in {topic}
+  backstory: >
+    You're a seasoned researcher with a knack for uncovering the latest
+    developments in {topic}. Known for your ability to find the most relevant
+    information and present it in a clear and concise manner.
+
+reporting_analyst:
+  role: >
+    {topic} Reporting Analyst
+  goal: >
+    Create detailed reports based on {topic} data analysis and research findings
+  backstory: >
+    You're a meticulous analyst with a keen eye for detail. You're known for
+    your ability to turn complex data into clear and concise reports, making
+    it easy for others to understand and act on the information you provide.
+```
+
+لاستخدام تهيئة YAML في الكود، أنشئ فئة طاقم ترث من `CrewBase`:
+
+```python Code
+# src/<project_name>/crew.py
+from crewai import Agent, Crew, Process
+from crewai.project import CrewBase, agent, crew
+from crewai_tools import SerperDevTool
+
+@CrewBase
+class LatestAiDevelopmentCrew():
+  """LatestAiDevelopment crew"""
+
+  agents_config = "config/agents.yaml"
+
+  @agent
+  def researcher(self) -> Agent:
+    return Agent(
+      config=self.agents_config['researcher'], # type: ignore[index]
+      verbose=True,
+      tools=[SerperDevTool()]
+    )
+
+  @agent
+  def reporting_analyst(self) -> Agent:
+    return Agent(
+      config=self.agents_config['reporting_analyst'], # type: ignore[index]
+      verbose=True
+    )
+```
+
+<Note>
+  يجب أن تتطابق الأسماء المستخدمة في ملفات YAML (`agents.yaml`) مع أسماء
+  الطرق في كود Python.
+</Note>
+
+### تعريف مباشر في الكود
+
+يمكنك إنشاء الوكلاء مباشرة في الكود بإنشاء فئة `Agent`. إليك مثالًا شاملًا يوضح جميع المعاملات المتاحة:
+
+```python Code
+from crewai import Agent
+from crewai_tools import SerperDevTool
+
+# إنشاء وكيل بجميع المعاملات المتاحة
+agent = Agent(
+    role="Senior Data Scientist",
+    goal="Analyze and interpret complex datasets to provide actionable insights",
+    backstory="With over 10 years of experience in data science and machine learning, "
+              "you excel at finding patterns in complex datasets.",
+    llm="gpt-4",
+    function_calling_llm=None,
+    verbose=False,
+    allow_delegation=False,
+    max_iter=20,
+    max_rpm=None,
+    max_execution_time=None,
+    max_retry_limit=2,
+    allow_code_execution=False,
+    code_execution_mode="safe",
+    respect_context_window=True,
+    use_system_prompt=True,
+    multimodal=False,
+    inject_date=False,
+    date_format="%Y-%m-%d",
+    reasoning=False,
+    max_reasoning_attempts=None,
+    tools=[SerperDevTool()],
+    knowledge_sources=None,
+    embedder=None,
+    system_template=None,
+    prompt_template=None,
+    response_template=None,
+    step_callback=None,
+)
+```
+
+دعنا نستعرض بعض تركيبات المعاملات الرئيسية لحالات الاستخدام الشائعة:
+
+#### وكيل بحث أساسي
+
+```python Code
+research_agent = Agent(
+    role="Research Analyst",
+    goal="Find and summarize information about specific topics",
+    backstory="You are an experienced researcher with attention to detail",
+    tools=[SerperDevTool()],
+    verbose=True
+)
+```
+
+#### وكيل تطوير الكود
+
+```python Code
+dev_agent = Agent(
+    role="Senior Python Developer",
+    goal="Write and debug Python code",
+    backstory="Expert Python developer with 10 years of experience",
+    allow_code_execution=True,
+    code_execution_mode="safe",
+    max_execution_time=300,
+    max_retry_limit=3
+)
+```
+
+#### وكيل تحليل طويل المدى
+
+```python Code
+analysis_agent = Agent(
+    role="Data Analyst",
+    goal="Perform deep analysis of large datasets",
+    backstory="Specialized in big data analysis and pattern recognition",
+    memory=True,
+    respect_context_window=True,
+    max_rpm=10,
+    function_calling_llm="gpt-4o-mini"
+)
+```
+
+### تفاصيل المعاملات
+
+#### المعاملات الحرجة
+
+- `role` و `goal` و `backstory` مطلوبة وتشكّل سلوك الوكيل
+- `llm` يحدد نموذج اللغة المستخدم (افتراضي: GPT-4 من OpenAI)
+
+#### الذاكرة والسياق
+
+- `memory`: تفعيل للحفاظ على سجل المحادثة
+- `respect_context_window`: يمنع مشاكل حد الرموز
+- `knowledge_sources`: إضافة قواعد معرفة خاصة بالمجال
+
+#### التحكم في التنفيذ
+
+- `max_iter`: الحد الأقصى للمحاولات قبل تقديم أفضل إجابة
+- `max_execution_time`: المهلة بالثواني
+- `max_rpm`: تحديد معدل استدعاءات API
+- `max_retry_limit`: إعادات المحاولة عند الخطأ
+
+#### تنفيذ الكود
+
+<Warning>
+  `allow_code_execution` و`code_execution_mode` مهجوران. تمت إزالة `CodeInterpreterTool` من `crewai-tools`. استخدم خدمة بيئة معزولة مخصصة مثل [E2B](https://e2b.dev) أو [Modal](https://modal.com) لتنفيذ الكود بأمان.
+</Warning>
+
+- `allow_code_execution` _(مهجور)_: كان يُمكّن تنفيذ الكود المدمج عبر `CodeInterpreterTool`.
+- `code_execution_mode` _(مهجور)_: كان يتحكم في وضع التنفيذ (`"safe"` لـ Docker، `"unsafe"` للتنفيذ المباشر).
+
+#### الميزات المتقدمة
+
+- `multimodal`: تفعيل القدرات متعددة الوسائط لمعالجة النص والمحتوى المرئي
+- `reasoning`: تمكين الوكيل من التأمل وإنشاء خطط قبل تنفيذ المهام
+- `inject_date`: حقن التاريخ الحالي تلقائيًا في أوصاف المهام
+
+#### القوالب
+
+- `system_template`: يحدد السلوك الأساسي للوكيل
+- `prompt_template`: ينظم تنسيق الإدخال
+- `response_template`: ينسّق استجابات الوكيل
+
+<Note>
+  عند استخدام القوالب المخصصة، تأكد من تعريف كل من `system_template` و
+  `prompt_template`. `response_template` اختياري لكن يُوصى به
+  لتنسيق مخرجات متسق.
+</Note>
+
+## أدوات الوكيل
+
+يمكن تجهيز الوكلاء بأدوات متنوعة لتعزيز قدراتهم. يدعم CrewAI أدوات من:
+
+- [مجموعة أدوات CrewAI](https://github.com/joaomdmoura/crewai-tools)
+- [أدوات LangChain](https://python.langchain.com/docs/integrations/tools)
+
+إليك كيفية إضافة أدوات لوكيل:
+
+```python Code
+from crewai import Agent
+from crewai_tools import SerperDevTool, WikipediaTools
+
+# إنشاء الأدوات
+search_tool = SerperDevTool()
+wiki_tool = WikipediaTools()
+
+# إضافة أدوات للوكيل
+researcher = Agent(
+    role="AI Technology Researcher",
+    goal="Research the latest AI developments",
+    tools=[search_tool, wiki_tool],
+    verbose=True
+)
+```
+
+## التفاعل المباشر مع الوكيل عبر `kickoff()`
+
+يمكن استخدام الوكلاء مباشرة بدون المرور بمهمة أو سير عمل طاقم باستخدام طريقة `kickoff()`. يوفر هذا طريقة أبسط للتفاعل مع وكيل عندما لا تحتاج إلى إمكانيات تنسيق الطاقم الكاملة.
+
+```python Code
+from crewai import Agent
+from crewai_tools import SerperDevTool
+
+# إنشاء وكيل
+researcher = Agent(
+    role="AI Technology Researcher",
+    goal="Research the latest AI developments",
+    tools=[SerperDevTool()],
+    verbose=True
+)
+
+# استخدام kickoff() للتفاعل مباشرة مع الوكيل
+result = researcher.kickoff("What are the latest developments in language models?")
+
+# الوصول إلى الاستجابة الخام
+print(result.raw)
+```
+
+## اعتبارات مهمة وأفضل الممارسات
+
+### الأمان وتنفيذ الكود
+
+<Warning>
+  `allow_code_execution` و`code_execution_mode` مهجوران وتمت إزالة `CodeInterpreterTool`. استخدم خدمة بيئة معزولة مخصصة مثل [E2B](https://e2b.dev) أو [Modal](https://modal.com) لتنفيذ الكود بأمان.
+</Warning>
+
+### تحسين الأداء
+
+- استخدم `respect_context_window: true` لمنع مشاكل حد الرموز
+- عيّن `max_rpm` مناسبًا لتجنب تحديد المعدل
+- فعّل `cache: true` لتحسين الأداء للمهام المتكررة
+- اضبط `max_iter` و `max_retry_limit` بناءً على تعقيد المهمة
+
+### إدارة الذاكرة والسياق
+
+- استفد من `knowledge_sources` للمعلومات الخاصة بالمجال
+- هيّئ `embedder` عند استخدام نماذج تضمين مخصصة
+- استخدم القوالب المخصصة للتحكم الدقيق في سلوك الوكيل
+
+### التعاون بين الوكلاء
+
+- فعّل `allow_delegation: true` عندما يحتاج الوكلاء للعمل معًا
+- استخدم `step_callback` لمراقبة وتسجيل تفاعلات الوكلاء
+- فكّر في استخدام نماذج LLM مختلفة لأغراض مختلفة
+
+### توافق النموذج
+
+- عيّن `use_system_prompt: false` للنماذج القديمة التي لا تدعم رسائل النظام
+- تأكد من أن `llm` المختار يدعم الميزات التي تحتاجها

docs/edge/ar/concepts/checkpointing.mdx

@@ -0,0 +1,423 @@
+---
+title: Checkpointing
+description: حفظ حالة التنفيذ تلقائيا حتى تتمكن الطواقم والتدفقات والوكلاء من الاستئناف بعد الفشل.
+icon: floppy-disk
+mode: "wide"
+---
+
+الـ Checkpointing يحفظ لقطة من حالة التنفيذ أثناء التشغيل بحيث يمكن لطاقم أو تدفق أو وكيل الاستئناف بعد الفشل أو التفرع إلى فرع بديل.
+
+<CardGroup cols={2}>
+  <Card title="الشرح" icon="lightbulb" href="#الشرح">
+    كيف يعمل الـ Checkpointing: الأحداث والتخزين والوراثة.
+  </Card>
+  <Card title="درس تطبيقي" icon="graduation-cap" href="#درس-تطبيقي-استئناف-طاقم-فاشل">
+    دليل 5 دقائق: تشغيل، إيقاف، استئناف.
+  </Card>
+  <Card title="ادلة عملية" icon="screwdriver-wrench" href="#ادلة-عملية">
+    وصفات مركزة على المهام لسير العمل الشائع.
+  </Card>
+  <Card title="المرجع" icon="book" href="#المرجع">
+    `CheckpointConfig` والأحداث والمزودات وسطر الأوامر.
+  </Card>
+</CardGroup>
+
+## الشرح
+
+### ما هي نقطة الحفظ
+
+تلتقط نقطة الحفظ كل ما يحتاجه CrewAI لإعادة إنشاء تشغيل أثناء سيره: الحالة الكاملة للطاقم أو التدفق أو الوكيل — التكوين، وذاكرة الوكلاء ومصادر المعرفة، وتقدم المهام، والمخرجات الوسيطة، والحالة الداخلية والسمات — إلى جانب مدخلات الـ kickoff، وسجل الأحداث حتى تلك النقطة، ومعرف نسب يربط نقطة الحفظ بالتشغيل الذي جاءت منه.
+
+الاستعادة تعيد بناء تلك الحالة وتستمر. تتخطى المهام المكتملة، وتعاد ترطيب الذاكرة والمعرفة، ويعمل العمل التابع على نفس المخرجات التي أنتجها التشغيل الأصلي. التفرع يجري نفس الاستعادة تحت نسب جديد، بحيث يكتب الفرع الجديد والتشغيل الأصلي نقاط الحفظ جنبا إلى جنب دون أن يطمس أحدهما الآخر.
+
+### متى تكتب نقاط الحفظ
+
+الـ Checkpointing مدفوع بالأحداث. يشترك وقت التشغيل في الأحداث التي تحددها عبر `on_events` ويكتب نقطة حفظ عند إطلاق أحدها. الافتراضي `task_completed` ينتج نقطة حفظ لكل مهمة منتهية — توازن معقول بين الدقة واستخدام القرص. الأحداث عالية التردد مثل `llm_call_completed` متاحة للاستعادة الدقيقة لكنها تكتب ملفات أكثر بكثير.
+
+### التخزين
+
+يتضمن CrewAI مزودين:
+
+- `JsonProvider` يكتب ملفا لكل نقطة حفظ. قابل للقراءة وسهل التفقد.
+- `SqliteProvider` يكتب إلى قاعدة بيانات SQLite واحدة. أفضل لنقاط الحفظ عالية التردد.
+
+كلاهما يحذف أقدم نقاط الحفظ عند تحديد `max_checkpoints`.
+
+<Note>
+كتابة نقاط الحفظ بأفضل جهد. فشل نقطة حفظ يسجل لكنه لا يقاطع التشغيل.
+</Note>
+
+### نموذج الوراثة
+
+`Crew` و`Flow` و`Agent` كلها تقبل وسيط `checkpoint`. يرث الأبناء من الأب ما لم يحددوا قيمتهم الخاصة أو يمرروا `False` للانسحاب. فعل الـ Checkpointing مرة واحدة على الطاقم وتشارك كل الوكلاء، أو استبعد وكيلا واحدا بشكل انتقائي.
+
+## درس تطبيقي: استئناف طاقم فاشل
+
+هذا الدليل يستغرق حوالي 5 دقائق. ستشغل طاقما بمهمتين، توقفه في المنتصف، ثم تستأنف من نقطة الحفظ المحفوظة.
+
+<Steps>
+  <Step title="أنشئ الطاقم مع تفعيل الـ Checkpointing">
+    ```python
+    from crewai import Agent, Crew, Task
+
+    researcher = Agent(role="Researcher", goal="Research", backstory="Expert")
+    writer = Agent(role="Writer", goal="Write", backstory="Expert")
+
+    crew = Crew(
+        agents=[researcher, writer],
+        tasks=[
+            Task(description="Research AI trends", agent=researcher, expected_output="bullets"),
+            Task(description="Write a summary", agent=writer, expected_output="paragraph"),
+        ],
+        checkpoint=True,
+    )
+    ```
+  </Step>
+  <Step title="شغله وأوقفه بعد المهمة الأولى">
+    ```python
+    result = crew.kickoff()
+    ```
+
+    اضغط `Ctrl+C` بعد انتهاء المهمة الأولى. في `./.checkpoints/`، الملف بصيغة `<timestamp>_<uuid>.json` هو نقطة الحفظ.
+  </Step>
+  <Step title="استأنف من نقطة الحفظ">
+    ```python
+    from crewai import CheckpointConfig
+
+    result = crew.kickoff(
+        from_checkpoint=CheckpointConfig(
+            restore_from="./.checkpoints/<timestamp>_<uuid>.json",
+        ),
+    )
+    ```
+
+    يتم تخطي مهمة البحث، ويعمل الكاتب على مخرجات البحث المحفوظة، وينتهي الطاقم.
+  </Step>
+</Steps>
+
+## ادلة عملية
+
+<AccordionGroup>
+  <Accordion title="تفعيل الـ Checkpointing بالإعدادات الافتراضية" icon="play">
+    ```python
+    crew = Crew(agents=[...], tasks=[...], checkpoint=True)
+    ```
+
+    يكتب إلى `./.checkpoints/` عند كل `task_completed`.
+  </Accordion>
+
+  <Accordion title="تخصيص التخزين والتردد" icon="sliders">
+    ```python
+    from crewai import Crew, CheckpointConfig
+
+    crew = Crew(
+        agents=[...],
+        tasks=[...],
+        checkpoint=CheckpointConfig(
+            location="./my_checkpoints",
+            on_events=["task_completed", "crew_kickoff_completed"],
+            max_checkpoints=5,
+        ),
+    )
+    ```
+  </Accordion>
+
+  <Accordion title="اختيار مزود التخزين" icon="database">
+    <CodeGroup>
+    ```python JsonProvider
+    from crewai import Crew, CheckpointConfig
+    from crewai.state import JsonProvider
+
+    crew = Crew(
+        agents=[...],
+        tasks=[...],
+        checkpoint=CheckpointConfig(
+            location="./my_checkpoints",
+            provider=JsonProvider(),
+            max_checkpoints=5,
+        ),
+    )
+    ```
+    ```python SqliteProvider
+    from crewai import Crew, CheckpointConfig
+    from crewai.state import SqliteProvider
+
+    crew = Crew(
+        agents=[...],
+        tasks=[...],
+        checkpoint=CheckpointConfig(
+            location="./.checkpoints.db",
+            provider=SqliteProvider(),
+            max_checkpoints=50,
+        ),
+    )
+    ```
+    </CodeGroup>
+
+    <Tip>
+    SQLite يفعل وضع journal WAL للقراءات المتزامنة. يفضل لنقاط الحفظ عالية التردد.
+    </Tip>
+  </Accordion>
+
+  <Accordion title="استبعاد وكيل واحد" icon="user-slash">
+    ```python
+    crew = Crew(
+        agents=[
+            Agent(role="Researcher", ...),
+            Agent(role="Writer", ..., checkpoint=False),
+        ],
+        tasks=[...],
+        checkpoint=True,
+    )
+    ```
+  </Accordion>
+
+  <Accordion title="التفرع إلى فرع جديد" icon="code-branch">
+    `fork()` يستعيد نقطة حفظ تحت نسب جديد بحيث لا يتصادم التشغيل الجديد مع الأصلي.
+
+    ```python
+    config = CheckpointConfig(restore_from="./my_checkpoints/<file>.json")
+    crew = Crew.fork(config, branch="experiment-a")
+    result = crew.kickoff(inputs={"strategy": "aggressive"})
+    ```
+
+    تسمية `branch` اختيارية؛ يتم إنشاء واحدة إذا أغفلت.
+  </Accordion>
+
+  <Accordion title="Checkpointing لـ Crew أو Flow أو Agent" icon="cubes">
+    <Tabs>
+      <Tab title="Crew">
+        ```python
+        crew = Crew(
+            agents=[researcher, writer],
+            tasks=[research_task, write_task, review_task],
+            checkpoint=CheckpointConfig(location="./crew_cp"),
+        )
+        ```
+
+        المشغل الافتراضي: `task_completed`.
+      </Tab>
+      <Tab title="Flow">
+        ```python
+        from crewai.flow.flow import Flow, start, listen
+        from crewai import CheckpointConfig
+
+        class MyFlow(Flow):
+            @start()
+            def step_one(self):
+                return "data"
+
+            @listen(step_one)
+            def step_two(self, data):
+                return process(data)
+
+        flow = MyFlow(
+            checkpoint=CheckpointConfig(
+                location="./flow_cp",
+                on_events=["method_execution_finished"],
+            ),
+        )
+        result = flow.kickoff()
+        ```
+      </Tab>
+      <Tab title="Agent">
+        ```python
+        agent = Agent(
+            role="Researcher",
+            goal="Research topics",
+            backstory="Expert researcher",
+            checkpoint=CheckpointConfig(
+                location="./agent_cp",
+                on_events=["lite_agent_execution_completed"],
+            ),
+        )
+        result = agent.kickoff(messages=[{"role": "user", "content": "Research AI trends"}])
+        ```
+      </Tab>
+    </Tabs>
+  </Accordion>
+
+  <Accordion title="كتابة نقطة حفظ يدويا" icon="code">
+    سجل معالجا على أي حدث واستدع `state.checkpoint()`.
+
+    <CodeGroup>
+    ```python Sync
+    from __future__ import annotations
+
+    from typing import TYPE_CHECKING, Any
+
+    from crewai.events.event_bus import crewai_event_bus
+    from crewai.events.types.llm_events import LLMCallCompletedEvent
+
+    if TYPE_CHECKING:
+        from crewai.state.runtime import RuntimeState
+
+
+    @crewai_event_bus.on(LLMCallCompletedEvent)
+    def on_llm_done(source: Any, event: LLMCallCompletedEvent, state: RuntimeState) -> None:
+        path = state.checkpoint("./my_checkpoints")
+        print(f"تم حفظ نقطة الحفظ: {path}")
+    ```
+    ```python Async
+    from __future__ import annotations
+
+    from typing import TYPE_CHECKING, Any
+
+    from crewai.events.event_bus import crewai_event_bus
+    from crewai.events.types.llm_events import LLMCallCompletedEvent
+
+    if TYPE_CHECKING:
+        from crewai.state.runtime import RuntimeState
+
+
+    @crewai_event_bus.on(LLMCallCompletedEvent)
+    async def on_llm_done_async(source: Any, event: LLMCallCompletedEvent, state: RuntimeState) -> None:
+        path = await state.acheckpoint("./my_checkpoints")
+        print(f"تم حفظ نقطة الحفظ: {path}")
+    ```
+    </CodeGroup>
+
+    يتم تمرير وسيط `state` تلقائيا عندما يقبل المعالج ثلاثة معاملات. راجع [Event Listeners](/ar/concepts/event-listener) لقائمة الأحداث الكاملة.
+  </Accordion>
+
+  <Accordion title="التصفح والاستئناف والتفرع من سطر الأوامر" icon="terminal">
+    ```bash
+    crewai checkpoint
+    crewai checkpoint --location ./my_checkpoints
+    crewai checkpoint --location ./.checkpoints.db
+    ```
+
+    <Frame caption="شجرة نقاط الحفظ — الفروع والتفرعات تتداخل تحت أبيها.">
+      <img src="/images/checkpoint-tui-tree.png" alt="Checkpoint TUI tree view" />
+    </Frame>
+
+    اللوحة اليسرى تجمع نقاط الحفظ حسب الفرع؛ التفرعات تتداخل تحت أبيها. اختيار نقطة حفظ يفتح لوحة التفاصيل مع بياناتها الوصفية وحالة الكيان وتقدم المهام. **Resume** يكمل التشغيل؛ **Fork** يبدأ فرعا جديدا.
+
+    <Frame caption="تبويب النظرة العامة — البيانات الوصفية وحالة الكيان وملخص التشغيل.">
+      <img src="/images/checkpoint-tui-detail-overview.png" alt="Checkpoint detail overview tab" />
+    </Frame>
+
+    لوحة التفاصيل تعرض منطقتين قابلتين للتحرير:
+
+    - **Inputs** — مدخلات الـ kickoff الأصلية، معبأة مسبقا وقابلة للتحرير.
+
+      <Frame>
+        <img src="/images/checkpoint-tui-detail-inputs.png" alt="Editable kickoff inputs" />
+      </Frame>
+
+    - **مخرجات المهام** — مخرجات المهام المكتملة. تحرير مخرج والضغط على **Fork** يبطل المهام التابعة لتعاد بالسياق المعدل.
+
+      <Frame>
+        <img src="/images/checkpoint-tui-detail-tasks.png" alt="Editable task outputs" />
+      </Frame>
+
+    <Frame caption="عرض التفرع — تأكيد فرع جديد من نقطة الحفظ المختارة.">
+      <img src="/images/checkpoint-tui-details-fork.png" alt="Fork confirmation panel" />
+    </Frame>
+
+    <Tip>
+    مفيد لاستكشاف "ماذا لو": تفرع، عدل، راقب.
+    </Tip>
+  </Accordion>
+
+  <Accordion title="تفقد نقاط الحفظ بدون TUI" icon="magnifying-glass">
+    ```bash
+    crewai checkpoint list ./my_checkpoints
+    crewai checkpoint info ./my_checkpoints/<file>.json
+    crewai checkpoint info ./.checkpoints.db
+    ```
+  </Accordion>
+</AccordionGroup>
+
+## المرجع
+
+### `CheckpointConfig`
+
+<ParamField path="location" type="str" default='"./.checkpoints"'>
+  وجهة التخزين. مجلد لـ `JsonProvider`، مسار ملف قاعدة بيانات لـ `SqliteProvider`.
+</ParamField>
+
+<ParamField path="on_events" type='list[CheckpointEventType | Literal["*"]]' default='["task_completed"]'>
+  أنواع الأحداث التي تطلق نقطة حفظ. `CheckpointEventType` هو `Literal` — مدقق الأنواع يكمل تلقائيا ويرفض القيم غير المدعومة. راجع [أنواع الأحداث](#أنواع-الأحداث) للقائمة الكاملة.
+</ParamField>
+
+<ParamField path="provider" type="BaseProvider" default="JsonProvider()">
+  واجهة التخزين. `JsonProvider` أو `SqliteProvider`.
+</ParamField>
+
+<ParamField path="max_checkpoints" type="int | None" default="None">
+  الحد الاقصى لنقاط الحفظ المحتفظ بها. الأقدم تحذف بعد كل كتابة.
+</ParamField>
+
+<ParamField path="restore_from" type="Path | str | None" default="None">
+  نقطة الحفظ المراد استعادتها عند تمريرها عبر `from_checkpoint`.
+</ParamField>
+
+### قيم حقل `checkpoint`
+
+مقبولة في `Crew` و`Flow` و`Agent`.
+
+<ParamField path="None" type="افتراضي">
+  يرث من الأب.
+</ParamField>
+
+<ParamField path="True" type="bool">
+  تفعيل بالإعدادات الافتراضية.
+</ParamField>
+
+<ParamField path="False" type="bool">
+  انسحاب صريح. يوقف الوراثة.
+</ParamField>
+
+<ParamField path="CheckpointConfig(...)" type="CheckpointConfig">
+  إعدادات مخصصة.
+</ParamField>
+
+### أنواع الأحداث
+
+يقبل `on_events` أي مجموعة من قيم `CheckpointEventType`. الافتراضي `["task_completed"]` يكتب نقطة حفظ لكل مهمة منتهية، و`["*"]` يطابق جميع الأحداث.
+
+<Warning>
+`["*"]` والأحداث عالية التردد مثل `llm_call_completed` تكتب نقاط حفظ كثيرة وقد تضر بالاداء. استخدمها مع `max_checkpoints`.
+</Warning>
+
+<Expandable title="جميع الأحداث المدعومة">
+
+- **Task** — `task_started`, `task_completed`, `task_failed`, `task_evaluation`
+- **Crew** — `crew_kickoff_started`, `crew_kickoff_completed`, `crew_kickoff_failed`, `crew_train_started`, `crew_train_completed`, `crew_train_failed`, `crew_test_started`, `crew_test_completed`, `crew_test_failed`, `crew_test_result`
+- **Agent** — `agent_execution_started`, `agent_execution_completed`, `agent_execution_error`, `lite_agent_execution_started`, `lite_agent_execution_completed`, `lite_agent_execution_error`, `agent_evaluation_started`, `agent_evaluation_completed`, `agent_evaluation_failed`
+- **Flow** — `flow_created`, `flow_started`, `flow_finished`, `flow_paused`, `method_execution_started`, `method_execution_finished`, `method_execution_failed`, `method_execution_paused`, `human_feedback_requested`, `human_feedback_received`, `flow_input_requested`, `flow_input_received`
+- **LLM** — `llm_call_started`, `llm_call_completed`, `llm_call_failed`, `llm_stream_chunk`, `llm_thinking_chunk`
+- **LLM Guardrail** — `llm_guardrail_started`, `llm_guardrail_completed`, `llm_guardrail_failed`
+- **Tool** — `tool_usage_started`, `tool_usage_finished`, `tool_usage_error`, `tool_validate_input_error`, `tool_selection_error`, `tool_execution_error`
+- **Memory** — `memory_save_started`, `memory_save_completed`, `memory_save_failed`, `memory_query_started`, `memory_query_completed`, `memory_query_failed`, `memory_retrieval_started`, `memory_retrieval_completed`, `memory_retrieval_failed`
+- **Knowledge** — `knowledge_search_query_started`, `knowledge_search_query_completed`, `knowledge_query_started`, `knowledge_query_completed`, `knowledge_query_failed`, `knowledge_search_query_failed`
+- **Reasoning** — `agent_reasoning_started`, `agent_reasoning_completed`, `agent_reasoning_failed`
+- **MCP** — `mcp_connection_started`, `mcp_connection_completed`, `mcp_connection_failed`, `mcp_tool_execution_started`, `mcp_tool_execution_completed`, `mcp_tool_execution_failed`, `mcp_config_fetch_failed`
+- **Observation** — `step_observation_started`, `step_observation_completed`, `step_observation_failed`, `plan_refinement`, `plan_replan_triggered`, `goal_achieved_early`
+- **Skill** — `skill_discovery_started`, `skill_discovery_completed`, `skill_loaded`, `skill_activated`, `skill_load_failed`
+- **Logging** — `agent_logs_started`, `agent_logs_execution`
+- **A2A** — `a2a_delegation_started`, `a2a_delegation_completed`, `a2a_conversation_started`, `a2a_conversation_completed`, `a2a_message_sent`, `a2a_response_received`, `a2a_polling_started`, `a2a_polling_status`, `a2a_push_notification_registered`, `a2a_push_notification_received`, `a2a_push_notification_sent`, `a2a_push_notification_timeout`, `a2a_streaming_started`, `a2a_streaming_chunk`, `a2a_agent_card_fetched`, `a2a_authentication_failed`, `a2a_artifact_received`, `a2a_connection_error`, `a2a_server_task_started`, `a2a_server_task_completed`, `a2a_server_task_canceled`, `a2a_server_task_failed`, `a2a_parallel_delegation_started`, `a2a_parallel_delegation_completed`, `a2a_transport_negotiated`, `a2a_content_type_negotiated`, `a2a_context_created`, `a2a_context_expired`, `a2a_context_idle`, `a2a_context_completed`, `a2a_context_pruned`
+- **إشارات النظام** — `SIGTERM`, `SIGINT`, `SIGHUP`, `SIGTSTP`, `SIGCONT`
+- **حرف بدل** — `"*"` يطابق جميع الأحداث.
+
+</Expandable>
+
+### مزودات التخزين
+
+<ParamField path="JsonProvider" type="provider">
+  ملف واحد لكل نقطة حفظ بصيغة `<timestamp>_<uuid>.json` داخل `location`.
+</ParamField>
+
+<ParamField path="SqliteProvider" type="provider">
+  ملف قاعدة بيانات واحد في `location` مع journaling WAL.
+</ParamField>
+
+### سطر الأوامر
+
+| الامر | الغرض |
+|:------|:------|
+| `crewai checkpoint` | تشغيل TUI؛ كشف التخزين تلقائيا. |
+| `crewai checkpoint --location <path>` | تشغيل TUI على موقع محدد. |
+| `crewai checkpoint list <path>` | سرد نقاط الحفظ. |
+| `crewai checkpoint info <path>` | تفقد ملف نقطة حفظ أو آخر مدخل في قاعدة بيانات SQLite. |

docs/edge/ar/concepts/cli.mdx

@@ -0,0 +1,302 @@
+---
+title: واجهة سطر الأوامر
+description: تعرّف على كيفية استخدام واجهة سطر أوامر CrewAI للتفاعل مع CrewAI.
+icon: terminal
+mode: "wide"
+---
+
+<Warning>
+  منذ الإصدار 0.140.0، بدأ CrewAI AMP عملية نقل مزود تسجيل الدخول.
+  لذلك، تم تحديث تدفق المصادقة عبر CLI. المستخدمون الذين يسجلون الدخول
+  باستخدام Google، أو الذين أنشأوا حساباتهم بعد 3 يوليو 2025 لن يتمكنوا
+  من تسجيل الدخول مع الإصدارات القديمة من مكتبة `crewai`.
+</Warning>
+
+## نظرة عامة
+
+توفر واجهة سطر أوامر CrewAI مجموعة من الأوامر للتفاعل مع CrewAI، مما يتيح لك إنشاء وتدريب وتشغيل وإدارة الأطقم والتدفقات.
+
+## التثبيت
+
+لاستخدام واجهة سطر أوامر CrewAI، تأكد من تثبيت CrewAI:
+
+```shell Terminal
+pip install crewai
+```
+
+## الاستخدام الأساسي
+
+الهيكل الأساسي لأمر CrewAI CLI هو:
+
+```shell Terminal
+crewai [COMMAND] [OPTIONS] [ARGUMENTS]
+```
+
+## الأوامر المتاحة
+
+### 1. إنشاء
+
+إنشاء طاقم أو تدفق جديد.
+
+```shell Terminal
+crewai create [OPTIONS] TYPE NAME
+```
+
+- `TYPE`: اختر بين "crew" أو "flow"
+- `NAME`: اسم الطاقم أو التدفق
+
+مثال:
+
+```shell Terminal
+crewai create crew my_new_crew
+crewai create flow my_new_flow
+```
+
+افتراضيًا، ينشئ `crewai create crew` مشروعًا JSON-first يحتوي على `crew.jsonc` و `agents/*.jsonc`. استخدم `crewai create crew my_new_crew --classic` فقط إذا أردت البنية القديمة Python/YAML مع `crew.py` و `config/agents.yaml` و `config/tasks.yaml`.
+
+### 2. الإصدار
+
+عرض الإصدار المثبت من CrewAI.
+
+```shell Terminal
+crewai version [OPTIONS]
+```
+
+- `--tools`: (اختياري) عرض الإصدار المثبت من أدوات CrewAI
+
+### 3. التدريب
+
+تدريب الطاقم لعدد محدد من التكرارات.
+
+```shell Terminal
+crewai train [OPTIONS]
+```
+
+- `-n, --n_iterations INTEGER`: عدد تكرارات التدريب (افتراضي: 5)
+- `-f, --filename TEXT`: مسار ملف مخصص للتدريب (افتراضي: "trained_agents_data.pkl")
+
+### 4. الإعادة
+
+إعادة تنفيذ الطاقم من مهمة محددة.
+
+```shell Terminal
+crewai replay [OPTIONS]
+```
+
+- `-t, --task_id TEXT`: إعادة تنفيذ الطاقم من معرّف المهمة هذا، بما في ذلك جميع المهام اللاحقة
+
+### 5. سجل مخرجات المهام
+
+استرجاع أحدث مخرجات مهام crew.kickoff().
+
+```shell Terminal
+crewai log-tasks-outputs
+```
+
+### 6. إعادة تعيين الذاكرة
+
+إعادة تعيين ذاكرة الطاقم (طويلة، قصيرة، الكيانات، أحدث مخرجات التشغيل).
+
+```shell Terminal
+crewai reset-memories [OPTIONS]
+```
+
+- `-l, --long`: إعادة تعيين الذاكرة طويلة المدى
+- `-s, --short`: إعادة تعيين الذاكرة قصيرة المدى
+- `-e, --entities`: إعادة تعيين ذاكرة الكيانات
+- `-k, --kickoff-outputs`: إعادة تعيين أحدث مخرجات التشغيل
+- `-kn, --knowledge`: إعادة تعيين تخزين المعرفة
+- `-akn, --agent-knowledge`: إعادة تعيين تخزين معرفة الوكيل
+- `-a, --all`: إعادة تعيين جميع الذاكرات
+
+### 7. الاختبار
+
+اختبار الطاقم وتقييم النتائج.
+
+```shell Terminal
+crewai test [OPTIONS]
+```
+
+- `-n, --n_iterations INTEGER`: عدد تكرارات الاختبار (افتراضي: 3)
+- `-m, --model TEXT`: نموذج LLM لتشغيل الاختبارات (افتراضي: "gpt-4o-mini")
+
+### 8. التشغيل
+
+تشغيل الطاقم أو التدفق.
+
+```shell Terminal
+crewai run
+```
+
+<Note>
+  بدءًا من الإصدار 0.103.0، يمكن استخدام أمر `crewai run` لتشغيل
+  كل من الأطقم القياسية والتدفقات. للتدفقات، يكتشف تلقائيًا النوع
+  من pyproject.toml ويشغّل الأمر المناسب. هذه هي الطريقة الموصى بها
+  لتشغيل كل من الأطقم والتدفقات.
+</Note>
+
+### 9. الدردشة
+
+بدءًا من الإصدار `0.98.0`، عند تشغيل أمر `crewai chat`، تبدأ جلسة تفاعلية مع طاقمك. سيرشدك المساعد الذكي بطلب المدخلات اللازمة لتنفيذ الطاقم. بمجرد توفير جميع المدخلات، سينفذ الطاقم مهامه.
+
+```shell Terminal
+crewai chat
+```
+
+<Note>
+مهم: عيّن خاصية `chat_llm` في تعريف الـ crew لتفعيل هذا الأمر.
+
+للـ crews بنمط JSON-first، أضفها إلى `crew.jsonc`:
+
+```jsonc
+{
+  "name": "My Crew",
+  "agents": ["researcher"],
+  "tasks": [],
+  "chat_llm": "openai/gpt-4o"
+}
+```
+
+للـ crews الكلاسيكية Python/YAML، عيّنها في `crew.py`:
+
+```python
+@crew
+def crew(self) -> Crew:
+    return Crew(
+        agents=self.agents,
+        tasks=self.tasks,
+        process=Process.sequential,
+        verbose=True,
+        chat_llm="gpt-4o",
+    )
+```
+</Note>
+
+### 10. النشر
+
+نشر الطاقم أو التدفق إلى [CrewAI AMP](https://app.crewai.com).
+
+- **المصادقة**: تحتاج لتكون مصادقًا للنشر إلى CrewAI AMP.
+
+  ```shell Terminal
+  crewai login
+  ```
+
+- **إنشاء نشر**:
+  ```shell Terminal
+  crewai deploy create
+  ```
+
+- **نشر الطاقم**:
+  ```shell Terminal
+  crewai deploy push
+  ```
+
+- **حالة النشر**:
+  ```shell Terminal
+  crewai deploy status
+  ```
+
+- **سجلات النشر**:
+  ```shell Terminal
+  crewai deploy logs
+  ```
+
+- **عرض النشرات**:
+  ```shell Terminal
+  crewai deploy list
+  ```
+
+- **حذف النشر**:
+  ```shell Terminal
+  crewai deploy remove
+  ```
+
+### 11. إدارة المؤسسة
+
+إدارة مؤسسات CrewAI AMP.
+
+```shell Terminal
+crewai org [COMMAND] [OPTIONS]
+```
+
+- `list`: عرض جميع المؤسسات
+- `current`: عرض المؤسسة النشطة حاليًا
+- `switch`: التبديل إلى مؤسسة محددة
+
+### 12. تسجيل الدخول
+
+المصادقة مع CrewAI AMP باستخدام تدفق رمز الجهاز الآمن.
+
+```shell Terminal
+crewai login
+```
+
+### 13. إدارة التهيئة
+
+إدارة إعدادات تهيئة CLI لـ CrewAI.
+
+```shell Terminal
+crewai config [COMMAND] [OPTIONS]
+```
+
+- `list`: عرض جميع معاملات التهيئة
+- `set`: تعيين معامل تهيئة
+- `reset`: إعادة تعيين جميع المعاملات إلى القيم الافتراضية
+
+### 14. إدارة التتبع
+
+إدارة تفضيلات جمع التتبع لعمليات الطاقم والتدفق.
+
+```shell Terminal
+crewai traces [COMMAND]
+```
+
+- `enable`: تفعيل جمع التتبع
+- `disable`: تعطيل جمع التتبع
+- `status`: عرض حالة جمع التتبع الحالية
+
+#### كيف يعمل التتبع
+
+يتم التحكم في جمع التتبع بفحص ثلاثة إعدادات بترتيب الأولوية:
+
+1. **علامة صريحة في الكود** (الأولوية الأعلى):
+   ```python
+   crew = Crew(agents=[...], tasks=[...], tracing=True)   # تفعيل دائمًا
+   crew = Crew(agents=[...], tasks=[...], tracing=False)  # تعطيل دائمًا
+   crew = Crew(agents=[...], tasks=[...])                 # فحص الأولويات الأدنى
+   ```
+
+2. **متغير البيئة** (الأولوية الثانية):
+   ```env
+   CREWAI_TRACING_ENABLED=true
+   ```
+
+3. **تفضيل المستخدم** (الأولوية الأدنى):
+   ```shell Terminal
+   crewai traces enable
+   ```
+
+<Note>
+**لتفعيل التتبع**، استخدم أيًا من هذه الطرق:
+- عيّن `tracing=True` في كود الطاقم/التدفق، أو
+- أضف `CREWAI_TRACING_ENABLED=true` إلى ملف `.env`، أو
+- شغّل `crewai traces enable`
+
+**لتعطيل التتبع**، استخدم أيًا من هذه الطرق:
+- عيّن `tracing=False` في كود الطاقم/التدفق، أو
+- أزل أو عيّن `false` لمتغير `CREWAI_TRACING_ENABLED`، أو
+- شغّل `crewai traces disable`
+</Note>
+
+<Tip>
+  يتعامل CrewAI CLI مع المصادقة لمستودع الأدوات تلقائيًا عند
+  إضافة حزم إلى مشروعك. فقط أضف `crewai` قبل أي أمر `uv`
+  لاستخدامه. مثلًا `crewai uv add requests`.
+</Tip>
+
+<Note>
+  تُخزن إعدادات التهيئة في `~/.config/crewai/settings.json`. بعض
+  الإعدادات مثل اسم المؤسسة ومعرّفها للقراءة فقط وتُدار من خلال
+  أوامر المصادقة والمؤسسة.
+</Note>

docs/edge/ar/concepts/collaboration.mdx

@@ -0,0 +1,363 @@
+---
+title: التعاون
+description: كيفية تمكين الوكلاء من العمل معًا وتفويض المهام والتواصل بفعالية داخل فرق CrewAI.
+icon: screen-users
+mode: "wide"
+---
+
+## نظرة عامة
+
+يُمكّن التعاون في CrewAI الوكلاء من العمل معًا كفريق عن طريق تفويض المهام وطرح الأسئلة للاستفادة من خبرات بعضهم البعض. عندما يكون `allow_delegation=True`، يحصل الوكلاء تلقائيًا على أدوات تعاون قوية.
+
+## البدء السريع: تفعيل التعاون
+
+```python
+from crewai import Agent, Crew, Task
+
+# تفعيل التعاون للوكلاء
+researcher = Agent(
+    role="Research Specialist",
+    goal="Conduct thorough research on any topic",
+    backstory="Expert researcher with access to various sources",
+    allow_delegation=True,  # الإعداد الرئيسي للتعاون
+    verbose=True
+)
+
+writer = Agent(
+    role="Content Writer",
+    goal="Create engaging content based on research",
+    backstory="Skilled writer who transforms research into compelling content",
+    allow_delegation=True,  # يُمكّن طرح الأسئلة على الوكلاء الآخرين
+    verbose=True
+)
+
+# يمكن للوكلاء الآن التعاون تلقائيًا
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[...],
+    verbose=True
+)
+```
+
+## كيف يعمل تعاون الوكلاء
+
+عندما يكون `allow_delegation=True`، يوفر CrewAI تلقائيًا للوكلاء أداتين قويتين:
+
+### 1. **أداة تفويض العمل**
+تسمح للوكلاء بتعيين مهام لزملاء الفريق ذوي الخبرة المحددة.
+
+```python
+# يحصل الوكيل تلقائيًا على هذه الأداة:
+# Delegate work to coworker(task: str, context: str, coworker: str)
+```
+
+### 2. **أداة طرح الأسئلة**
+تُمكّن الوكلاء من طرح أسئلة محددة لجمع المعلومات من الزملاء.
+
+```python
+# يحصل الوكيل تلقائيًا على هذه الأداة:
+# Ask question to coworker(question: str, context: str, coworker: str)
+```
+
+## التعاون في الممارسة
+
+إليك مثالًا كاملًا يوضح تعاون الوكلاء في مهمة إنشاء المحتوى:
+
+```python
+from crewai import Agent, Crew, Task, Process
+
+# إنشاء وكلاء تعاونيين
+researcher = Agent(
+    role="Research Specialist",
+    goal="Find accurate, up-to-date information on any topic",
+    backstory="""You're a meticulous researcher with expertise in finding
+    reliable sources and fact-checking information across various domains.""",
+    allow_delegation=True,
+    verbose=True
+)
+
+writer = Agent(
+    role="Content Writer",
+    goal="Create engaging, well-structured content",
+    backstory="""You're a skilled content writer who excels at transforming
+    research into compelling, readable content for different audiences.""",
+    allow_delegation=True,
+    verbose=True
+)
+
+editor = Agent(
+    role="Content Editor",
+    goal="Ensure content quality and consistency",
+    backstory="""You're an experienced editor with an eye for detail,
+    ensuring content meets high standards for clarity and accuracy.""",
+    allow_delegation=True,
+    verbose=True
+)
+
+# إنشاء مهمة تشجع التعاون
+article_task = Task(
+    description="""Write a comprehensive 1000-word article about 'The Future of AI in Healthcare'.
+
+    The article should include:
+    - Current AI applications in healthcare
+    - Emerging trends and technologies
+    - Potential challenges and ethical considerations
+    - Expert predictions for the next 5 years
+
+    Collaborate with your teammates to ensure accuracy and quality.""",
+    expected_output="A well-researched, engaging 1000-word article with proper structure and citations",
+    agent=writer  # الكاتب يقود، لكن يمكنه تفويض البحث إلى الباحث
+)
+
+# إنشاء طاقم تعاوني
+crew = Crew(
+    agents=[researcher, writer, editor],
+    tasks=[article_task],
+    process=Process.sequential,
+    verbose=True
+)
+
+result = crew.kickoff()
+```
+
+## أنماط التعاون
+
+### النمط 1: بحث ← كتابة ← تحرير
+```python
+research_task = Task(
+    description="Research the latest developments in quantum computing",
+    expected_output="Comprehensive research summary with key findings and sources",
+    agent=researcher
+)
+
+writing_task = Task(
+    description="Write an article based on the research findings",
+    expected_output="Engaging 800-word article about quantum computing",
+    agent=writer,
+    context=[research_task]  # يحصل على مخرجات البحث كسياق
+)
+
+editing_task = Task(
+    description="Edit and polish the article for publication",
+    expected_output="Publication-ready article with improved clarity and flow",
+    agent=editor,
+    context=[writing_task]  # يحصل على مسودة المقال كسياق
+)
+```
+
+### النمط 2: مهمة واحدة تعاونية
+```python
+collaborative_task = Task(
+    description="""Create a marketing strategy for a new AI product.
+
+    Writer: Focus on messaging and content strategy
+    Researcher: Provide market analysis and competitor insights
+
+    Work together to create a comprehensive strategy.""",
+    expected_output="Complete marketing strategy with research backing",
+    agent=writer  # الوكيل القائد، لكن يمكنه التفويض إلى الباحث
+)
+```
+
+## التعاون الهرمي
+
+للمشاريع المعقدة، استخدم عملية هرمية مع وكيل مدير:
+
+```python
+from crewai import Agent, Crew, Task, Process
+
+# وكيل المدير ينسق الفريق
+manager = Agent(
+    role="Project Manager",
+    goal="Coordinate team efforts and ensure project success",
+    backstory="Experienced project manager skilled at delegation and quality control",
+    allow_delegation=True,
+    verbose=True
+)
+
+# وكلاء متخصصون
+researcher = Agent(
+    role="Researcher",
+    goal="Provide accurate research and analysis",
+    backstory="Expert researcher with deep analytical skills",
+    allow_delegation=False,  # المتخصصون يركزون على خبرتهم
+    verbose=True
+)
+
+writer = Agent(
+    role="Writer",
+    goal="Create compelling content",
+    backstory="Skilled writer who creates engaging content",
+    allow_delegation=False,
+    verbose=True
+)
+
+# مهمة يقودها المدير
+project_task = Task(
+    description="Create a comprehensive market analysis report with recommendations",
+    expected_output="Executive summary, detailed analysis, and strategic recommendations",
+    agent=manager  # المدير سيفوّض إلى المتخصصين
+)
+
+# طاقم هرمي
+crew = Crew(
+    agents=[manager, researcher, writer],
+    tasks=[project_task],
+    process=Process.hierarchical,  # المدير ينسق كل شيء
+    manager_llm="gpt-4o",  # تحديد LLM للمدير
+    verbose=True
+)
+```
+
+## أفضل ممارسات التعاون
+
+### 1. **تحديد الأدوار بوضوح**
+```python
+# جيد: أدوار محددة ومتكاملة
+researcher = Agent(role="Market Research Analyst", ...)
+writer = Agent(role="Technical Content Writer", ...)
+
+# تجنب: أدوار متداخلة أو غامضة
+agent1 = Agent(role="General Assistant", ...)
+agent2 = Agent(role="Helper", ...)
+```
+
+### 2. **تفعيل التفويض الاستراتيجي**
+```python
+# فعّل التفويض للمنسقين والعامين
+lead_agent = Agent(
+    role="Content Lead",
+    allow_delegation=True,  # يمكنه التفويض إلى المتخصصين
+    ...
+)
+
+# عطّل للمتخصصين المركّزين (اختياري)
+specialist_agent = Agent(
+    role="Data Analyst",
+    allow_delegation=False,  # يركز على الخبرة الأساسية
+    ...
+)
+```
+
+### 3. **مشاركة السياق**
+```python
+# استخدم معامل context لاعتماديات المهام
+writing_task = Task(
+    description="Write article based on research",
+    agent=writer,
+    context=[research_task],  # يشارك نتائج البحث
+    ...
+)
+```
+
+### 4. **أوصاف المهام الواضحة**
+```python
+# أوصاف محددة وقابلة للتنفيذ
+Task(
+    description="""Research competitors in the AI chatbot space.
+    Focus on: pricing models, key features, target markets.
+    Provide data in a structured format.""",
+    ...
+)
+
+# تجنب: أوصاف غامضة لا توجه التعاون
+Task(description="Do some research about chatbots", ...)
+```
+
+## استكشاف أخطاء التعاون وإصلاحها
+
+### المشكلة: الوكلاء لا يتعاونون
+**الأعراض:** يعمل الوكلاء بمعزل، لا يحدث تفويض
+```python
+# الحل: تأكد من تفعيل التفويض
+agent = Agent(
+    role="...",
+    allow_delegation=True,  # هذا مطلوب!
+    ...
+)
+```
+
+### المشكلة: كثرة الذهاب والإياب
+**الأعراض:** يطرح الوكلاء أسئلة مفرطة، تقدم بطيء
+```python
+# الحل: وفّر سياقًا أفضل وأدوارًا محددة
+Task(
+    description="""Write a technical blog post about machine learning.
+
+    Context: Target audience is software developers with basic ML knowledge.
+    Length: 1200 words
+    Include: code examples, practical applications, best practices
+
+    If you need specific technical details, delegate research to the researcher.""",
+    ...
+)
+```
+
+### المشكلة: حلقات التفويض
+**الأعراض:** يفوّض الوكلاء ذهابًا وإيابًا بلا نهاية
+```python
+# الحل: تسلسل هرمي واضح ومسؤوليات
+manager = Agent(role="Manager", allow_delegation=True)
+specialist1 = Agent(role="Specialist A", allow_delegation=False)  # لا إعادة تفويض
+specialist2 = Agent(role="Specialist B", allow_delegation=False)
+```
+
+## ميزات التعاون المتقدمة
+
+### قواعد التعاون المخصصة
+```python
+# تعيين إرشادات تعاون محددة في خلفية الوكيل
+agent = Agent(
+    role="Senior Developer",
+    backstory="""You lead development projects and coordinate with team members.
+
+    Collaboration guidelines:
+    - Delegate research tasks to the Research Analyst
+    - Ask the Designer for UI/UX guidance
+    - Consult the QA Engineer for testing strategies
+    - Only escalate blocking issues to the Project Manager""",
+    allow_delegation=True
+)
+```
+
+### مراقبة التعاون
+```python
+def track_collaboration(output):
+    """تتبع أنماط التعاون"""
+    if "Delegate work to coworker" in output.raw:
+        print("Delegation occurred")
+    if "Ask question to coworker" in output.raw:
+        print("Question asked")
+
+crew = Crew(
+    agents=[...],
+    tasks=[...],
+    step_callback=track_collaboration,  # مراقبة التعاون
+    verbose=True
+)
+```
+
+## الذاكرة والتعلم
+
+تمكين الوكلاء من تذكر التعاونات السابقة:
+
+```python
+agent = Agent(
+    role="Content Lead",
+    memory=True,  # يتذكر التفاعلات السابقة
+    allow_delegation=True,
+    verbose=True
+)
+```
+
+مع تفعيل الذاكرة، يتعلم الوكلاء من التعاونات السابقة ويحسّنون قرارات التفويض بمرور الوقت.
+
+## الخطوات التالية
+
+- **جرّب الأمثلة**: ابدأ بمثال التعاون الأساسي
+- **جرّب أدوارًا مختلفة**: اختبر تركيبات أدوار وكلاء مختلفة
+- **راقب التفاعلات**: استخدم `verbose=True` لرؤية التعاون في العمل
+- **حسّن أوصاف المهام**: المهام الواضحة تؤدي إلى تعاون أفضل
+- **وسّع النطاق**: جرّب العمليات الهرمية للمشاريع المعقدة
+
+يحوّل التعاون وكلاء الذكاء الاصطناعي الفرديين إلى فرق قوية يمكنها معالجة التحديات المعقدة ومتعددة الأوجه معًا.

docs/edge/ar/concepts/crews.mdx

@@ -0,0 +1,245 @@
+---
+title: الأطقم
+description: فهم واستخدام الأطقم في إطار عمل CrewAI مع خصائص ووظائف شاملة.
+icon: people-group
+mode: "wide"
+---
+
+## نظرة عامة
+
+يمثل الطاقم في CrewAI مجموعة تعاونية من الوكلاء يعملون معًا لتحقيق مجموعة من المهام. يحدد كل طاقم استراتيجية تنفيذ المهام وتعاون الوكلاء وسير العمل العام.
+
+## خصائص الطاقم
+
+| الخاصية                             | المعامل             | الوصف                                                                                                                                                                                                                                               |
+| :------------------------------------ | :--------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **المهام**                             | `tasks`                | قائمة المهام المعيّنة للطاقم.                                                                                                                                                                                                                     |
+| **الوكلاء**                            | `agents`               | قائمة الوكلاء الذين يشكلون جزءًا من الطاقم.                                                                                                                                                                                                               |
+| **العملية** _(اختياري)_              | `process`              | تدفق العملية (مثل تسلسلي، هرمي) الذي يتبعه الطاقم. الافتراضي `sequential`.                                                                                                                              |
+| **الوضع المفصل** _(اختياري)_              | `verbose`              | مستوى التفصيل في التسجيل أثناء التنفيذ. الافتراضي `False`.                                                                                                                                                                                    |
+| **LLM المدير** _(اختياري)_          | `manager_llm`          | نموذج اللغة المستخدم بواسطة وكيل المدير في العملية الهرمية. **مطلوب عند استخدام العملية الهرمية.**                                                                                   |
+| **LLM استدعاء الدوال** _(اختياري)_ | `function_calling_llm` | إذا مُرر، سيستخدم الطاقم هذا LLM لاستدعاء دوال الأدوات لجميع الوكلاء. يمكن لكل وكيل أن يكون له LLM خاص يتجاوز LLM الطاقم.                                                                  |
+| **التهيئة** _(اختياري)_               | `config`               | إعدادات تهيئة اختيارية للطاقم، بتنسيق `Json` أو `Dict[str, Any]`.                                                                                                                                                                       |
+| **الحد الأقصى لـ RPM** _(اختياري)_              | `max_rpm`              | الحد الأقصى للطلبات في الدقيقة. الافتراضي `None`.                                                                                                                                                                     |
+| **الذاكرة** _(اختياري)_               | `memory`               | تُستخدم لتخزين ذاكرات التنفيذ (قصيرة المدى، طويلة المدى، ذاكرة الكيانات).                                                                                                                                                                           |
+| **التخزين المؤقت** _(اختياري)_                | `cache`                | يحدد ما إذا كان يُستخدم تخزين مؤقت لنتائج تنفيذ الأدوات. الافتراضي `True`.                                                                                                                                                         |
+| **المُضمّن** _(اختياري)_             | `embedder`             | تهيئة المُضمّن المستخدم من قبل الطاقم. الافتراضي `{"provider": "openai"}`.                                                                                                                                |
+| **دالة الخطوة** _(اختياري)_        | `step_callback`        | دالة تُستدعى بعد كل خطوة لكل وكيل.                                                               |
+| **دالة المهمة** _(اختياري)_        | `task_callback`        | دالة تُستدعى بعد اكتمال كل مهمة.                                                                                                                          |
+| **مشاركة الطاقم** _(اختياري)_           | `share_crew`           | ما إذا كنت تريد مشاركة معلومات الطاقم الكاملة وتنفيذه مع فريق CrewAI.                                                                                                      |
+| **ملف سجل المخرجات** _(اختياري)_      | `output_log_file`      | عيّن True لحفظ السجلات كـ logs.txt أو وفّر مسار ملف. الافتراضي `None`.                                                                      |
+| **وكيل المدير** _(اختياري)_        | `manager_agent`        | يعيّن وكيلًا مخصصًا سيُستخدم كمدير.                                                                                                                                                                                             |
+| **التخطيط** *(اختياري)*             | `planning`             | يضيف قدرة التخطيط للطاقم.                                                     |
+| **LLM التخطيط** *(اختياري)*         | `planning_llm`         | نموذج اللغة المستخدم بواسطة AgentPlanner في عملية التخطيط.                                                                                                                                                                                        |
+| **مصادر المعرفة** _(اختياري)_    | `knowledge_sources`    | مصادر المعرفة المتاحة على مستوى الطاقم، يمكن لجميع الوكلاء الوصول إليها.                                                                                                                                                                                    |
+| **البث** _(اختياري)_               | `stream`               | تفعيل مخرجات البث لتلقي تحديثات في الوقت الفعلي. الافتراضي `False`.                                                                                    |
+
+<Tip>
+**الحد الأقصى لـ RPM للطاقم**: تعيّن خاصية `max_rpm` الحد الأقصى للطلبات في الدقيقة التي يمكن للطاقم تنفيذها لتجنب حدود المعدل وستتجاوز إعدادات `max_rpm` الفردية للوكلاء إذا عيّنتها.
+</Tip>
+
+## إنشاء الأطقم
+
+هناك طريقتان رئيسيتان لإنشاء الأطقم في CrewAI: باستخدام **تهيئة JSONC (الموصى بها للـ crews الجديدة)** أو تعريفها **مباشرة في الكود** للمشاريع الكلاسيكية والحالات المتقدمة.
+
+### تهيئة JSONC (موصى بها)
+
+المشاريع الجديدة التي تُنشأ عبر `crewai create crew <name>` تستخدم `crew.jsonc` لإعدادات الـ crew والمهام، وملفًا منفصلًا لكل Agent داخل `agents/`. يكتشف `crewai run` ملف `crew.jsonc` أو `crew.json`، ويحمّل الـ Agents المشار إليها، ويطلب قيم placeholders الناقصة، ثم يبدأ الـ crew.
+
+```jsonc crew.jsonc
+{
+  "name": "Market Research Crew",
+  "agents": ["researcher", "analyst"],
+  "tasks": [
+    {
+      "name": "research",
+      "description": "Research {topic} and collect the most relevant facts.",
+      "expected_output": "Structured research notes about {topic}.",
+      "agent": "researcher"
+    },
+    {
+      "name": "analysis",
+      "description": "Analyze the research and write a concise report.",
+      "expected_output": "A markdown report with findings and recommendations.",
+      "agent": "analyst",
+      "context": ["research"],
+      "output_file": "output/report.md"
+    }
+  ],
+  "process": "sequential",
+  "verbose": true,
+  "memory": true,
+  "inputs": {
+    "topic": "AI Agents"
+  }
+}
+```
+
+كل عنصر في `agents` يُحل أولًا إلى `agents/<name>.jsonc` ثم إلى `agents/<name>.json`. للـ crews الهرمية، استخدم `"process": "hierarchical"` مع `manager_llm` أو `manager_agent`.
+
+<Warning>
+شغّل مشاريع JSON crew من مصادر تثق بها فقط. أدوات `custom:<name>` ومراجع `{"python": "module.attribute"}` تنفذ كود Python محليًا عند تحميل الـ crew.
+</Warning>
+
+### تهيئة YAML الكلاسيكية
+
+المشاريع الكلاسيكية التي تُنشأ عبر `crewai create crew <name> --classic` تستخدم `crew.py` و `config/agents.yaml` و `config/tasks.yaml` والمزيّنات `@CrewBase` و `@agent` و `@task` و `@crew`.
+
+تظل هذه الطريقة مدعومة للمشاريع الحالية المبنية بـ Python/YAML وللفِرق التي تحتاج تحكمًا صريحًا عبر decorators.
+
+```python code
+from crewai import Agent, Crew, Task, Process
+from crewai.project import CrewBase, agent, task, crew, before_kickoff, after_kickoff
+from crewai.agents.agent_builder.base_agent import BaseAgent
+from typing import List
+
+@CrewBase
+class YourCrewName:
+    """Description of your crew"""
+
+    agents: List[BaseAgent]
+    tasks: List[Task]
+
+    agents_config = 'config/agents.yaml'
+    tasks_config = 'config/tasks.yaml'
+
+    @before_kickoff
+    def prepare_inputs(self, inputs):
+        inputs['additional_data'] = "Some extra information"
+        return inputs
+
+    @after_kickoff
+    def process_output(self, output):
+        output.raw += "\nProcessed after kickoff."
+        return output
+
+    @agent
+    def agent_one(self) -> Agent:
+        return Agent(
+            config=self.agents_config['agent_one'], # type: ignore[index]
+            verbose=True
+        )
+
+    @task
+    def task_one(self) -> Task:
+        return Task(
+            config=self.tasks_config['task_one'] # type: ignore[index]
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        return Crew(
+            agents=self.agents,
+            tasks=self.tasks,
+            process=Process.sequential,
+            verbose=True,
+        )
+```
+
+<Note>
+سيتم تنفيذ المهام بالترتيب الذي عُرّفت به.
+</Note>
+
+فئة `CrewBase`، مع هذه المزيّنات، تؤتمت جمع الوكلاء والمهام، مما يقلل الحاجة للإدارة اليدوية.
+
+### تعريف مباشر في الكود (بديل)
+
+بدلاً من ذلك، يمكنك تعريف الطاقم مباشرة في الكود بدون ملفات تهيئة YAML.
+
+## مخرجات الطاقم
+
+تُغلّف مخرجات الطاقم في فئة `CrewOutput`. توفر هذه الفئة طريقة منظمة للوصول إلى نتائج تنفيذ الطاقم، بما في ذلك تنسيقات متنوعة مثل السلاسل النصية الخام وJSON ونماذج Pydantic.
+
+### خصائص مخرجات الطاقم
+
+| الخاصية        | المعامل     | النوع                       | الوصف                                                                                          |
+| :--------------- | :------------- | :------------------------- | :--------------------------------------------------------------------------------------------------- |
+| **Raw**          | `raw`          | `str`                      | المخرجات الخام للطاقم. هذا هو التنسيق الافتراضي.                               |
+| **Pydantic**     | `pydantic`     | `Optional[BaseModel]`      | كائن نموذج Pydantic يمثل المخرجات المنظمة.                              |
+| **JSON Dict**    | `json_dict`    | `Optional[Dict[str, Any]]` | قاموس يمثل مخرجات JSON.                                               |
+| **Tasks Output** | `tasks_output` | `List[TaskOutput]`         | قائمة كائنات `TaskOutput`، كل منها يمثل مخرجات مهمة.                  |
+| **Token Usage**  | `token_usage`  | `Dict[str, Any]`           | ملخص استخدام الرموز. |
+
+## استخدام الذاكرة
+
+يمكن للأطقم استخدام الذاكرة (قصيرة المدى، طويلة المدى، وذاكرة الكيانات) لتحسين تنفيذها وتعلمها بمرور الوقت.
+
+## استخدام التخزين المؤقت
+
+يمكن استخدام التخزين المؤقت لتخزين نتائج تنفيذ الأدوات، مما يجعل العملية أكثر كفاءة.
+
+## مقاييس استخدام الطاقم
+
+بعد تنفيذ الطاقم، يمكنك الوصول إلى خاصية `usage_metrics` لعرض مقاييس استخدام نموذج اللغة (LLM) لجميع المهام المنفذة.
+
+```python Code
+crew = Crew(agents=[agent1, agent2], tasks=[task1, task2])
+crew.kickoff()
+print(crew.usage_metrics)
+```
+
+## عملية تنفيذ الطاقم
+
+- **العملية التسلسلية**: تُنفذ المهام واحدة تلو الأخرى، مما يسمح بتدفق عمل خطي.
+- **العملية الهرمية**: ينسق وكيل مدير الطاقم، ويفوّض المهام ويتحقق من النتائج.
+
+### تشغيل الطاقم
+
+بمجرد تجميع طاقمك، ابدأ سير العمل بطريقة `kickoff()`.
+
+```python Code
+result = my_crew.kickoff()
+print(result)
+```
+
+### طرق مختلفة لتشغيل الطاقم
+
+#### الطرق المتزامنة
+
+- `kickoff()`: يبدأ عملية التنفيذ وفقًا لتدفق العملية المحدد.
+- `kickoff_for_each()`: ينفذ المهام بالتتابع لكل مدخل.
+
+#### الطرق غير المتزامنة
+
+| الطريقة | النوع | الوصف |
+|--------|------|-------------|
+| `akickoff()` | غير متزامن أصلي | async/await أصلي عبر سلسلة التنفيذ بأكملها |
+| `akickoff_for_each()` | غير متزامن أصلي | تنفيذ غير متزامن أصلي لكل مدخل في قائمة |
+| `kickoff_async()` | مبني على الخيوط | يغلّف التنفيذ المتزامن في `asyncio.to_thread` |
+| `kickoff_for_each_async()` | مبني على الخيوط | غير متزامن مبني على الخيوط لكل مدخل في قائمة |
+
+<Note>
+لأحمال العمل عالية التزامن، يُوصى بـ `akickoff()` و `akickoff_for_each()` لأنها تستخدم async أصلي.
+</Note>
+
+### بث تنفيذ الطاقم
+
+للرؤية في الوقت الفعلي لتنفيذ الطاقم، يمكنك تفعيل البث:
+
+```python Code
+crew = Crew(
+    agents=[researcher],
+    tasks=[task],
+    stream=True
+)
+
+streaming = crew.kickoff(inputs={"topic": "AI"})
+for chunk in streaming:
+    print(chunk.content, end="", flush=True)
+
+result = streaming.result
+```
+
+### الإعادة من مهمة محددة
+
+يمكنك الآن الإعادة من مهمة محددة باستخدام أمر CLI `replay`.
+
+```shell
+crewai log-tasks-outputs
+```
+
+ثم للإعادة من مهمة محددة:
+
+```shell
+crewai replay -t <task_id>
+```

docs/edge/ar/concepts/event-listener.mdx

@@ -0,0 +1,237 @@
+---
+title: "مستمعو الأحداث"
+description: "الاستفادة من أحداث CrewAI لبناء تكاملات مخصصة ومراقبة"
+icon: spinner
+mode: "wide"
+---
+
+## نظرة عامة
+
+يوفر CrewAI نظام أحداث قوي يتيح لك الاستماع والتفاعل مع الأحداث المختلفة التي تحدث أثناء تنفيذ طاقمك. تُمكّنك هذه الميزة من بناء تكاملات مخصصة وحلول مراقبة وأنظمة تسجيل أو أي وظائف أخرى تحتاج للتشغيل بناءً على أحداث CrewAI الداخلية.
+
+## كيف يعمل
+
+يستخدم CrewAI بنية ناقل أحداث لإرسال الأحداث طوال دورة حياة التنفيذ. يُبنى نظام الأحداث على المكونات التالية:
+
+1. **CrewAIEventsBus**: ناقل أحداث فريد يدير تسجيل الأحداث وإرسالها
+2. **BaseEvent**: الفئة الأساسية لجميع الأحداث في النظام
+3. **BaseEventListener**: فئة أساسية مجردة لإنشاء مستمعي أحداث مخصصين
+
+عندما تحدث إجراءات محددة في CrewAI (مثل بدء تنفيذ طاقم، أو إكمال وكيل لمهمة، أو استخدام أداة)، يرسل النظام أحداثًا مقابلة. يمكنك تسجيل معالجات لهذه الأحداث لتنفيذ كود مخصص عند حدوثها.
+
+<Note type="info" title="تحسين المؤسسات: تتبع الأوامر">
+يوفر CrewAI AMP ميزة تتبع أوامر مدمجة تستفيد من نظام الأحداث لتتبع وتخزين وتصور جميع الأوامر والاستكمالات والبيانات الوصفية المرتبطة.
+
+![Prompt Tracing Dashboard](/images/enterprise/traces-overview.png)
+
+مع تتبع الأوامر يمكنك:
+
+- عرض السجل الكامل لجميع الأوامر المرسلة إلى LLM
+- تتبع استخدام الرموز والتكاليف
+- تصحيح إخفاقات استدلال الوكيل
+- مشاركة تسلسلات الأوامر مع فريقك
+- مقارنة استراتيجيات الأوامر المختلفة
+- تصدير التتبعات للامتثال والتدقيق
+</Note>
+
+## إنشاء مستمع أحداث مخصص
+
+لإنشاء مستمع أحداث مخصص، تحتاج إلى:
+
+1. إنشاء فئة ترث من `BaseEventListener`
+2. تنفيذ طريقة `setup_listeners`
+3. تسجيل معالجات للأحداث التي تهمك
+4. إنشاء مثيل من مستمعك في الملف المناسب
+
+إليك مثالًا بسيطًا:
+
+```python
+from crewai.events import (
+    CrewKickoffStartedEvent,
+    CrewKickoffCompletedEvent,
+    AgentExecutionCompletedEvent,
+)
+from crewai.events import BaseEventListener
+
+class MyCustomListener(BaseEventListener):
+    def __init__(self):
+        super().__init__()
+
+    def setup_listeners(self, crewai_event_bus):
+        @crewai_event_bus.on(CrewKickoffStartedEvent)
+        def on_crew_started(source, event):
+            print(f"Crew '{event.crew_name}' has started execution!")
+
+        @crewai_event_bus.on(CrewKickoffCompletedEvent)
+        def on_crew_completed(source, event):
+            print(f"Crew '{event.crew_name}' has completed execution!")
+            print(f"Output: {event.output}")
+
+        @crewai_event_bus.on(AgentExecutionCompletedEvent)
+        def on_agent_execution_completed(source, event):
+            print(f"Agent '{event.agent.role}' completed task")
+            print(f"Output: {event.output}")
+```
+
+## تسجيل المستمع بشكل صحيح
+
+مجرد تعريف فئة المستمع ليس كافيًا. تحتاج لإنشاء مثيل منه والتأكد من استيراده في تطبيقك.
+
+```python
+# في ملف crew.py
+from crewai import Agent, Crew, Task
+from my_listeners import MyCustomListener
+
+# إنشاء مثيل من المستمع
+my_listener = MyCustomListener()
+
+class MyCustomCrew:
+    def crew(self):
+        return Crew(
+            agents=[...],
+            tasks=[...],
+        )
+```
+
+## أنواع الأحداث المتاحة
+
+يوفر CrewAI مجموعة واسعة من الأحداث يمكنك الاستماع إليها:
+
+### أحداث الطاقم
+
+- **CrewKickoffStartedEvent**: يُرسل عند بدء تنفيذ الطاقم
+- **CrewKickoffCompletedEvent**: يُرسل عند اكتمال تنفيذ الطاقم
+- **CrewKickoffFailedEvent**: يُرسل عند فشل تنفيذ الطاقم
+- **CrewTestStartedEvent**: يُرسل عند بدء اختبار الطاقم
+- **CrewTestCompletedEvent**: يُرسل عند اكتمال اختبار الطاقم
+- **CrewTestFailedEvent**: يُرسل عند فشل اختبار الطاقم
+- **CrewTrainStartedEvent**: يُرسل عند بدء تدريب الطاقم
+- **CrewTrainCompletedEvent**: يُرسل عند اكتمال تدريب الطاقم
+- **CrewTrainFailedEvent**: يُرسل عند فشل تدريب الطاقم
+
+### أحداث الوكيل
+
+- **AgentExecutionStartedEvent**: يُرسل عند بدء تنفيذ وكيل لمهمة
+- **AgentExecutionCompletedEvent**: يُرسل عند اكتمال تنفيذ وكيل لمهمة
+- **AgentExecutionErrorEvent**: يُرسل عند مواجهة وكيل لخطأ أثناء التنفيذ
+- **LiteAgentExecutionStartedEvent**: يُرسل عند بدء تنفيذ LiteAgent
+- **LiteAgentExecutionCompletedEvent**: يُرسل عند اكتمال تنفيذ LiteAgent
+
+### أحداث المهام
+
+- **TaskStartedEvent**: يُرسل عند بدء تنفيذ مهمة
+- **TaskCompletedEvent**: يُرسل عند اكتمال تنفيذ مهمة
+- **TaskFailedEvent**: يُرسل عند فشل تنفيذ مهمة
+
+### أحداث استخدام الأدوات
+
+- **ToolUsageStartedEvent**: يُرسل عند بدء تنفيذ أداة
+- **ToolUsageFinishedEvent**: يُرسل عند اكتمال تنفيذ أداة
+- **ToolUsageErrorEvent**: يُرسل عند مواجهة خطأ في تنفيذ أداة
+
+### أحداث MCP
+
+- **MCPConnectionStartedEvent**: يُرسل عند بدء الاتصال بخادم MCP
+- **MCPConnectionCompletedEvent**: يُرسل عند اكتمال الاتصال بخادم MCP
+- **MCPConnectionFailedEvent**: يُرسل عند فشل الاتصال بخادم MCP
+- **MCPToolExecutionStartedEvent**: يُرسل عند بدء تنفيذ أداة MCP
+- **MCPToolExecutionCompletedEvent**: يُرسل عند اكتمال تنفيذ أداة MCP
+- **MCPToolExecutionFailedEvent**: يُرسل عند فشل تنفيذ أداة MCP
+
+### أحداث المعرفة
+
+- **KnowledgeRetrievalStartedEvent**: يُرسل عند بدء استرجاع المعرفة
+- **KnowledgeRetrievalCompletedEvent**: يُرسل عند اكتمال استرجاع المعرفة
+- **KnowledgeQueryStartedEvent**: يُرسل عند بدء استعلام المعرفة
+- **KnowledgeQueryCompletedEvent**: يُرسل عند اكتمال استعلام المعرفة
+- **KnowledgeQueryFailedEvent**: يُرسل عند فشل استعلام المعرفة
+
+### أحداث حواجز LLM
+
+- **LLMGuardrailStartedEvent**: يُرسل عند بدء التحقق من الحاجز
+- **LLMGuardrailCompletedEvent**: يُرسل عند اكتمال التحقق من الحاجز
+- **LLMGuardrailFailedEvent**: يُرسل عند فشل التحقق من الحاجز
+
+### أحداث التدفق
+
+- **FlowCreatedEvent**: يُرسل عند إنشاء تدفق
+- **FlowStartedEvent**: يُرسل عند بدء تنفيذ تدفق
+- **FlowFinishedEvent**: يُرسل عند اكتمال تنفيذ تدفق
+- **FlowFailedEvent**: يُرسل عند فشل تنفيذ تدفق. يحتوي على اسم التدفق والاستثناء الذي أنهى التنفيذ.
+- **FlowPausedEvent**: يُرسل عند إيقاف تدفق مؤقتًا بانتظار ملاحظات بشرية
+
+### أحداث LLM
+
+- **LLMCallStartedEvent**: يُرسل عند بدء استدعاء LLM
+- **LLMCallCompletedEvent**: يُرسل عند اكتمال استدعاء LLM
+- **LLMCallFailedEvent**: يُرسل عند فشل استدعاء LLM
+- **LLMStreamChunkEvent**: يُرسل لكل جزء مستلم أثناء بث استجابات LLM
+
+### أحداث الذاكرة
+
+- **MemoryQueryStartedEvent**: يُرسل عند بدء استعلام الذاكرة
+- **MemoryQueryCompletedEvent**: يُرسل عند اكتمال استعلام الذاكرة
+- **MemorySaveStartedEvent**: يُرسل عند بدء حفظ الذاكرة
+- **MemorySaveCompletedEvent**: يُرسل عند اكتمال حفظ الذاكرة
+
+### أحداث الاستدلال
+
+- **AgentReasoningStartedEvent**: يُرسل عند بدء وكيل الاستدلال حول مهمة
+- **AgentReasoningCompletedEvent**: يُرسل عند انتهاء عملية الاستدلال
+- **AgentReasoningFailedEvent**: يُرسل عند فشل عملية الاستدلال
+
+### أحداث A2A (وكيل إلى وكيل)
+
+- **A2ADelegationStartedEvent**: يُرسل عند بدء تفويض A2A
+- **A2ADelegationCompletedEvent**: يُرسل عند اكتمال تفويض A2A
+- **A2AConversationStartedEvent**: يُرسل عند بدء محادثة A2A متعددة الأدوار
+- **A2AConversationCompletedEvent**: يُرسل عند انتهاء محادثة A2A
+
+## هيكل معالج الأحداث
+
+يستقبل كل معالج حدث معاملين:
+
+1. **source**: الكائن الذي أرسل الحدث
+2. **event**: مثيل الحدث، يحتوي على بيانات خاصة بالحدث
+
+هيكل كائن الحدث يعتمد على نوع الحدث، لكن جميع الأحداث ترث من `BaseEvent` وتتضمن:
+
+- **timestamp**: الوقت الذي أُرسل فيه الحدث
+- **type**: معرّف نصي لنوع الحدث
+
+## الاستخدام المتقدم: المعالجات المحددة النطاق
+
+لمعالجة الأحداث المؤقتة، يمكنك استخدام مدير سياق `scoped_handlers`:
+
+```python
+from crewai.events import crewai_event_bus, CrewKickoffStartedEvent
+
+with crewai_event_bus.scoped_handlers():
+    @crewai_event_bus.on(CrewKickoffStartedEvent)
+    def temp_handler(source, event):
+        print("This handler only exists within this context")
+
+    # قم بشيء يرسل أحداثًا
+
+# خارج السياق، يتم إزالة المعالج المؤقت
+```
+
+## حالات الاستخدام
+
+يمكن استخدام مستمعي الأحداث لأغراض متنوعة:
+
+1. **التسجيل والمراقبة**: تتبع تنفيذ طاقمك وتسجيل الأحداث المهمة
+2. **التحليلات**: جمع بيانات عن أداء وسلوك طاقمك
+3. **التصحيح**: إعداد مستمعين مؤقتين لتصحيح مشاكل محددة
+4. **التكامل**: ربط CrewAI بأنظمة خارجية مثل منصات المراقبة وقواعد البيانات أو خدمات الإشعارات
+5. **السلوك المخصص**: تشغيل إجراءات مخصصة بناءً على أحداث محددة
+
+## أفضل الممارسات
+
+1. **اجعل المعالجات خفيفة**: يجب أن تكون معالجات الأحداث خفيفة وتتجنب العمليات الحاجبة
+2. **معالجة الأخطاء**: أدرج معالجة أخطاء مناسبة في معالجات الأحداث لمنع الاستثناءات من التأثير على التنفيذ الرئيسي
+3. **التنظيف**: إذا خصص مستمعك موارد، تأكد من تنظيفها بشكل صحيح
+4. **الاستماع الانتقائي**: استمع فقط للأحداث التي تحتاج فعلاً لمعالجتها
+5. **الاختبار**: اختبر مستمعي الأحداث بمعزل لضمان سلوكهم كما هو متوقع
+
+بالاستفادة من نظام أحداث CrewAI، يمكنك توسيع وظائفه ودمجه بسلاسة مع بنيتك التحتية الحالية.

docs/edge/ar/concepts/files.mdx

@@ -0,0 +1,267 @@
+---
+title: الملفات
+description: تمرير الصور وملفات PDF والصوت والفيديو والنصوص إلى وكلائك للمعالجة متعددة الوسائط.
+icon: file-image
+---
+
+## نظرة عامة
+
+يدعم CrewAI مدخلات الملفات متعددة الوسائط الأصلية، مما يتيح لك تمرير الصور وملفات PDF والصوت والفيديو والنصوص مباشرة إلى وكلائك. يتم تنسيق الملفات تلقائيًا وفقًا لمتطلبات API لكل مزود LLM.
+
+<Note type="info" title="اعتمادية اختيارية">
+يتطلب دعم الملفات حزمة `crewai-files` الاختيارية. ثبّتها بـ:
+
+```bash
+uv add 'crewai[file-processing]'
+```
+</Note>
+
+<Note type="warning" title="وصول مبكر">
+واجهة معالجة الملفات حاليًا في مرحلة الوصول المبكر.
+</Note>
+
+## أنواع الملفات
+
+يدعم CrewAI خمسة أنواع ملفات محددة بالإضافة إلى فئة `File` العامة التي تكتشف النوع تلقائيًا:
+
+| النوع | الفئة | حالات الاستخدام |
+|:-----|:------|:----------|
+| **صورة** | `ImageFile` | صور، لقطات شاشة، مخططات، رسوم بيانية |
+| **PDF** | `PDFFile` | مستندات، تقارير، أوراق بحثية |
+| **صوت** | `AudioFile` | تسجيلات صوتية، بودكاست، اجتماعات |
+| **فيديو** | `VideoFile` | تسجيلات شاشة، عروض تقديمية |
+| **نص** | `TextFile` | ملفات كود، سجلات، ملفات بيانات |
+| **عام** | `File` | اكتشاف تلقائي للنوع من المحتوى |
+
+```python
+from crewai_files import File, ImageFile, PDFFile, AudioFile, VideoFile, TextFile
+
+image = ImageFile(source="screenshot.png")
+pdf = PDFFile(source="report.pdf")
+audio = AudioFile(source="meeting.mp3")
+video = VideoFile(source="demo.mp4")
+text = TextFile(source="data.csv")
+
+file = File(source="document.pdf")
+```
+
+## مصادر الملفات
+
+يقبل معامل `source` أنواع إدخال متعددة ويكتشف تلقائيًا المعالج المناسب:
+
+### من مسار
+
+```python
+from crewai_files import ImageFile
+
+image = ImageFile(source="./images/chart.png")
+```
+
+### من عنوان URL
+
+```python
+from crewai_files import ImageFile
+
+image = ImageFile(source="https://example.com/image.png")
+```
+
+### من بايتات
+
+```python
+from crewai_files import ImageFile, FileBytes
+
+image_bytes = download_image_from_api()
+image = ImageFile(source=FileBytes(data=image_bytes, filename="downloaded.png"))
+image = ImageFile(source=image_bytes)
+```
+
+## استخدام الملفات
+
+يمكن تمرير الملفات على مستويات متعددة، حيث تأخذ المستويات الأكثر تحديدًا الأولوية.
+
+### مع الأطقم
+
+مرر الملفات عند تشغيل طاقم:
+
+```python
+from crewai import Crew
+from crewai_files import ImageFile
+
+crew = Crew(agents=[analyst], tasks=[analysis_task])
+
+result = crew.kickoff(
+    inputs={"topic": "Q4 Sales"},
+    input_files={
+        "chart": ImageFile(source="sales_chart.png"),
+        "report": PDFFile(source="quarterly_report.pdf"),
+    }
+)
+```
+
+### مع المهام
+
+أرفق الملفات بمهام محددة:
+
+```python
+from crewai import Task
+from crewai_files import ImageFile
+
+task = Task(
+    description="Analyze the sales chart and identify trends in {chart}",
+    expected_output="A summary of key trends",
+    input_files={
+        "chart": ImageFile(source="sales_chart.png"),
+    }
+)
+```
+
+### مع التدفقات
+
+مرر الملفات إلى التدفقات، والتي تنتقل تلقائيًا إلى الأطقم:
+
+```python
+from crewai.flow.flow import Flow, start
+from crewai_files import ImageFile
+
+class AnalysisFlow(Flow):
+    @start()
+    def analyze(self):
+        return self.analysis_crew.kickoff()
+
+flow = AnalysisFlow()
+result = flow.kickoff(
+    input_files={"image": ImageFile(source="data.png")}
+)
+```
+
+### مع الوكلاء المستقلين
+
+مرر الملفات مباشرة إلى تشغيل الوكيل:
+
+```python
+from crewai import Agent
+from crewai_files import ImageFile
+
+agent = Agent(
+    role="Image Analyst",
+    goal="Analyze images",
+    backstory="Expert at visual analysis",
+    llm="gpt-4o",
+)
+
+result = agent.kickoff(
+    messages="What's in this image?",
+    input_files={"photo": ImageFile(source="photo.jpg")},
+)
+```
+
+## أولوية الملفات
+
+عند تمرير الملفات على مستويات متعددة، تتجاوز المستويات الأكثر تحديدًا المستويات الأوسع:
+
+```
+Flow input_files < Crew input_files < Task input_files
+```
+
+على سبيل المثال، إذا عرّف كل من التدفق والمهمة ملفًا باسم `"chart"`، تُستخدم نسخة المهمة.
+
+## دعم المزودين
+
+تدعم المزودات المختلفة أنواع ملفات مختلفة. يقوم CrewAI تلقائيًا بتنسيق الملفات وفقًا لواجهة كل مزود.
+
+| المزود | صورة | PDF | صوت | فيديو | نص |
+|:---------|:-----:|:---:|:-----:|:-----:|:----:|
+| **OpenAI** (completions API) | ✓ | | | | |
+| **OpenAI** (responses API) | ✓ | ✓ | ✓ | | |
+| **Anthropic** (claude-3.x) | ✓ | ✓ | | | |
+| **Google Gemini** (gemini-1.5, 2.0, 2.5) | ✓ | ✓ | ✓ | ✓ | ✓ |
+| **AWS Bedrock** (claude-3) | ✓ | ✓ | | | |
+| **Azure OpenAI** (gpt-4o) | ✓ | | ✓ | | |
+
+<Note type="info" title="Gemini لأقصى دعم للملفات">
+تدعم نماذج Google Gemini جميع أنواع الملفات بما في ذلك الفيديو (حتى ساعة واحدة، 2 جيجابايت). استخدم Gemini عندما تحتاج لمعالجة محتوى الفيديو.
+</Note>
+
+<Note type="warning" title="أنواع الملفات غير المدعومة">
+إذا مررت نوع ملف لا يدعمه المزود (مثل الفيديو إلى OpenAI)، ستتلقى خطأ `UnsupportedFileTypeError`. اختر مزودك بناءً على أنواع الملفات التي تحتاج لمعالجتها.
+</Note>
+
+## كيف تُرسل الملفات
+
+يختار CrewAI تلقائيًا الطريقة المثلى لإرسال الملفات إلى كل مزود:
+
+| الطريقة | الوصف | متى تُستخدم |
+|:-------|:------------|:----------|
+| **Inline Base64** | الملف مضمّن مباشرة في الطلب | ملفات صغيرة (< 5 ميجابايت عادة) |
+| **File Upload API** | الملف يُرفع بشكل منفصل، يُشار إليه بمعرّف | ملفات كبيرة تتجاوز العتبة |
+| **URL Reference** | عنوان URL مباشر يُمرر إلى النموذج | مصدر الملف هو عنوان URL بالفعل |
+
+### طرق الإرسال حسب المزود
+
+| المزود | Inline Base64 | File Upload API | URL References |
+|:---------|:-------------:|:---------------:|:--------------:|
+| **OpenAI** | ✓ | ✓ (> 5 MB) | ✓ |
+| **Anthropic** | ✓ | ✓ (> 5 MB) | ✓ |
+| **Google Gemini** | ✓ | ✓ (> 20 MB) | ✓ |
+| **AWS Bedrock** | ✓ | | ✓ (S3 URIs) |
+| **Azure OpenAI** | ✓ | | ✓ |
+
+<Note type="info" title="تحسين تلقائي">
+لا تحتاج لإدارة هذا بنفسك. يستخدم CrewAI تلقائيًا الطريقة الأكثر كفاءة بناءً على حجم الملف وقدرات المزود. المزودات بدون واجهات رفع الملفات تستخدم inline base64 لجميع الملفات.
+</Note>
+
+## أوضاع معالجة الملفات
+
+تحكم في كيفية معالجة الملفات عندما تتجاوز حدود المزود:
+
+```python
+from crewai_files import ImageFile, PDFFile
+
+image = ImageFile(source="large.png", mode="strict")
+image = ImageFile(source="large.png", mode="auto")
+image = ImageFile(source="large.png", mode="warn")
+pdf = PDFFile(source="large.pdf", mode="chunk")
+```
+
+## قيود المزودين
+
+لكل مزود حدود محددة لأحجام الملفات والأبعاد:
+
+### OpenAI
+- **الصور**: حد أقصى 20 ميجابايت، حتى 10 صور لكل طلب
+- **PDF**: حد أقصى 32 ميجابايت، حتى 100 صفحة
+- **الصوت**: حد أقصى 25 ميجابايت، حتى 25 دقيقة
+
+### Anthropic
+- **الصور**: حد أقصى 5 ميجابايت، أقصى 8000x8000 بكسل، حتى 100 صورة
+- **PDF**: حد أقصى 32 ميجابايت، حتى 100 صفحة
+
+### Google Gemini
+- **الصور**: حد أقصى 100 ميجابايت
+- **PDF**: حد أقصى 50 ميجابايت
+- **الصوت**: حد أقصى 100 ميجابايت، حتى 9.5 ساعة
+- **الفيديو**: حد أقصى 2 جيجابايت، حتى ساعة واحدة
+
+### AWS Bedrock
+- **الصور**: حد أقصى 4.5 ميجابايت، أقصى 8000x8000 بكسل
+- **PDF**: حد أقصى 3.75 ميجابايت، حتى 100 صفحة
+
+## الإشارة إلى الملفات في الأوامر
+
+استخدم اسم مفتاح الملف في أوصاف المهام للإشارة إلى الملفات:
+
+```python
+task = Task(
+    description="""
+    Analyze the provided materials:
+    1. Review the chart in {sales_chart}
+    2. Cross-reference with data in {quarterly_report}
+    3. Summarize key findings
+    """,
+    expected_output="Analysis summary with key insights",
+    input_files={
+        "sales_chart": ImageFile(source="chart.png"),
+        "quarterly_report": PDFFile(source="report.pdf"),
+    }
+)
+```

docs/edge/ar/concepts/memory.mdx

@@ -0,0 +1,878 @@
+---
+title: الذاكرة
+description: الاستفادة من نظام الذاكرة الموحد في CrewAI لتعزيز قدرات الوكلاء.
+icon: database
+mode: "wide"
+---
+
+## نظرة عامة
+
+يوفر CrewAI **نظام ذاكرة موحد** -- فئة `Memory` واحدة تستبدل أنواع الذاكرة المنفصلة (قصيرة المدى، طويلة المدى، ذاكرة الكيانات، والخارجية) بواجهة برمجة تطبيقات ذكية واحدة. تستخدم الذاكرة LLM لتحليل المحتوى عند الحفظ (استنتاج النطاق والفئات والأهمية) وتدعم الاسترجاع متعدد العمق مع تسجيل مركب يمزج بين التشابه الدلالي والحداثة والأهمية.
+
+يمكنك استخدام الذاكرة بأربع طرق: **مستقلة** (سكربتات، دفاتر ملاحظات)، **مع فرق Crew**، **مع Agents**، أو **داخل التدفقات**.
+
+## البدء السريع
+
+```python
+from crewai import Memory
+
+memory = Memory()
+
+# Store -- the LLM infers scope, categories, and importance
+memory.remember("We decided to use PostgreSQL for the user database.")
+
+# Retrieve -- results ranked by composite score (semantic + recency + importance)
+matches = memory.recall("What database did we choose?")
+for m in matches:
+    print(f"[{m.score:.2f}] {m.record.content}")
+
+# Tune scoring for a fast-moving project
+memory = Memory(recency_weight=0.5, recency_half_life_days=7)
+
+# Forget
+memory.forget(scope="/project/old")
+
+# Explore the self-organized scope tree
+print(memory.tree())
+print(memory.info("/"))
+```
+
+## أربع طرق لاستخدام الذاكرة
+
+### مستقلة
+
+استخدم الذاكرة في السكربتات ودفاتر الملاحظات وأدوات سطر الأوامر أو كقاعدة معرفة مستقلة -- لا حاجة لوكلاء أو فرق Crew.
+
+```python
+from crewai import Memory
+
+memory = Memory()
+
+# Build up knowledge
+memory.remember("The API rate limit is 1000 requests per minute.")
+memory.remember("Our staging environment uses port 8080.")
+memory.remember("The team agreed to use feature flags for all new releases.")
+
+# Later, recall what you need
+matches = memory.recall("What are our API limits?", limit=5)
+for m in matches:
+    print(f"[{m.score:.2f}] {m.record.content}")
+
+# Extract atomic facts from a longer text
+raw = """Meeting notes: We decided to migrate from MySQL to PostgreSQL
+next quarter. The budget is $50k. Sarah will lead the migration."""
+
+facts = memory.extract_memories(raw)
+# ["Migration from MySQL to PostgreSQL planned for next quarter",
+#  "Database migration budget is $50k",
+#  "Sarah will lead the database migration"]
+
+for fact in facts:
+    memory.remember(fact)
+```
+
+### مع فرق Crew
+
+مرّر `memory=True` للإعدادات الافتراضية، أو مرّر مثيل `Memory` مُعدّ للسلوك المخصص.
+
+```python
+from crewai import Crew, Agent, Task, Process, Memory
+
+# Option 1: Default memory
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[research_task, writing_task],
+    process=Process.sequential,
+    memory=True,
+    verbose=True,
+)
+
+# Option 2: Custom memory with tuned scoring
+memory = Memory(
+    recency_weight=0.4,
+    semantic_weight=0.4,
+    importance_weight=0.2,
+    recency_half_life_days=14,
+)
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[research_task, writing_task],
+    memory=memory,
+)
+```
+
+عند استخدام `memory=True`، ينشئ الفريق مثيل `Memory()` افتراضيًا ويمرر إعداد `embedder` الخاص بالفريق تلقائيًا. يشترك جميع الوكلاء في الفريق في ذاكرة الفريق ما لم يكن لدى الوكيل ذاكرته الخاصة.
+
+بعد كل مهمة، يستخرج الفريق تلقائيًا حقائق منفصلة من مخرجات المهمة ويخزّنها. قبل كل مهمة، يسترجع الوكيل السياق ذا الصلة من الذاكرة ويحقنه في موجّه المهمة.
+
+### مع Agents
+
+يمكن للوكلاء استخدام ذاكرة الفريق المشتركة (افتراضيًا) أو تلقي عرض محدد النطاق للسياق الخاص.
+
+```python
+from crewai import Agent, Memory
+
+memory = Memory()
+
+# Researcher gets a private scope -- only sees /agent/researcher
+researcher = Agent(
+    role="Researcher",
+    goal="Find and analyze information",
+    backstory="Expert researcher with attention to detail",
+    memory=memory.scope("/agent/researcher"),
+)
+
+# Writer uses crew shared memory (no agent-level memory set)
+writer = Agent(
+    role="Writer",
+    goal="Produce clear, well-structured content",
+    backstory="Experienced technical writer",
+    # memory not set -- uses crew._memory when crew has memory enabled
+)
+```
+
+يمنح هذا النمط الباحث نتائج خاصة بينما يقرأ الكاتب من ذاكرة الفريق المشتركة.
+
+### مع التدفقات
+
+كل تدفق يحتوي على ذاكرة مدمجة. استخدم `self.remember()` و `self.recall()` و `self.extract_memories()` داخل أي دالة تدفق.
+
+```python
+from crewai.flow.flow import Flow, listen, start
+
+class ResearchFlow(Flow):
+    @start()
+    def gather_data(self):
+        findings = "PostgreSQL handles 10k concurrent connections. MySQL caps at 5k."
+        self.remember(findings, scope="/research/databases")
+        return findings
+
+    @listen(gather_data)
+    def write_report(self, findings):
+        # Recall past research to provide context
+        past = self.recall("database performance benchmarks")
+        context = "\n".join(f"- {m.record.content}" for m in past)
+        return f"Report:\nNew findings: {findings}\nPrevious context:\n{context}"
+```
+
+انظر [وثائق التدفقات](/concepts/flows) لمزيد من المعلومات حول الذاكرة في التدفقات.
+
+
+## النطاقات الهرمية
+
+### ما هي النطاقات
+
+يتم تنظيم الذكريات في شجرة هرمية من النطاقات، مشابهة لنظام الملفات. كل نطاق هو مسار مثل `/` أو `/project/alpha` أو `/agent/researcher/findings`.
+
+```
+/
+  /company
+    /company/engineering
+    /company/product
+  /project
+    /project/alpha
+    /project/beta
+  /agent
+    /agent/researcher
+    /agent/writer
+```
+
+توفر النطاقات **ذاكرة تعتمد على السياق** -- عند الاسترجاع ضمن نطاق، تبحث فقط في ذلك الفرع من الشجرة، مما يحسّن كلًا من الدقة والأداء.
+
+### كيف يعمل استنتاج النطاق
+
+عند استدعاء `remember()` دون تحديد نطاق، يحلل LLM المحتوى وشجرة النطاقات الحالية، ثم يقترح أفضل موضع. إذا لم يكن هناك نطاق حالي مناسب، ينشئ واحدًا جديدًا. بمرور الوقت، تنمو شجرة النطاقات عضويًا من المحتوى نفسه -- لا تحتاج إلى تصميم مخطط مسبقًا.
+
+```python
+memory = Memory()
+
+# LLM infers scope from content
+memory.remember("We chose PostgreSQL for the user database.")
+# -> might be placed under /project/decisions or /engineering/database
+
+# You can also specify scope explicitly
+memory.remember("Sprint velocity is 42 points", scope="/team/metrics")
+```
+
+### تصوير شجرة النطاقات
+
+```python
+print(memory.tree())
+# / (15 records)
+#   /project (8 records)
+#     /project/alpha (5 records)
+#     /project/beta (3 records)
+#   /agent (7 records)
+#     /agent/researcher (4 records)
+#     /agent/writer (3 records)
+
+print(memory.info("/project/alpha"))
+# ScopeInfo(path='/project/alpha', record_count=5,
+#           categories=['architecture', 'database'],
+#           oldest_record=datetime(...), newest_record=datetime(...),
+#           child_scopes=[])
+```
+
+### MemoryScope: عروض الأشجار الفرعية
+
+يقيّد `MemoryScope` جميع العمليات على فرع من الشجرة. يمكن للوكيل أو الكود الذي يستخدمه الرؤية والكتابة فقط ضمن تلك الشجرة الفرعية.
+
+```python
+memory = Memory()
+
+# Create a scope for a specific agent
+agent_memory = memory.scope("/agent/researcher")
+
+# Everything is relative to /agent/researcher
+agent_memory.remember("Found three relevant papers on LLM memory.")
+# -> stored under /agent/researcher
+
+agent_memory.recall("relevant papers")
+# -> searches only under /agent/researcher
+
+# Narrow further with subscope
+project_memory = agent_memory.subscope("project-alpha")
+# -> /agent/researcher/project-alpha
+```
+
+### أفضل الممارسات لتصميم النطاقات
+
+- **ابدأ بشكل مسطح، ودع LLM ينظّم.** لا تبالغ في هندسة تسلسل النطاقات مسبقًا. ابدأ بـ `memory.remember(content)` ودع استنتاج النطاق في LLM ينشئ الهيكل مع تراكم المحتوى.
+
+- **استخدم أنماط `/{entity_type}/{identifier}`.** تنشأ التسلسلات الطبيعية من أنماط مثل `/project/alpha` و `/agent/researcher` و `/company/engineering` و `/customer/acme-corp`.
+
+- **حدد النطاق حسب الاهتمام، وليس حسب نوع البيانات.** استخدم `/project/alpha/decisions` بدلاً من `/decisions/project/alpha`. هذا يبقي المحتوى ذا الصلة معًا.
+
+- **حافظ على العمق ضحلًا (2-3 مستويات).** النطاقات المتداخلة بعمق تصبح متفرقة جدًا. `/project/alpha/architecture` جيد؛ `/project/alpha/architecture/decisions/databases/postgresql` عميق جدًا.
+
+- **استخدم النطاقات الصريحة عندما تعرف، ودع LLM يستنتج عندما لا تعرف.** إذا كنت تخزّن قرار مشروع معروف، مرّر `scope="/project/alpha/decisions"`. إذا كنت تخزّن مخرجات وكيل حرة الشكل، اترك النطاق ودع LLM يحدده.
+
+### أمثلة حالات الاستخدام
+
+**فريق متعدد المشاريع:**
+```python
+memory = Memory()
+# Each project gets its own branch
+memory.remember("Using microservices architecture", scope="/project/alpha/architecture")
+memory.remember("GraphQL API for client apps", scope="/project/beta/api")
+
+# Recall across all projects
+memory.recall("API design decisions")
+
+# Or within a specific project
+memory.recall("API design", scope="/project/beta")
+```
+
+**سياق خاص لكل وكيل مع معرفة مشتركة:**
+```python
+memory = Memory()
+
+# Researcher has private findings
+researcher_memory = memory.scope("/agent/researcher")
+
+# Writer can read from both its own scope and shared company knowledge
+writer_view = memory.slice(
+    scopes=["/agent/writer", "/company/knowledge"],
+    read_only=True,
+)
+```
+
+**دعم العملاء (سياق لكل عميل):**
+```python
+memory = Memory()
+
+# Each customer gets isolated context
+memory.remember("Prefers email communication", scope="/customer/acme-corp")
+memory.remember("On enterprise plan, 50 seats", scope="/customer/acme-corp")
+
+# Shared product docs are accessible to all agents
+memory.remember("Rate limit is 1000 req/min on enterprise plan", scope="/product/docs")
+```
+
+
+## شرائح الذاكرة
+
+### ما هي الشرائح
+
+`MemorySlice` هو عرض عبر نطاقات متعددة، ربما متباعدة. على عكس النطاق (الذي يقيّد على شجرة فرعية واحدة)، تتيح لك الشريحة الاسترجاع من عدة فروع في وقت واحد.
+
+### متى تستخدم الشرائح مقابل النطاقات
+
+- **النطاق**: استخدمه عندما يجب تقييد وكيل أو كتلة كود على شجرة فرعية واحدة. مثال: وكيل يرى فقط `/agent/researcher`.
+- **الشريحة**: استخدمها عندما تحتاج إلى دمج السياق من عدة فروع. مثال: وكيل يقرأ من نطاقه الخاص بالإضافة إلى معرفة الشركة المشتركة.
+
+### شرائح القراءة فقط
+
+النمط الأكثر شيوعًا: منح وكيل إمكانية القراءة من فروع متعددة دون السماح له بالكتابة في المناطق المشتركة.
+
+```python
+memory = Memory()
+
+# Agent can recall from its own scope AND company knowledge,
+# but cannot write to company knowledge
+agent_view = memory.slice(
+    scopes=["/agent/researcher", "/company/knowledge"],
+    read_only=True,
+)
+
+matches = agent_view.recall("company security policies", limit=5)
+# Searches both /agent/researcher and /company/knowledge, merges and ranks results
+
+agent_view.remember("new finding")  # Raises PermissionError (read-only)
+```
+
+### شرائح القراءة والكتابة
+
+عند تعطيل القراءة فقط، يمكنك الكتابة في أي من النطاقات المضمّنة، لكن يجب تحديد النطاق صراحة.
+
+```python
+view = memory.slice(scopes=["/team/alpha", "/team/beta"], read_only=False)
+
+# Must specify scope when writing
+view.remember("Cross-team decision", scope="/team/alpha", categories=["decisions"])
+```
+
+
+## التسجيل المركب
+
+يتم ترتيب نتائج الاسترجاع بواسطة مزيج مرجّح من ثلاث إشارات:
+
+```
+composite = semantic_weight * similarity + recency_weight * decay + importance_weight * importance
+```
+
+حيث:
+- **similarity** = `1 / (1 + distance)` من فهرس المتجهات (0 إلى 1)
+- **decay** = `0.5^(age_days / half_life_days)` -- اضمحلال أُسي (1.0 لليوم، 0.5 عند نصف العمر)
+- **importance** = درجة أهمية السجل (0 إلى 1)، يتم تعيينها وقت الترميز
+
+قم بإعدادها مباشرة على منشئ `Memory`:
+
+```python
+# Sprint retrospective: favor recent memories, short half-life
+memory = Memory(
+    recency_weight=0.5,
+    semantic_weight=0.3,
+    importance_weight=0.2,
+    recency_half_life_days=7,
+)
+
+# Architecture knowledge base: favor important memories, long half-life
+memory = Memory(
+    recency_weight=0.1,
+    semantic_weight=0.5,
+    importance_weight=0.4,
+    recency_half_life_days=180,
+)
+```
+
+يتضمن كل `MemoryMatch` قائمة `match_reasons` حتى تتمكن من رؤية سبب ترتيب نتيجة معينة في موضعها (مثل `["semantic", "recency", "importance"]`).
+
+
+## طبقة تحليل LLM
+
+تستخدم الذاكرة LLM بثلاث طرق:
+
+1. **عند الحفظ** -- عندما تحذف النطاق أو الفئات أو الأهمية، يحلل LLM المحتوى ويقترح النطاق والفئات والأهمية والبيانات الوصفية (الكيانات والتواريخ والموضوعات).
+2. **عند الاسترجاع** -- للاسترجاع العميق/التلقائي، يحلل LLM الاستعلام (الكلمات المفتاحية، تلميحات الوقت، النطاقات المقترحة، التعقيد) لتوجيه الاسترجاع.
+3. **استخراج الذكريات** -- `extract_memories(content)` يقسم النص الخام (مثل مخرجات المهمة) إلى عبارات ذاكرة منفصلة. يستخدم الوكلاء هذا قبل استدعاء `remember()` على كل عبارة حتى يتم تخزين حقائق ذرية بدلاً من كتلة كبيرة واحدة.
+
+جميع التحليلات تتدهور بسلاسة عند فشل LLM -- انظر [سلوك الفشل](#سلوك-الفشل).
+
+
+## توحيد الذاكرة
+
+عند حفظ محتوى جديد، يتحقق خط أنابيب الترميز تلقائيًا من وجود سجلات مماثلة في التخزين. إذا كان التشابه أعلى من `consolidation_threshold` (الافتراضي 0.85)، يقرر LLM ما يجب فعله:
+
+- **keep** -- السجل الحالي لا يزال دقيقًا وغير مكرر.
+- **update** -- يجب تحديث السجل الحالي بمعلومات جديدة (يوفر LLM المحتوى المدمج).
+- **delete** -- السجل الحالي قديم أو تم استبداله أو تناقضه.
+- **insert_new** -- ما إذا كان يجب إدراج المحتوى الجديد أيضًا كسجل منفصل.
+
+هذا يمنع تراكم النسخ المكررة. على سبيل المثال، إذا حفظت "CrewAI ensures reliable operation" ثلاث مرات، يتعرف التوحيد على النسخ المكررة ويحتفظ بسجل واحد فقط.
+
+### إزالة التكرار داخل الدفعة
+
+عند استخدام `remember_many()`، تتم مقارنة العناصر داخل نفس الدفعة مع بعضها البعض قبل الوصول إلى التخزين. إذا كان تشابه جيب التمام >= `batch_dedup_threshold` (الافتراضي 0.98)، يتم إسقاط العنصر الأحدث بصمت. هذا يلتقط النسخ المكررة الدقيقة أو شبه الدقيقة داخل دفعة واحدة دون أي استدعاءات LLM (رياضيات متجهات خالصة).
+
+```python
+# Only 2 records are stored (the third is a near-duplicate of the first)
+memory.remember_many([
+    "CrewAI supports complex workflows.",
+    "Python is a great language.",
+    "CrewAI supports complex workflows.",  # dropped by intra-batch dedup
+])
+```
+
+
+## الحفظ غير الحاجب
+
+`remember_many()` **غير حاجب** -- يقدم خط أنابيب الترميز إلى خيط خلفي ويعود فورًا. هذا يعني أن الوكيل يمكنه المتابعة إلى المهمة التالية بينما يتم حفظ الذكريات.
+
+```python
+# Returns immediately -- save happens in background
+memory.remember_many(["Fact A.", "Fact B.", "Fact C."])
+
+# recall() automatically waits for pending saves before searching
+matches = memory.recall("facts")  # sees all 3 records
+```
+
+### حاجز القراءة
+
+كل استدعاء `recall()` يستدعي تلقائيًا `drain_writes()` قبل البحث، مما يضمن أن الاستعلام يرى دائمًا أحدث السجلات المستمرة. هذا شفاف -- لا تحتاج أبدًا إلى التفكير فيه.
+
+### إيقاف الفريق
+
+عند انتهاء الفريق، يستنزف `kickoff()` جميع عمليات حفظ الذاكرة المعلقة في كتلة `finally` الخاصة به، لذا لا تُفقد أي عمليات حفظ حتى لو اكتمل الفريق بينما عمليات الحفظ الخلفية قيد التنفيذ.
+
+### الاستخدام المستقل
+
+للسكربتات أو دفاتر الملاحظات حيث لا توجد دورة حياة فريق، استدعِ `drain_writes()` أو `close()` صراحة:
+
+```python
+memory = Memory()
+memory.remember_many(["Fact A.", "Fact B."])
+
+# Option 1: Wait for pending saves
+memory.drain_writes()
+
+# Option 2: Drain and shut down the background pool
+memory.close()
+```
+
+
+## المصدر والخصوصية
+
+يمكن لكل سجل ذاكرة أن يحمل علامة `source` لتتبع المصدر وعلامة `private` للتحكم في الوصول.
+
+### تتبع المصدر
+
+يحدد معامل `source` من أين جاءت الذاكرة:
+
+```python
+# Tag memories with their origin
+memory.remember("User prefers dark mode", source="user:alice")
+memory.remember("System config updated", source="admin")
+memory.remember("Agent found a bug", source="agent:debugger")
+
+# Recall only memories from a specific source
+matches = memory.recall("user preferences", source="user:alice")
+```
+
+### الذكريات الخاصة
+
+الذكريات الخاصة مرئية فقط للاسترجاع عندما يتطابق `source`:
+
+```python
+# Store a private memory
+memory.remember("Alice's API key is sk-...", source="user:alice", private=True)
+
+# This recall sees the private memory (source matches)
+matches = memory.recall("API key", source="user:alice")
+
+# This recall does NOT see it (different source)
+matches = memory.recall("API key", source="user:bob")
+
+# Admin access: see all private records regardless of source
+matches = memory.recall("API key", include_private=True)
+```
+
+هذا مفيد بشكل خاص في النشرات متعددة المستخدمين أو المؤسسية حيث يجب عزل ذكريات المستخدمين المختلفين.
+
+
+## RecallFlow (الاسترجاع العميق)
+
+يدعم `recall()` عمقين:
+
+- **`depth="shallow"`** -- بحث متجهي مباشر مع تسجيل مركب. سريع (~200 مللي ثانية)، بدون استدعاءات LLM.
+- **`depth="deep"` (افتراضي)** -- يشغل RecallFlow متعدد الخطوات: تحليل الاستعلام، اختيار النطاق، بحث متجهي متوازٍ، توجيه قائم على الثقة، واستكشاف متكرر اختياري عندما تكون الثقة منخفضة.
+
+**تخطي LLM الذكي**: الاستعلامات الأقصر من `query_analysis_threshold` (الافتراضي 200 حرف) تتخطى تحليل LLM للاستعلام بالكامل، حتى في الوضع العميق. الاستعلامات القصيرة مثل "ما قاعدة البيانات التي نستخدمها؟" هي بالفعل عبارات بحث جيدة -- تحليل LLM يضيف قيمة قليلة. هذا يوفر ~1-3 ثوانٍ لكل استرجاع للاستعلامات القصيرة النموذجية. فقط الاستعلامات الأطول (مثل أوصاف المهام الكاملة) تمر عبر تقطير LLM إلى استعلامات فرعية مستهدفة.
+
+```python
+# Shallow: pure vector search, no LLM
+matches = memory.recall("What did we decide?", limit=10, depth="shallow")
+
+# Deep (default): intelligent retrieval with LLM analysis for long queries
+matches = memory.recall(
+    "Summarize all architecture decisions from this quarter",
+    limit=10,
+    depth="deep",
+)
+```
+
+عتبات الثقة التي تتحكم في موجّه RecallFlow قابلة للإعداد:
+
+```python
+memory = Memory(
+    confidence_threshold_high=0.9,   # Only synthesize when very confident
+    confidence_threshold_low=0.4,    # Explore deeper more aggressively
+    exploration_budget=2,            # Allow up to 2 exploration rounds
+    query_analysis_threshold=200,    # Skip LLM for queries shorter than this
+)
+```
+
+
+## إعداد المُضمِّن
+
+تحتاج الذاكرة إلى نموذج تضمين لتحويل النص إلى متجهات للبحث الدلالي. يمكنك إعداده بثلاث طرق.
+
+### التمرير إلى Memory مباشرة
+
+```python
+from crewai import Memory
+
+# As a config dict
+memory = Memory(embedder={"provider": "openai", "config": {"model_name": "text-embedding-3-small"}})
+
+# As a pre-built callable
+from crewai.rag.embeddings.factory import build_embedder
+embedder = build_embedder({"provider": "ollama", "config": {"model_name": "mxbai-embed-large"}})
+memory = Memory(embedder=embedder)
+```
+
+### عبر إعداد مُضمِّن Crew
+
+عند استخدام `memory=True`، يتم تمرير إعداد `embedder` الخاص بالفريق:
+
+```python
+from crewai import Crew
+
+crew = Crew(
+    agents=[...],
+    tasks=[...],
+    memory=True,
+    embedder={"provider": "openai", "config": {"model_name": "text-embedding-3-small"}},
+)
+```
+
+### أمثلة المزودين
+
+<AccordionGroup>
+<Accordion title="OpenAI (افتراضي)">
+```python
+memory = Memory(embedder={
+    "provider": "openai",
+    "config": {
+        "model_name": "text-embedding-3-small",
+        # "api_key": "sk-...",  # or set OPENAI_API_KEY env var
+    },
+})
+```
+</Accordion>
+
+<Accordion title="Ollama (محلي، خاص)">
+```python
+memory = Memory(embedder={
+    "provider": "ollama",
+    "config": {
+        "model_name": "mxbai-embed-large",
+        "url": "http://localhost:11434/api/embeddings",
+    },
+})
+```
+</Accordion>
+
+<Accordion title="Azure OpenAI">
+```python
+memory = Memory(embedder={
+    "provider": "azure",
+    "config": {
+        "deployment_id": "your-embedding-deployment",
+        "api_key": "your-azure-api-key",
+        "api_base": "https://your-resource.openai.azure.com",
+        "api_version": "2024-02-01",
+    },
+})
+```
+</Accordion>
+
+<Accordion title="Google AI">
+```python
+memory = Memory(embedder={
+    "provider": "google-generativeai",
+    "config": {
+        "model_name": "gemini-embedding-001",
+        # "api_key": "...",  # or set GOOGLE_API_KEY env var
+    },
+})
+```
+</Accordion>
+
+<Accordion title="Google Vertex AI">
+```python
+memory = Memory(embedder={
+    "provider": "google-vertex",
+    "config": {
+        "model_name": "gemini-embedding-001",
+        "project_id": "your-gcp-project-id",
+        "location": "us-central1",
+    },
+})
+```
+</Accordion>
+
+<Accordion title="Cohere">
+```python
+memory = Memory(embedder={
+    "provider": "cohere",
+    "config": {
+        "model_name": "embed-english-v3.0",
+        # "api_key": "...",  # or set COHERE_API_KEY env var
+    },
+})
+```
+</Accordion>
+
+<Accordion title="VoyageAI">
+```python
+memory = Memory(embedder={
+    "provider": "voyageai",
+    "config": {
+        "model": "voyage-3",
+        # "api_key": "...",  # or set VOYAGE_API_KEY env var
+    },
+})
+```
+</Accordion>
+
+<Accordion title="AWS Bedrock">
+```python
+memory = Memory(embedder={
+    "provider": "amazon-bedrock",
+    "config": {
+        "model_name": "amazon.titan-embed-text-v1",
+        # Uses default AWS credentials (boto3 session)
+    },
+})
+```
+</Accordion>
+
+<Accordion title="Hugging Face">
+```python
+memory = Memory(embedder={
+    "provider": "huggingface",
+    "config": {
+        "model_name": "sentence-transformers/all-MiniLM-L6-v2",
+    },
+})
+```
+</Accordion>
+
+<Accordion title="Jina">
+```python
+memory = Memory(embedder={
+    "provider": "jina",
+    "config": {
+        "model_name": "jina-embeddings-v2-base-en",
+        # "api_key": "...",  # or set JINA_API_KEY env var
+    },
+})
+```
+</Accordion>
+
+<Accordion title="IBM WatsonX">
+```python
+memory = Memory(embedder={
+    "provider": "watsonx",
+    "config": {
+        "model_id": "ibm/slate-30m-english-rtrvr",
+        "api_key": "your-watsonx-api-key",
+        "project_id": "your-project-id",
+        "url": "https://us-south.ml.cloud.ibm.com",
+    },
+})
+```
+</Accordion>
+
+<Accordion title="مُضمِّن مخصص">
+```python
+# Pass any callable that takes a list of strings and returns a list of vectors
+def my_embedder(texts: list[str]) -> list[list[float]]:
+    # Your embedding logic here
+    return [[0.1, 0.2, ...] for _ in texts]
+
+memory = Memory(embedder=my_embedder)
+```
+</Accordion>
+</AccordionGroup>
+
+### مرجع المزودين
+
+| المزود | المفتاح | النموذج النموذجي | ملاحظات |
+| :--- | :--- | :--- | :--- |
+| OpenAI | `openai` | `text-embedding-3-small` | افتراضي. عيّن `OPENAI_API_KEY`. |
+| Ollama | `ollama` | `mxbai-embed-large` | محلي، لا حاجة لمفتاح API. |
+| Azure OpenAI | `azure` | `text-embedding-ada-002` | يتطلب `deployment_id`. |
+| Google AI | `google-generativeai` | `gemini-embedding-001` | عيّن `GOOGLE_API_KEY`. |
+| Google Vertex | `google-vertex` | `gemini-embedding-001` | يتطلب `project_id`. |
+| Cohere | `cohere` | `embed-english-v3.0` | دعم قوي متعدد اللغات. |
+| VoyageAI | `voyageai` | `voyage-3` | محسّن للاسترجاع. |
+| AWS Bedrock | `amazon-bedrock` | `amazon.titan-embed-text-v1` | يستخدم بيانات اعتماد boto3. |
+| Hugging Face | `huggingface` | `all-MiniLM-L6-v2` | sentence-transformers محلي. |
+| Jina | `jina` | `jina-embeddings-v2-base-en` | عيّن `JINA_API_KEY`. |
+| IBM WatsonX | `watsonx` | `ibm/slate-30m-english-rtrvr` | يتطلب `project_id`. |
+| Sentence Transformer | `sentence-transformer` | `all-MiniLM-L6-v2` | محلي، لا حاجة لمفتاح API. |
+| مخصص | `custom` | -- | يتطلب `embedding_callable`. |
+
+
+## إعداد LLM
+
+تستخدم الذاكرة LLM لتحليل الحفظ (استنتاج النطاق والفئات والأهمية)، وقرارات التوحيد، وتحليل استعلام الاسترجاع العميق. يمكنك إعداد النموذج المُستخدم.
+
+```python
+from crewai import Memory, LLM
+
+# Default: gpt-4o-mini
+memory = Memory()
+
+# Use a different OpenAI model
+memory = Memory(llm="gpt-4o")
+
+# Use Anthropic
+memory = Memory(llm="anthropic/claude-3-haiku-20240307")
+
+# Use Ollama for fully local/private analysis
+memory = Memory(llm="ollama/llama3.2")
+
+# Use Google Gemini
+memory = Memory(llm="gemini/gemini-2.0-flash")
+
+# Pass a pre-configured LLM instance with custom settings
+llm = LLM(model="gpt-4o", temperature=0)
+memory = Memory(llm=llm)
+```
+
+يتم تهيئة LLM **بشكل كسول** -- يتم إنشاؤه فقط عند الحاجة لأول مرة. هذا يعني أن `Memory()` لا يفشل أبدًا في وقت الإنشاء، حتى لو لم تكن مفاتيح API مُعيّنة. تظهر الأخطاء فقط عند استدعاء LLM فعليًا (مثلاً عند الحفظ بدون نطاق/فئات صريحة، أو أثناء الاسترجاع العميق).
+
+للتشغيل المحلي/الخاص بالكامل، استخدم نموذجًا محليًا لكل من LLM والمُضمِّن:
+
+```python
+memory = Memory(
+    llm="ollama/llama3.2",
+    embedder={"provider": "ollama", "config": {"model_name": "mxbai-embed-large"}},
+)
+```
+
+
+## واجهة التخزين
+
+- **الافتراضي**: LanceDB، مخزّن تحت `./.crewai/memory` (أو `$CREWAI_STORAGE_DIR/memory` إذا تم تعيين متغير البيئة، أو المسار الذي تمرره كـ `storage="path/to/dir"`).
+- **واجهة مخصصة**: نفّذ بروتوكول `StorageBackend` (انظر `crewai.memory.storage.backend`) ومرّر مثيلًا إلى `Memory(storage=your_backend)`.
+
+
+## الاستكشاف
+
+فحص التسلسل الهرمي للنطاقات والفئات والسجلات:
+
+```python
+memory.tree()                        # Formatted tree of scopes and record counts
+memory.tree("/project", max_depth=2) # Subtree view
+memory.info("/project")              # ScopeInfo: record_count, categories, oldest/newest
+memory.list_scopes("/")              # Immediate child scopes
+memory.list_categories()             # Category names and counts
+memory.list_records(scope="/project/alpha", limit=20)  # Records in a scope, newest first
+```
+
+
+## سلوك الفشل
+
+إذا فشل LLM أثناء التحليل (خطأ شبكة، حد معدل، استجابة غير صالحة)، تتدهور الذاكرة بسلاسة:
+
+- **تحليل الحفظ** -- يتم تسجيل تحذير ولا يزال يتم تخزين الذاكرة مع النطاق الافتراضي `/`، فئات فارغة، وأهمية `0.5`.
+- **استخراج الذكريات** -- يتم تخزين المحتوى الكامل كذاكرة واحدة حتى لا يُفقد شيء.
+- **تحليل الاستعلام** -- يتراجع الاسترجاع إلى اختيار نطاق بسيط وبحث متجهي حتى تستمر في الحصول على نتائج.
+
+لا يتم رفع أي استثناء لفشل التحليل هذه؛ فقط فشل التخزين أو المُضمِّن سيرفع استثناءً.
+
+
+## ملاحظة حول الخصوصية
+
+يتم إرسال محتوى الذاكرة إلى LLM المُعدّ للتحليل (النطاق/الفئات/الأهمية عند الحفظ، تحليل الاستعلام والاسترجاع العميق الاختياري). للبيانات الحساسة، استخدم LLM محليًا (مثل Ollama) أو تأكد من أن مزودك يلبي متطلبات الامتثال الخاصة بك.
+
+
+## أحداث الذاكرة
+
+جميع عمليات الذاكرة تُصدر أحداثًا مع `source_type="unified_memory"`. يمكنك الاستماع للتوقيت والأخطاء والمحتوى.
+
+| الحدث | الوصف | الخصائص الرئيسية |
+| :---- | :---------- | :------------- |
+| **MemoryQueryStartedEvent** | بداية الاستعلام | `query`, `limit` |
+| **MemoryQueryCompletedEvent** | نجاح الاستعلام | `query`, `results`, `query_time_ms` |
+| **MemoryQueryFailedEvent** | فشل الاستعلام | `query`, `error` |
+| **MemorySaveStartedEvent** | بداية الحفظ | `value`, `metadata` |
+| **MemorySaveCompletedEvent** | نجاح الحفظ | `value`, `save_time_ms` |
+| **MemorySaveFailedEvent** | فشل الحفظ | `value`, `error` |
+| **MemoryRetrievalStartedEvent** | بداية استرجاع الوكيل | `task_id` |
+| **MemoryRetrievalCompletedEvent** | اكتمال استرجاع الوكيل | `task_id`, `memory_content`, `retrieval_time_ms` |
+
+مثال: مراقبة وقت الاستعلام:
+
+```python
+from crewai.events import BaseEventListener, MemoryQueryCompletedEvent
+
+class MemoryMonitor(BaseEventListener):
+    def setup_listeners(self, crewai_event_bus):
+        @crewai_event_bus.on(MemoryQueryCompletedEvent)
+        def on_done(source, event):
+            if getattr(event, "source_type", None) == "unified_memory":
+                print(f"Query '{event.query}' completed in {event.query_time_ms:.0f}ms")
+```
+
+
+## استكشاف المشاكل
+
+**الذاكرة لا تستمر؟**
+- تأكد من أن مسار التخزين قابل للكتابة (الافتراضي `./.crewai/memory`). مرّر `storage="./your_path"` لاستخدام مجلد مختلف، أو عيّن متغير البيئة `CREWAI_STORAGE_DIR`.
+- عند استخدام فريق، تأكد من تعيين `memory=True` أو `memory=Memory(...)`.
+
+**الاسترجاع بطيء؟**
+- استخدم `depth="shallow"` لسياق الوكيل الروتيني. احتفظ بـ `depth="deep"` للاستعلامات المعقدة.
+- زد `query_analysis_threshold` لتخطي تحليل LLM لمزيد من الاستعلامات.
+
+**أخطاء تحليل LLM في السجلات؟**
+- لا تزال الذاكرة تحفظ/تسترجع بإعدادات افتراضية آمنة. تحقق من مفاتيح API وحدود المعدل وتوفر النموذج إذا كنت تريد تحليل LLM كاملاً.
+
+**أخطاء حفظ خلفية في السجلات؟**
+- عمليات حفظ الذاكرة تعمل في خيط خلفي. تُصدر الأخطاء كـ `MemorySaveFailedEvent` لكنها لا تعطل الوكيل. تحقق من السجلات للسبب الجذري (عادة مشاكل اتصال LLM أو المُضمِّن).
+
+**تعارضات الكتابة المتزامنة؟**
+- عمليات LanceDB مُتسلسلة بقفل مشترك وتُعاد تلقائيًا عند التعارض. هذا يتعامل مع مثيلات `Memory` المتعددة التي تشير إلى نفس قاعدة البيانات (مثل ذاكرة وكيل + ذاكرة فريق). لا حاجة لإجراء.
+
+**تصفح الذاكرة من الطرفية:**
+```bash
+crewai memory                              # Opens the TUI browser
+crewai memory --storage-path ./my_memory   # Point to a specific directory
+```
+
+**إعادة تعيين الذاكرة (مثلاً للاختبارات):**
+```python
+crew.reset_memories(command_type="memory")  # Resets unified memory
+# Or on a Memory instance:
+memory.reset()                    # All scopes
+memory.reset(scope="/project/old")  # Only that subtree
+```
+
+
+## مرجع الإعداد
+
+جميع الإعدادات تُمرر كمعاملات كلمة مفتاحية إلى `Memory(...)`. كل معامل له قيمة افتراضية معقولة.
+
+| المعامل | الافتراضي | الوصف |
+| :--- | :--- | :--- |
+| `llm` | `"gpt-4o-mini"` | LLM للتحليل (اسم نموذج أو مثيل `BaseLLM`). |
+| `storage` | `"lancedb"` | واجهة التخزين (`"lancedb"`، سلسلة مسار، أو مثيل `StorageBackend`). |
+| `embedder` | `None` (افتراضي OpenAI) | المُضمِّن (قاموس إعداد، دالة قابلة للاستدعاء، أو `None` لافتراضي OpenAI). |
+| `recency_weight` | `0.3` | وزن الحداثة في الدرجة المركبة. |
+| `semantic_weight` | `0.5` | وزن التشابه الدلالي في الدرجة المركبة. |
+| `importance_weight` | `0.2` | وزن الأهمية في الدرجة المركبة. |
+| `recency_half_life_days` | `30` | أيام لتنصيف درجة الحداثة (اضمحلال أُسي). |
+| `consolidation_threshold` | `0.85` | التشابه الذي يُشغّل فوقه التوحيد عند الحفظ. عيّن إلى `1.0` للتعطيل. |
+| `consolidation_limit` | `5` | أقصى عدد سجلات حالية للمقارنة أثناء التوحيد. |
+| `default_importance` | `0.5` | الأهمية المُعيّنة عندما لا تُوفَّر ويتم تخطي تحليل LLM. |
+| `batch_dedup_threshold` | `0.98` | تشابه جيب التمام لإسقاط النسخ شبه المكررة داخل دفعة `remember_many()`. |
+| `confidence_threshold_high` | `0.8` | ثقة الاسترجاع التي تُعاد فوقها النتائج مباشرة. |
+| `confidence_threshold_low` | `0.5` | ثقة الاسترجاع التي يُشغّل تحتها استكشاف أعمق. |
+| `complex_query_threshold` | `0.7` | للاستعلامات المعقدة، استكشف أعمق تحت هذه الثقة. |
+| `exploration_budget` | `1` | عدد جولات الاستكشاف المدفوعة بـ LLM أثناء الاسترجاع العميق. |
+| `query_analysis_threshold` | `200` | الاستعلامات الأقصر من هذا (بالأحرف) تتخطى تحليل LLM أثناء الاسترجاع العميق. |

docs/edge/ar/concepts/planning.mdx

@@ -0,0 +1,155 @@
+---
+title: التخطيط
+description: تعرّف على كيفية إضافة التخطيط إلى طاقم CrewAI وتحسين أدائه.
+icon: ruler-combined
+mode: "wide"
+---
+
+## نظرة عامة
+
+تتيح لك ميزة التخطيط في CrewAI إضافة قدرة التخطيط إلى طاقمك. عند تفعيلها، قبل كل تكرار للطاقم،
+يتم إرسال جميع معلومات الطاقم إلى AgentPlanner الذي يخطط للمهام خطوة بخطوة، ويُضاف هذا المخطط إلى وصف كل مهمة.
+
+### استخدام ميزة التخطيط
+
+البدء بميزة التخطيط سهل جدًا، الخطوة الوحيدة المطلوبة هي إضافة `planning=True` إلى طاقمك:
+
+<CodeGroup>
+```python Code
+from crewai import Crew, Agent, Task, Process
+
+# تجميع طاقمك مع قدرات التخطيط
+my_crew = Crew(
+    agents=self.agents,
+    tasks=self.tasks,
+    process=Process.sequential,
+    planning=True,
+)
+```
+</CodeGroup>
+
+من هذه النقطة فصاعدًا، سيكون التخطيط مفعّلًا في طاقمك، وسيتم تخطيط المهام قبل كل تكرار.
+
+<Warning>
+عند تفعيل التخطيط، سيستخدم CrewAI `gpt-4o-mini` كنموذج LLM افتراضي للتخطيط، مما يتطلب مفتاح API صالحًا من OpenAI. نظرًا لأن وكلاءك قد يستخدمون نماذج LLM مختلفة، فقد يسبب ذلك ارتباكًا إذا لم يكن لديك مفتاح OpenAI API مهيأ أو إذا كنت تواجه سلوكًا غير متوقع متعلقًا باستدعاءات LLM API.
+</Warning>
+
+#### LLM التخطيط
+
+يمكنك الآن تحديد نموذج LLM الذي سيُستخدم لتخطيط المهام.
+
+عند تشغيل مثال الحالة الأساسية، سترى شيئًا مشابهًا للمخرجات أدناه، والتي تمثل مخرجات `AgentPlanner`
+المسؤول عن إنشاء المنطق التدريجي لإضافته إلى مهام الوكلاء.
+
+<CodeGroup>
+```python Code
+from crewai import Crew, Agent, Task, Process
+
+# تجميع طاقمك مع قدرات التخطيط ونموذج LLM مخصص
+my_crew = Crew(
+    agents=self.agents,
+    tasks=self.tasks,
+    process=Process.sequential,
+    planning=True,
+    planning_llm="gpt-4o"
+)
+
+# تشغيل الطاقم
+my_crew.kickoff()
+```
+
+```markdown Result
+[2024-07-15 16:49:11][INFO]: Planning the crew execution
+**Step-by-Step Plan for Task Execution**
+
+**Task Number 1: Conduct a thorough research about AI LLMs**
+
+**Agent:** AI LLMs Senior Data Researcher
+
+**Agent Goal:** Uncover cutting-edge developments in AI LLMs
+
+**Task Expected Output:** A list with 10 bullet points of the most relevant information about AI LLMs
+
+**Task Tools:** None specified
+
+**Agent Tools:** None specified
+
+**Step-by-Step Plan:**
+
+1. **Define Research Scope:**
+
+   - Determine the specific areas of AI LLMs to focus on, such as advancements in architecture, use cases, ethical considerations, and performance metrics.
+
+2. **Identify Reliable Sources:**
+
+   - List reputable sources for AI research, including academic journals, industry reports, conferences (e.g., NeurIPS, ACL), AI research labs (e.g., OpenAI, Google AI), and online databases (e.g., IEEE Xplore, arXiv).
+
+3. **Collect Data:**
+
+   - Search for the latest papers, articles, and reports published in 2024 and early 2025.
+   - Use keywords like "Large Language Models 2025", "AI LLM advancements", "AI ethics 2025", etc.
+
+4. **Analyze Findings:**
+
+   - Read and summarize the key points from each source.
+   - Highlight new techniques, models, and applications introduced in the past year.
+
+5. **Organize Information:**
+
+   - Categorize the information into relevant topics (e.g., new architectures, ethical implications, real-world applications).
+   - Ensure each bullet point is concise but informative.
+
+6. **Create the List:**
+
+   - Compile the 10 most relevant pieces of information into a bullet point list.
+   - Review the list to ensure clarity and relevance.
+
+**Expected Output:**
+
+A list with 10 bullet points of the most relevant information about AI LLMs.
+
+---
+
+**Task Number 2: Review the context you got and expand each topic into a full section for a report**
+
+**Agent:** AI LLMs Reporting Analyst
+
+**Agent Goal:** Create detailed reports based on AI LLMs data analysis and research findings
+
+**Task Expected Output:** A fully fledged report with the main topics, each with a full section of information. Formatted as markdown without '```'
+
+**Task Tools:** None specified
+
+**Agent Tools:** None specified
+
+**Step-by-Step Plan:**
+
+1. **Review the Bullet Points:**
+   - Carefully read through the list of 10 bullet points provided by the AI LLMs Senior Data Researcher.
+
+2. **Outline the Report:**
+   - Create an outline with each bullet point as a main section heading.
+   - Plan sub-sections under each main heading to cover different aspects of the topic.
+
+3. **Research Further Details:**
+   - For each bullet point, conduct additional research if necessary to gather more detailed information.
+   - Look for case studies, examples, and statistical data to support each section.
+
+4. **Write Detailed Sections:**
+   - Expand each bullet point into a comprehensive section.
+   - Ensure each section includes an introduction, detailed explanation, examples, and a conclusion.
+   - Use markdown formatting for headings, subheadings, lists, and emphasis.
+
+5. **Review and Edit:**
+   - Proofread the report for clarity, coherence, and correctness.
+   - Make sure the report flows logically from one section to the next.
+   - Format the report according to markdown standards.
+
+6. **Finalize the Report:**
+   - Ensure the report is complete with all sections expanded and detailed.
+   - Double-check formatting and make any necessary adjustments.
+
+**Expected Output:**
+A fully fledged report with the main topics, each with a full section of information. Formatted as markdown without '```'.
+```
+</CodeGroup>

docs/edge/ar/concepts/processes.mdx

@@ -0,0 +1,66 @@
+---
+title: العمليات
+description: دليل تفصيلي حول إدارة سير العمل من خلال العمليات في CrewAI، مع تفاصيل التنفيذ المحدّثة.
+icon: bars-staggered
+mode: "wide"
+---
+
+## نظرة عامة
+
+<Tip>
+  تنسّق العمليات تنفيذ المهام بواسطة الوكلاء، على غرار إدارة المشاريع في الفرق البشرية.
+  تضمن هذه العمليات توزيع المهام وتنفيذها بكفاءة، وفقًا لاستراتيجية محددة مسبقًا.
+</Tip>
+
+## تنفيذات العمليات
+
+- **تسلسلي**: ينفذ المهام بالتتابع، مما يضمن إكمال المهام بتقدم منظم.
+- **هرمي**: ينظم المهام في تسلسل إداري هرمي، حيث يتم تفويض المهام وتنفيذها بناءً على سلسلة أوامر منظمة. يجب تحديد نموذج لغة المدير (`manager_llm`) أو وكيل مدير مخصص (`manager_agent`) في الطاقم لتفعيل العملية الهرمية، مما يسهّل إنشاء وإدارة المهام من قبل المدير.
+
+## دور العمليات في العمل الجماعي
+تُمكّن العمليات الوكلاء الأفراد من العمل كوحدة متماسكة، مما يبسّط جهودهم لتحقيق أهداف مشتركة بكفاءة وتناسق.
+
+## تعيين العمليات للطاقم
+لتعيين عملية لطاقم، حدد نوع العملية عند إنشاء الطاقم لتعيين استراتيجية التنفيذ. للعملية الهرمية، تأكد من تحديد `manager_llm` أو `manager_agent` لوكيل المدير.
+
+```python
+from crewai import Crew, Process
+
+# مثال: إنشاء طاقم بعملية تسلسلية
+crew = Crew(
+    agents=my_agents,
+    tasks=my_tasks,
+    process=Process.sequential
+)
+
+# مثال: إنشاء طاقم بعملية هرمية
+# تأكد من توفير manager_llm أو manager_agent
+crew = Crew(
+    agents=my_agents,
+    tasks=my_tasks,
+    process=Process.hierarchical,
+    manager_llm="gpt-4o"
+    # أو
+    # manager_agent=my_manager_agent
+)
+```
+**ملاحظة:** تأكد من تعريف `my_agents` و `my_tasks` قبل إنشاء كائن `Crew`، وللعملية الهرمية، يُعد `manager_llm` أو `manager_agent` مطلوبًا أيضًا.
+
+## العملية التسلسلية
+
+تعكس هذه الطريقة سير عمل الفريق الديناميكي، وتتقدم عبر المهام بطريقة مدروسة ومنهجية. يتبع تنفيذ المهام الترتيب المحدد مسبقًا في قائمة المهام، حيث يعمل ناتج مهمة واحدة كسياق للمهمة التالية.
+
+لتخصيص سياق المهمة، استخدم معامل `context` في فئة `Task` لتحديد المخرجات التي يجب استخدامها كسياق للمهام اللاحقة.
+
+## العملية الهرمية
+
+تحاكي التسلسل الهرمي المؤسسي، حيث يسمح CrewAI بتحديد وكيل مدير مخصص أو إنشاء واحد تلقائيًا، مما يتطلب تحديد نموذج لغة المدير (`manager_llm`). يشرف هذا الوكيل على تنفيذ المهام، بما في ذلك التخطيط والتفويض والتحقق. لا يتم تعيين المهام مسبقًا؛ يخصص المدير المهام للوكلاء بناءً على قدراتهم، ويراجع المخرجات، ويقيّم اكتمال المهام.
+
+## فئة Process: نظرة عامة مفصلة
+
+تم تنفيذ فئة `Process` كتعداد (`Enum`)، مما يضمن أمان الأنواع ويقيّد قيم العملية على الأنواع المحددة (`sequential`، `hierarchical`).
+
+## الخلاصة
+
+التعاون المنظم الذي تسهّله العمليات داخل CrewAI ضروري لتمكين العمل الجماعي المنهجي بين الوكلاء.
+تم تحديث هذه الوثائق لتعكس أحدث الميزات والتحسينات، مما يضمن وصول المستخدمين إلى أحدث المعلومات وأكثرها شمولاً.

docs/edge/ar/concepts/production-architecture.mdx

@@ -0,0 +1,162 @@
+---
+title: بنية الإنتاج
+description: أفضل الممارسات لبناء تطبيقات ذكاء اصطناعي جاهزة للإنتاج مع CrewAI
+icon: server
+mode: "wide"
+---
+
+# عقلية التدفق أولاً
+
+عند بناء تطبيقات ذكاء اصطناعي إنتاجية مع CrewAI، **نوصي بالبدء بتدفق (Flow)**.
+
+بينما يمكن تشغيل أطقم أو وكلاء فرديين، فإن تغليفهم في تدفق يوفر الهيكل اللازم لتطبيق متين وقابل للتوسع.
+
+## لماذا التدفقات؟
+
+1. **إدارة الحالة**: توفر التدفقات طريقة مدمجة لإدارة الحالة عبر مراحل مختلفة من تطبيقك. هذا ضروري لتمرير البيانات بين الأطقم والحفاظ على السياق ومعالجة مدخلات المستخدم.
+2. **التحكم**: تتيح لك التدفقات تحديد مسارات تنفيذ دقيقة، بما في ذلك الحلقات والشرطيات ومنطق التفريع. هذا أساسي لمعالجة الحالات الاستثنائية وضمان سلوك تطبيقك بشكل متوقع.
+3. **المراقبة**: توفر التدفقات هيكلًا واضحًا يسهّل تتبع التنفيذ وتصحيح الأخطاء ومراقبة الأداء. نوصي باستخدام [تتبع CrewAI](/ar/observability/tracing) للحصول على رؤى تفصيلية. ما عليك سوى تشغيل `crewai login` لتفعيل ميزات المراقبة المجانية.
+
+## البنية
+
+يبدو تطبيق CrewAI الإنتاجي النموذجي هكذا:
+
+```mermaid
+graph TD
+    Start((Start)) --> Flow[Flow Orchestrator]
+    Flow --> State{State Management}
+    State --> Step1[Step 1: Data Gathering]
+    Step1 --> Crew1[Research Crew]
+    Crew1 --> State
+    State --> Step2{Condition Check}
+    Step2 -- "Valid" --> Step3[Step 3: Execution]
+    Step3 --> Crew2[Action Crew]
+    Step2 -- "Invalid" --> End((End))
+    Crew2 --> End
+```
+
+### 1. فئة التدفق
+فئة `Flow` هي نقطة الدخول. تحدد مخطط الحالة والطرق التي تنفذ منطقك.
+
+```python
+from crewai.flow.flow import Flow, listen, start
+from pydantic import BaseModel
+
+class AppState(BaseModel):
+    user_input: str = ""
+    research_results: str = ""
+    final_report: str = ""
+
+class ProductionFlow(Flow[AppState]):
+    @start()
+    def gather_input(self):
+        # ... منطق الحصول على المدخلات ...
+        pass
+
+    @listen(gather_input)
+    def run_research_crew(self):
+        # ... تشغيل طاقم ...
+        pass
+```
+
+### 2. إدارة الحالة
+استخدم نماذج Pydantic لتعريف حالتك. يضمن هذا أمان الأنواع ويوضح البيانات المتاحة في كل مرحلة.
+
+- **اجعلها بسيطة**: خزّن فقط ما تحتاجه للاستمرار بين المراحل.
+- **استخدم بيانات منظمة**: تجنب القواميس غير المنظمة قدر الإمكان.
+
+### 3. الأطقم كوحدات عمل
+فوّض المهام المعقدة إلى الأطقم. يجب أن يكون الطاقم مركّزًا على هدف محدد (مثل "البحث في موضوع"، "كتابة مقال مدونة").
+
+- **لا تبالغ في هندسة الأطقم**: اجعلها مركّزة.
+- **مرر الحالة بشكل صريح**: مرر البيانات الضرورية من حالة التدفق إلى مدخلات الطاقم.
+
+```python
+    @listen(gather_input)
+    def run_research_crew(self):
+        crew = ResearchCrew()
+        result = crew.kickoff(inputs={"topic": self.state.user_input})
+        self.state.research_results = result.raw
+```
+
+## عناصر التحكم الأولية
+
+استفد من عناصر التحكم الأولية في CrewAI لإضافة المتانة والتحكم إلى أطقمك.
+
+### 1. حواجز المهام
+استخدم [حواجز المهام](/ar/concepts/tasks#task-guardrails) للتحقق من مخرجات المهام قبل قبولها. يضمن هذا أن وكلاءك ينتجون نتائج عالية الجودة.
+
+```python
+def validate_content(result: TaskOutput) -> Tuple[bool, Any]:
+    if len(result.raw) < 100:
+        return (False, "Content is too short. Please expand.")
+    return (True, result.raw)
+
+task = Task(
+    ...,
+    guardrail=validate_content
+)
+```
+
+### 2. المخرجات المنظمة
+استخدم دائمًا المخرجات المنظمة (`output_pydantic` أو `output_json`) عند تمرير البيانات بين المهام أو إلى تطبيقك. يمنع هذا أخطاء التحليل ويضمن أمان الأنواع.
+
+```python
+class ResearchResult(BaseModel):
+    summary: str
+    sources: List[str]
+
+task = Task(
+    ...,
+    output_pydantic=ResearchResult
+)
+```
+
+### 3. خطافات LLM
+استخدم [خطافات LLM](/ar/learn/llm-hooks) لفحص أو تعديل الرسائل قبل إرسالها إلى LLM، أو لتنقية الاستجابات.
+
+```python
+@before_llm_call
+def log_request(context):
+    print(f"Agent {context.agent.role} is calling the LLM...")
+```
+
+## أنماط النشر
+
+عند نشر تدفقك، ضع في اعتبارك ما يلي:
+
+### CrewAI Enterprise
+أسهل طريقة لنشر تدفقك هي استخدام CrewAI Enterprise. تتعامل مع البنية التحتية والمصادقة والمراقبة نيابة عنك.
+
+راجع [دليل النشر](https://docs-platform.crewai.com/platform/ar/guides/deploy-to-amp) للبدء.
+
+```bash
+crewai deploy create
+```
+
+### التنفيذ غير المتزامن
+للمهام طويلة التشغيل، استخدم `kickoff_async` لتجنب حظر واجهتك البرمجية.
+
+### الاستمرارية
+استخدم مزيّن `@persist` لحفظ حالة تدفقك في قاعدة بيانات. يتيح لك هذا استئناف التنفيذ إذا تعطلت العملية أو إذا كنت بحاجة لانتظار مدخلات بشرية.
+
+```python
+@persist
+class ProductionFlow(Flow[AppState]):
+    # ...
+```
+
+افتراضيًا، يستأنف `@persist` تدفقًا عند توفير `kickoff(inputs={"id": <uuid>})`، مما يمدّ نفس تاريخ `flow_uuid`. لـ **تفرع** تدفق مستمر إلى نسبٍ جديد — ترطيب الحالة من تشغيل سابق ولكن الكتابة تحت `state.id` جديد — مرّر `restore_from_state_id`:
+
+```python
+flow.kickoff(restore_from_state_id="<previous-run-state-id>")
+```
+
+يحصل التشغيل الجديد على `state.id` جديد (مولّد تلقائيًا، أو `inputs["id"]` إذا تم تثبيته) لذا لا تمتد كتابات `@persist` الخاصة به إلى تاريخ المصدر. الجمع مع `from_checkpoint` يطلق `ValueError`؛ اختر مصدر ترطيب واحدًا.
+
+## الخلاصة
+
+- **ابدأ بتدفق.**
+- **حدد حالة واضحة.**
+- **استخدم الأطقم للمهام المعقدة.**
+- **انشر مع API واستمرارية.**

docs/edge/ar/concepts/reasoning.mdx

@@ -0,0 +1,148 @@
+---
+title: الاستدلال
+description: "تعرّف على كيفية تفعيل واستخدام استدلال الوكيل لتحسين تنفيذ المهام."
+icon: brain
+mode: "wide"
+---
+
+## نظرة عامة
+
+استدلال الوكيل هو ميزة تتيح للوكلاء التأمل في المهمة وإنشاء خطة قبل التنفيذ. يساعد هذا الوكلاء على التعامل مع المهام بشكل أكثر منهجية ويضمن استعدادهم لأداء العمل المطلوب.
+
+## الاستخدام
+
+لتفعيل الاستدلال لوكيل، ما عليك سوى تعيين `reasoning=True` عند إنشاء الوكيل:
+
+```python
+from crewai import Agent
+
+agent = Agent(
+    role="Data Analyst",
+    goal="Analyze complex datasets and provide insights",
+    backstory="You are an experienced data analyst with expertise in finding patterns in complex data.",
+    reasoning=True,  # تفعيل الاستدلال
+    max_reasoning_attempts=3  # اختياري: تعيين حد أقصى لمحاولات الاستدلال
+)
+```
+
+## كيف يعمل
+
+عند تفعيل الاستدلال، قبل تنفيذ المهمة، سيقوم الوكيل بما يلي:
+
+1. التأمل في المهمة وإنشاء خطة مفصلة
+2. تقييم ما إذا كان مستعدًا لتنفيذ المهمة
+3. تحسين الخطة حسب الحاجة حتى يصبح مستعدًا أو يصل إلى max_reasoning_attempts
+4. حقن خطة الاستدلال في وصف المهمة قبل التنفيذ
+
+تساعد هذه العملية الوكيل على تقسيم المهام المعقدة إلى خطوات يمكن إدارتها وتحديد التحديات المحتملة قبل البدء.
+
+## خيارات التهيئة
+
+<ParamField body="reasoning" type="bool" default="False">
+    تفعيل أو تعطيل الاستدلال
+</ParamField>
+
+<ParamField body="max_reasoning_attempts" type="int" default="None">
+    الحد الأقصى لعدد المحاولات لتحسين الخطة قبل المتابعة بالتنفيذ. إذا كانت القيمة None (الافتراضي)، سيستمر الوكيل في التحسين حتى يصبح مستعدًا.
+</ParamField>
+
+## مثال
+
+إليك مثالًا كاملًا:
+
+```python
+from crewai import Agent, Task, Crew
+
+# إنشاء وكيل مع تفعيل الاستدلال
+analyst = Agent(
+    role="Data Analyst",
+    goal="Analyze data and provide insights",
+    backstory="You are an expert data analyst.",
+    reasoning=True,
+    max_reasoning_attempts=3  # اختياري: تعيين حد لمحاولات الاستدلال
+)
+
+# إنشاء مهمة
+analysis_task = Task(
+    description="Analyze the provided sales data and identify key trends.",
+    expected_output="A report highlighting the top 3 sales trends.",
+    agent=analyst
+)
+
+# إنشاء طاقم وتشغيل المهمة
+crew = Crew(agents=[analyst], tasks=[analysis_task])
+result = crew.kickoff()
+
+print(result)
+```
+
+## معالجة الأخطاء
+
+صُممت عملية الاستدلال لتكون متينة، مع معالجة أخطاء مدمجة. إذا حدث خطأ أثناء الاستدلال، سيتابع الوكيل تنفيذ المهمة بدون خطة الاستدلال. يضمن هذا إمكانية تنفيذ المهام حتى في حالة فشل عملية الاستدلال.
+
+إليك كيفية التعامل مع الأخطاء المحتملة في الكود الخاص بك:
+
+```python
+from crewai import Agent, Task
+import logging
+
+# إعداد التسجيل لالتقاط أي أخطاء في الاستدلال
+logging.basicConfig(level=logging.INFO)
+
+# إنشاء وكيل مع تفعيل الاستدلال
+agent = Agent(
+    role="Data Analyst",
+    goal="Analyze data and provide insights",
+    reasoning=True,
+    max_reasoning_attempts=3
+)
+
+# إنشاء مهمة
+task = Task(
+    description="Analyze the provided sales data and identify key trends.",
+    expected_output="A report highlighting the top 3 sales trends.",
+    agent=agent
+)
+
+# تنفيذ المهمة
+# إذا حدث خطأ أثناء الاستدلال، سيتم تسجيله وسيستمر التنفيذ
+result = agent.execute_task(task)
+```
+
+## مثال على مخرجات الاستدلال
+
+إليك مثالًا على شكل خطة الاستدلال لمهمة تحليل البيانات:
+
+```
+Task: Analyze the provided sales data and identify key trends.
+
+Reasoning Plan:
+I'll analyze the sales data to identify the top 3 trends.
+
+1. Understanding of the task:
+   I need to analyze sales data to identify key trends that would be valuable for business decision-making.
+
+2. Key steps I'll take:
+   - First, I'll examine the data structure to understand what fields are available
+   - Then I'll perform exploratory data analysis to identify patterns
+   - Next, I'll analyze sales by time periods to identify temporal trends
+   - I'll also analyze sales by product categories and customer segments
+   - Finally, I'll identify the top 3 most significant trends
+
+3. Approach to challenges:
+   - If the data has missing values, I'll decide whether to fill or filter them
+   - If the data has outliers, I'll investigate whether they're valid data points or errors
+   - If trends aren't immediately obvious, I'll apply statistical methods to uncover patterns
+
+4. Use of available tools:
+   - I'll use data analysis tools to explore and visualize the data
+   - I'll use statistical tools to identify significant patterns
+   - I'll use knowledge retrieval to access relevant information about sales analysis
+
+5. Expected outcome:
+   A concise report highlighting the top 3 sales trends with supporting evidence from the data.
+
+READY: I am ready to execute the task.
+```
+
+تساعد خطة الاستدلال هذه الوكيل على تنظيم نهجه تجاه المهمة، والنظر في التحديات المحتملة، وضمان تقديم المخرجات المتوقعة.

docs/edge/ar/concepts/skills.mdx

@@ -0,0 +1,373 @@
+---
+title: المهارات
+description: حزم المهارات المبنية على نظام الملفات التي تحقن خبرة المجال والتعليمات في إرشادات الوكلاء.
+icon: bolt
+mode: "wide"
+---
+
+## نظرة عامة
+
+المهارات هي مجلدات مستقلة توفر للوكلاء **تعليمات وإرشادات ومواد مرجعية خاصة بالمجال**. تُعرّف كل مهارة بملف `SKILL.md` يحتوي على بيانات وصفية YAML ومحتوى Markdown.
+
+عند التفعيل، يتم حقن تعليمات المهارة مباشرة في إرشادات مهمة الوكيل — مما يمنح الوكيل خبرة دون الحاجة لأي تغييرات في الكود.
+
+<Note type="info" title="المهارات مقابل الأدوات — التمييز الأساسي">
+**المهارات ليست أدوات.** هذه هي نقطة الارتباك الأكثر شيوعًا.
+
+- **المهارات** تحقن *تعليمات وسياق* في إرشادات الوكيل. تخبر الوكيل *كيف يفكر* في مشكلة ما.
+- **الأدوات** تمنح الوكيل *دوال قابلة للاستدعاء* لاتخاذ إجراءات (البحث، قراءة الملفات، استدعاء APIs).
+
+غالبًا ما تحتاج **كليهما**: مهارات للخبرة، وأدوات للإجراء. يتم تكوينهما بشكل مستقل ويُكمّلان بعضهما.
+</Note>
+
+---
+
+## البداية السريعة
+
+### 1. إنشاء مهارة باستخدام سطر الأوامر (CLI)
+
+واجهة سطر الأوامر هي الطريقة المدعومة لإنشاء مهارة — فهي تُنشئ لك هيكل المجلد وملف `SKILL.md` صالحًا:
+
+```shell Terminal
+crewai skill create code-review
+```
+
+داخل مشروع طاقم (حيث يوجد `pyproject.toml`) يُنشئ هذا الأمر `./skills/code-review/`؛ وخارج المشروع يُنشئ `./code-review/` في المجلد الحالي (يمكنك فرض هذا السلوك باستخدام `--no-project`):
+
+```
+skills/
+└── code-review/
+    ├── SKILL.md          # Required — instructions (pre-filled template)
+    ├── references/       # Optional — reference docs
+    ├── scripts/          # Optional — executable scripts
+    └── assets/           # Optional — static files
+```
+
+### 2. كتابة SKILL.md الخاص بك
+
+```markdown
+---
+name: code-review
+description: Guidelines for conducting thorough code reviews with focus on security and performance.
+metadata:
+  author: your-team
+  version: "1.0"
+---
+
+## إرشادات مراجعة الكود
+
+عند مراجعة الكود، اتبع قائمة التحقق هذه:
+
+1. **الأمان**: تحقق من ثغرات الحقن وتجاوز المصادقة وكشف البيانات
+2. **الأداء**: ابحث عن استعلامات N+1 والتخصيصات غير الضرورية والاستدعاءات المحظورة
+3. **القابلية للقراءة**: تأكد من وضوح التسمية والتعليقات المناسبة والأسلوب المتسق
+4. **الاختبارات**: تحقق من تغطية اختبار كافية للوظائف الجديدة
+
+### مستويات الخطورة
+- **حرج**: ثغرات أمنية، مخاطر فقدان البيانات → حظر الدمج
+- **رئيسي**: مشاكل أداء، أخطاء منطقية → طلب تغييرات
+- **ثانوي**: مسائل أسلوبية، اقتراحات تسمية → الموافقة مع تعليقات
+```
+
+### 3. ربطها بوكيل
+
+```python
+from crewai import Agent
+from crewai_tools import GithubSearchTool, FileReadTool
+
+reviewer = Agent(
+    role="Senior Code Reviewer",
+    goal="Review pull requests for quality and security issues",
+    backstory="Staff engineer with expertise in secure coding practices.",
+    skills=["./skills"],                          # يحقن إرشادات المراجعة
+    tools=[GithubSearchTool(), FileReadTool()],   # يسمح للوكيل بقراءة الكود
+)
+```
+
+الوكيل الآن لديه **خبرة** (من المهارة) و**قدرات** (من الأدوات) معًا.
+
+---
+
+## المهارات + الأدوات: العمل معًا
+
+إليك أنماط شائعة توضح كيف تُكمّل المهارات والأدوات بعضهما:
+
+### النمط 1: مهارات فقط (خبرة المجال، بدون إجراءات مطلوبة)
+
+استخدم عندما يحتاج الوكيل لتعليمات محددة لكن لا يحتاج لاستدعاء خدمات خارجية:
+
+```python
+agent = Agent(
+    role="Technical Writer",
+    goal="Write clear API documentation",
+    backstory="Expert technical writer",
+    skills=["./skills/api-docs-style"],  # إرشادات وقوالب الكتابة
+    # لا حاجة لأدوات — الوكيل يكتب بناءً على السياق المقدم
+)
+```
+
+### النمط 2: أدوات فقط (إجراءات، بدون خبرة خاصة)
+
+استخدم عندما يحتاج الوكيل لاتخاذ إجراءات لكن لا يحتاج لتعليمات مجال محددة:
+
+```python
+from crewai_tools import SerperDevTool, ScrapeWebsiteTool
+
+agent = Agent(
+    role="Web Researcher",
+    goal="Find information about a topic",
+    backstory="Skilled at finding information online",
+    tools=[SerperDevTool(), ScrapeWebsiteTool()],  # يمكنه البحث والاستخراج
+    # لا حاجة لمهارات — البحث العام لا يحتاج إرشادات خاصة
+)
+```
+
+### النمط 3: مهارات + أدوات (خبرة وإجراءات)
+
+النمط الأكثر شيوعًا في العالم الحقيقي. المهارة توفر *كيف* تقترب من العمل؛ الأدوات توفر *ما* يمكن للوكيل فعله:
+
+```python
+from crewai_tools import SerperDevTool, FileReadTool, CodeInterpreterTool
+
+analyst = Agent(
+    role="Security Analyst",
+    goal="Audit infrastructure for vulnerabilities",
+    backstory="Expert in cloud security and compliance",
+    skills=["./skills/security-audit"],   # منهجية وقوائم تحقق التدقيق
+    tools=[
+        SerperDevTool(),                  # البحث عن ثغرات معروفة
+        FileReadTool(),                   # قراءة ملفات التكوين
+        CodeInterpreterTool(),            # تشغيل سكربتات التحليل
+    ],
+)
+```
+
+### النمط 4: مهارات + MCP
+
+المهارات تعمل مع خوادم MCP بنفس الطريقة التي تعمل بها مع الأدوات:
+
+```python
+agent = Agent(
+    role="Data Analyst",
+    goal="Analyze customer data and generate reports",
+    backstory="Expert data analyst with strong statistical background",
+    skills=["./skills/data-analysis"],           # منهجية التحليل
+    mcps=["https://data-warehouse.example.com/sse"],  # وصول بيانات عن بُعد
+)
+```
+
+### النمط 5: مهارات + تطبيقات
+
+المهارات يمكن أن توجّه كيف يستخدم الوكيل تكاملات المنصة:
+
+```python
+agent = Agent(
+    role="Customer Support Agent",
+    goal="Respond to customer inquiries professionally",
+    backstory="Experienced support representative",
+    skills=["./skills/support-playbook"],  # قوالب الردود وقواعد التصعيد
+    apps=["gmail", "zendesk"],             # يمكنه إرسال رسائل بريد وتحديث التذاكر
+)
+```
+
+---
+
+## إنشاء المهارات ونشرها وتثبيتها
+
+للمهارات دورة حياة كاملة تُدار عبر واجهة سطر الأوامر: **أنشئها باستخدام `crewai skill create`، وانشرها باستخدام `crewai skill publish`** — إنشاء المجلدات يدويًا يصلح للتجارب المحلية، لكن واجهة سطر الأوامر هي سير العمل المقصود، وهي تحافظ على صحة هيكل المهارة وبياناتها الوصفية.
+
+### الإنشاء
+
+```shell Terminal
+crewai skill create my-skill
+```
+
+يُنشئ هذا الأمر المجلد (داخل `./skills/` في مشروع الطاقم) مع قالب `SKILL.md`، بالإضافة إلى مجلدات فارغة `scripts/` و `references/` و `assets/`. عدّل `SKILL.md` لتعريف التعليمات.
+
+### النشر
+
+نفّذ الأمر من داخل مجلد المهارة (حيث يوجد `SKILL.md`):
+
+```shell Terminal
+cd skills/my-skill
+crewai skill publish
+```
+
+يقرأ النشر الحقول `name` و `description` و `metadata.version` من البيانات الوصفية في مقدمة `SKILL.md` ويدفع المهارة إلى سجل CrewAI. **المهارات المنشورة تكون دائمًا مقيّدة بنطاق مؤسستك** — مثل الأدوات، لا يستطيع رؤيتها وتثبيتها إلا أعضاء المؤسسة الناشرة؛ ولا توجد رؤية عامة. أعلام مفيدة:
+
+| العلم | التأثير |
+| :--- | :--- |
+| `--org <slug>` | النشر تحت مؤسسة محددة (يتجاوز الإعدادات). |
+| `--force` | تخطي التحقق من حالة git (تغييرات غير مُثبتة، إلخ). |
+
+### التثبيت
+
+ثبّت مهارة منشورة عبر مرجعها `@org/name`:
+
+```shell Terminal
+crewai skill install @acme/code-review
+```
+
+داخل مشروع الطاقم تُثبَّت المهارة في `./skills/{name}/`؛ وخارج المشروع تذهب إلى ذاكرة التخزين المؤقتة المشتركة في `~/.crewai/skills/{org}/{name}/`.
+
+يمكن للوكلاء أيضًا الإشارة إلى مهارات السجل مباشرة — يتم حلّها من ذاكرة التخزين المؤقتة المحلية (أو من مجلد `skills/` في المشروع) وقت التشغيل:
+
+```python
+agent = Agent(
+    role="Senior Code Reviewer",
+    goal="Review pull requests for quality and security issues",
+    backstory="Staff engineer with expertise in secure coding practices.",
+    skills=["@acme/code-review"],  # registry ref, resolved locally
+)
+```
+
+### عرض القائمة
+
+```shell Terminal
+crewai skill list
+```
+
+يعرض المهارات المثبّتة من مجلد المشروع `./skills/` ومن ذاكرة التخزين المؤقتة العامة معًا، مع إصداراتها ومساراتها.
+
+---
+
+## المهارات على مستوى الطاقم
+
+يمكن تعيين المهارات على الطاقم لتُطبّق على **جميع الوكلاء**:
+
+```python
+from crewai import Crew
+
+crew = Crew(
+    agents=[researcher, writer, reviewer],
+    tasks=[research_task, write_task, review_task],
+    skills=["./skills"],  # جميع الوكلاء يحصلون على هذه المهارات
+)
+```
+
+المهارات على مستوى الوكيل لها الأولوية — إذا تم اكتشاف نفس المهارة في كلا المستويين، يتم استخدام نسخة الوكيل.
+
+---
+
+## تنسيق SKILL.md
+
+```markdown
+---
+name: my-skill
+description: وصف قصير لما تفعله هذه المهارة ومتى تُستخدم.
+license: Apache-2.0                    # اختياري
+compatibility: crewai>=0.1.0          # اختياري
+metadata:                              # اختياري
+  author: your-name
+  version: "1.0"
+allowed-tools: web-search file-read   # اختياري، تجريبي
+---
+
+التعليمات للوكيل تُكتب هنا. يتم حقن محتوى Markdown هذا
+في إرشادات الوكيل عند تفعيل المهارة.
+```
+
+### حقول البيانات الوصفية
+
+| الحقل           | مطلوب    | الوصف                                                                    |
+| :-------------- | :------- | :----------------------------------------------------------------------- |
+| `name`          | نعم      | 1-64 حرف. أحرف صغيرة أبجدية رقمية وشرطات. يجب أن يطابق اسم المجلد.     |
+| `description`   | نعم      | 1-1024 حرف. يصف ما تفعله المهارة ومتى تُستخدم.                          |
+| `license`       | لا       | اسم الترخيص أو مرجع لملف ترخيص مضمّن.                                   |
+| `compatibility` | لا       | حد أقصى 500 حرف. متطلبات البيئة (منتجات، حزم، شبكة).                    |
+| `metadata`      | لا       | تعيين مفتاح-قيمة نصي عشوائي.                                            |
+| `allowed-tools` | لا       | قائمة أدوات معتمدة مسبقًا مفصولة بمسافات. تجريبي.                        |
+
+---
+
+## هيكل المجلد
+
+```
+my-skill/
+├── SKILL.md            # مطلوب — البيانات الوصفية + التعليمات
+├── scripts/            # اختياري — سكربتات قابلة للتنفيذ
+├── references/         # اختياري — مستندات مرجعية
+└── assets/             # اختياري — ملفات ثابتة (إعدادات، بيانات)
+```
+
+يجب أن يتطابق اسم المجلد مع حقل `name` في `SKILL.md`. مجلدات `scripts/` و `references/` و `assets/` متاحة في مسار المهارة `path` للوكلاء الذين يحتاجون للإشارة إلى الملفات مباشرة.
+
+---
+
+## المهارات المحمّلة مسبقًا
+
+للمزيد من التحكم، يمكنك اكتشاف المهارات وتفعيلها برمجيًا:
+
+```python
+from pathlib import Path
+from crewai.skills import discover_skills, activate_skill
+
+# اكتشاف جميع المهارات في مجلد
+skills = discover_skills(Path("./skills"))
+
+# تفعيلها (تحميل محتوى SKILL.md الكامل)
+activated = [activate_skill(s) for s in skills]
+
+# تمرير إلى وكيل
+agent = Agent(
+    role="Researcher",
+    goal="Find relevant information",
+    backstory="An expert researcher.",
+    skills=activated,
+)
+```
+
+---
+
+## كيف يتم تحميل المهارات
+
+تستخدم المهارات **الكشف التدريجي** — تحمّل فقط ما هو مطلوب في كل مرحلة:
+
+| المرحلة    | ما يتم تحميله                          | متى                |
+| :--------- | :------------------------------------ | :------------------ |
+| الاكتشاف  | الاسم، الوصف، حقول البيانات الوصفية   | `discover_skills()` |
+| التفعيل   | نص محتوى SKILL.md الكامل              | `activate_skill()`  |
+
+أثناء التنفيذ العادي للوكيل (تمرير مسارات المجلدات عبر `skills=["./skills"]`)، يتم اكتشاف المهارات وتفعيلها تلقائيًا. التحميل التدريجي مهم فقط عند استخدام الواجهة البرمجية.
+
+---
+
+## المهارات مقابل المعرفة
+
+كلا المهارات والمعرفة تُعدّل إرشادات الوكيل، لكنهما يخدمان أغراضًا مختلفة:
+
+| الجانب | المهارات | المعرفة |
+| :--- | :--- | :--- |
+| **ما توفره** | تعليمات، إجراءات، إرشادات | حقائق، بيانات، معلومات |
+| **كيف تُخزّن** | ملفات Markdown (SKILL.md) | مُضمّنة في مخزن متجهي (ChromaDB) |
+| **كيف تُسترجع** | يتم حقن المحتوى الكامل في الإرشادات | البحث الدلالي يجد الأجزاء ذات الصلة |
+| **الأفضل لـ** | المنهجيات، قوائم التحقق، أدلة الأسلوب | مستندات الشركة، معلومات المنتج، بيانات مرجعية |
+| **يُعيّن عبر** | `skills=["./skills"]` | `knowledge_sources=[source]` |
+
+**القاعدة العامة:** إذا كان الوكيل يحتاج لاتباع *عملية*، استخدم مهارة. إذا كان يحتاج للرجوع إلى *بيانات*، استخدم المعرفة.
+
+---
+
+## الأسئلة الشائعة
+
+<AccordionGroup>
+  <Accordion title="هل أحتاج لتعيين المهارات والأدوات معًا؟">
+    يعتمد على حالة الاستخدام. المهارات والأدوات **مستقلتان** — يمكنك استخدام أيّ منهما أو كليهما أو لا شيء.
+
+    - **مهارات فقط**: عندما يحتاج الوكيل خبرة لكن لا يحتاج إجراءات خارجية (مثال: الكتابة بإرشادات أسلوبية)
+    - **أدوات فقط**: عندما يحتاج الوكيل إجراءات لكن لا يحتاج منهجية خاصة (مثال: بحث بسيط على الويب)
+    - **كليهما**: عندما يحتاج الوكيل خبرة وإجراءات (مثال: تدقيق أمني بقوائم تحقق محددة وقدرة على فحص الكود)
+  </Accordion>
+
+  <Accordion title="هل توفر المهارات أدوات تلقائيًا؟">
+    **لا.** حقل `allowed-tools` في SKILL.md هو بيانات وصفية تجريبية فقط — لا يُنشئ أو يحقن أي أدوات. يجب عليك دائمًا تعيين الأدوات بشكل منفصل عبر `tools=[]` أو `mcps=[]` أو `apps=[]`.
+  </Accordion>
+
+  <Accordion title="ماذا يحدث إذا عيّنت نفس المهارة على كل من الوكيل والطاقم؟">
+    المهارة على مستوى الوكيل لها الأولوية. يتم إزالة التكرار حسب الاسم — مهارات الوكيل تُعالج أولاً، لذا إذا ظهر نفس اسم المهارة في كلا المستويين، تُستخدم نسخة الوكيل.
+  </Accordion>
+
+  <Accordion title="ما الحجم الأقصى لمحتوى SKILL.md؟">
+    هناك تحذير ناعم عند 50,000 حرف، لكن بدون حد صارم. حافظ على تركيز المهارات وإيجازها للحصول على أفضل النتائج — الحقن الكبيرة في الإرشادات قد تُشتت انتباه الوكيل.
+  </Accordion>
+</AccordionGroup>

docs/edge/ar/concepts/testing.mdx

@@ -0,0 +1,49 @@
+---
+title: الاختبار
+description: تعرّف على كيفية اختبار طاقم CrewAI وتقييم أدائه.
+icon: vial
+mode: "wide"
+---
+
+## نظرة عامة
+
+يُعد الاختبار جزءًا حيويًا من عملية التطوير، ومن الضروري التأكد من أن طاقمك يعمل كما هو متوقع. مع CrewAI، يمكنك اختبار طاقمك وتقييم أدائه بسهولة باستخدام إمكانيات الاختبار المدمجة.
+
+### استخدام ميزة الاختبار
+
+أضفنا أمر CLI `crewai test` لتسهيل اختبار طاقمك. سيقوم هذا الأمر بتشغيل طاقمك لعدد محدد من التكرارات وتوفير مقاييس أداء مفصلة. المعاملات هي `n_iterations` و `model`، وهي اختيارية وتكون قيمها الافتراضية 2 و `gpt-4o-mini` على التوالي. حاليًا، المزود الوحيد المتاح هو OpenAI.
+
+```bash
+crewai test
+```
+
+إذا أردت تشغيل المزيد من التكرارات أو استخدام نموذج مختلف، يمكنك تحديد المعاملات هكذا:
+
+```bash
+crewai test --n_iterations 5 --model gpt-4o
+```
+
+أو باستخدام الصيغة المختصرة:
+
+```bash
+crewai test -n 5 -m gpt-4o
+```
+
+عند تشغيل أمر `crewai test`، سيتم تنفيذ الطاقم للعدد المحدد من التكرارات، وستُعرض مقاييس الأداء في نهاية التشغيل.
+
+سيظهر جدول الدرجات في النهاية لعرض أداء الطاقم من حيث المقاييس التالية:
+
+<center>**درجات المهام (1-10 الأعلى أفضل)**</center>
+
+| المهام/الطاقم/الوكلاء  | التشغيل 1 | التشغيل 2 | المجموع المتوسط | الوكلاء                         | معلومات إضافية                  |
+|:------------------|:-----:|:-----:|:----------:|:------------------------------:|:---------------------------------|
+| المهمة 1        |  9.0  |  9.5  |    **9.2**     | Professional Insights          |                                  |
+|                    |       |       |            | Researcher                     |                                  |
+| المهمة 2        |  9.0  | 10.0  |    **9.5**     | Company Profile Investigator   |                                  |
+| المهمة 3        |  9.0  |  9.0  |    **9.0**     | Automation Insights            |                                  |
+|                    |       |       |            | Specialist                     |                                  |
+| المهمة 4        |  9.0  |  9.0  |    **9.0**     | Final Report Compiler          | Automation Insights Specialist   |
+| الطاقم         | 9.00  | 9.38  |    **9.2**     |                                |                                  |
+| زمن التنفيذ (ثانية) |  126  |  145  |    **135**     |                                |                                  |
+
+يوضح المثال أعلاه نتائج الاختبار لتشغيلين للطاقم مع مهمتين، مع الدرجة الإجمالية المتوسطة لكل مهمة والطاقم ككل.

docs/edge/ar/concepts/tools.mdx

@@ -0,0 +1,290 @@
+---
+title: الأدوات
+description: فهم واستخدام الأدوات ضمن إطار عمل CrewAI لتعاون الوكلاء وتنفيذ المهام.
+icon: screwdriver-wrench
+mode: "wide"
+---
+
+## نظرة عامة
+
+تُمكّن أدوات CrewAI الوكلاء بقدرات تتراوح من البحث على الويب وتحليل البيانات إلى التعاون وتفويض المهام بين الزملاء.
+توضح هذه الوثائق كيفية إنشاء هذه الأدوات ودمجها والاستفادة منها ضمن إطار عمل CrewAI، بما في ذلك التركيز على أدوات التعاون.
+
+<Note type="info" title="الأدوات هي أحد أنواع قدرات الوكيل الخمسة">
+  الأدوات تمنح الوكلاء **دوال قابلة للاستدعاء** لاتخاذ إجراءات. تعمل جنبًا إلى جنب مع [MCP](/ar/mcp/overview) (خوادم أدوات عن بُعد) و[التطبيقات](/ar/concepts/agent-capabilities) (تكاملات المنصة) و[المهارات](/ar/concepts/skills) (خبرة المجال) و[المعرفة](/ar/concepts/knowledge) (حقائق مُسترجعة). راجع نظرة عامة على [قدرات الوكيل](/ar/concepts/agent-capabilities) لفهم متى تستخدم كل نوع.
+</Note>
+
+## ما هي الأداة؟
+
+الأداة في CrewAI هي مهارة أو وظيفة يمكن للوكلاء استخدامها لأداء إجراءات مختلفة.
+يشمل ذلك أدوات من [مجموعة أدوات CrewAI](https://github.com/joaomdmoura/crewai-tools) و[أدوات LangChain](https://python.langchain.com/docs/integrations/tools)،
+مما يُمكّن كل شيء من عمليات البحث البسيطة إلى التفاعلات المعقدة والعمل الجماعي الفعال بين الوكلاء.
+
+<Note type="info" title="تحسين المؤسسات: مستودع الأدوات">
+يوفر CrewAI AMP مستودع أدوات شامل مع تكاملات جاهزة لأنظمة الأعمال الشائعة وواجهات API. انشر الوكلاء مع أدوات المؤسسة في دقائق بدلاً من أيام.
+
+يتضمن مستودع أدوات المؤسسة:
+
+- موصلات جاهزة لأنظمة المؤسسة الشائعة
+- واجهة إنشاء أدوات مخصصة
+- إمكانيات التحكم في الإصدارات والمشاركة
+- ميزات الأمان والامتثال
+</Note>
+
+## الخصائص الرئيسية للأدوات
+
+- **المنفعة**: مصممة لمهام مثل البحث على الويب وتحليل البيانات وإنشاء المحتوى وتعاون الوكلاء.
+- **التكامل**: تعزز قدرات الوكلاء من خلال دمج الأدوات بسلاسة في سير عملهم.
+- **القابلية للتخصيص**: توفر المرونة لتطوير أدوات مخصصة أو استخدام الأدوات الموجودة، لتلبية الاحتياجات المحددة للوكلاء.
+- **معالجة الأخطاء**: تتضمن آليات معالجة أخطاء قوية لضمان التشغيل السلس.
+- **آلية التخزين المؤقت**: تتميز بتخزين مؤقت ذكي لتحسين الأداء وتقليل العمليات المتكررة.
+- **الدعم غير المتزامن**: تتعامل مع الأدوات المتزامنة وغير المتزامنة، مما يُمكّن العمليات غير الحاجبة.
+
+## استخدام أدوات CrewAI
+
+لتعزيز قدرات وكلائك بأدوات CrewAI، ابدأ بتثبيت حزمة الأدوات الإضافية:
+
+```bash
+pip install 'crewai[tools]'
+```
+
+إليك مثالًا يوضح استخدامها:
+
+```python Code
+import os
+from crewai import Agent, Task, Crew
+# استيراد أدوات crewAI
+from crewai_tools import (
+    DirectoryReadTool,
+    FileReadTool,
+    SerperDevTool,
+    WebsiteSearchTool
+)
+
+# إعداد مفاتيح API
+os.environ["SERPER_API_KEY"] = "Your Key" # serper.dev API key
+os.environ["OPENAI_API_KEY"] = "Your Key"
+
+# إنشاء الأدوات
+docs_tool = DirectoryReadTool(directory='./blog-posts')
+file_tool = FileReadTool()
+search_tool = SerperDevTool()
+web_rag_tool = WebsiteSearchTool()
+
+# إنشاء الوكلاء
+researcher = Agent(
+    role='Market Research Analyst',
+    goal='Provide up-to-date market analysis of the AI industry',
+    backstory='An expert analyst with a keen eye for market trends.',
+    tools=[search_tool, web_rag_tool],
+    verbose=True
+)
+
+writer = Agent(
+    role='Content Writer',
+    goal='Craft engaging blog posts about the AI industry',
+    backstory='A skilled writer with a passion for technology.',
+    tools=[docs_tool, file_tool],
+    verbose=True
+)
+
+# تعريف المهام
+research = Task(
+    description='Research the latest trends in the AI industry and provide a summary.',
+    expected_output='A summary of the top 3 trending developments in the AI industry with a unique perspective on their significance.',
+    agent=researcher
+)
+
+write = Task(
+    description='Write an engaging blog post about the AI industry, based on the research analyst\'s summary. Draw inspiration from the latest blog posts in the directory.',
+    expected_output='A 4-paragraph blog post formatted in markdown with engaging, informative, and accessible content, avoiding complex jargon.',
+    agent=writer,
+    output_file='blog-posts/new_post.md'
+)
+
+# تجميع طاقم مع تفعيل التخطيط
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[research, write],
+    verbose=True,
+    planning=True,
+)
+
+# تنفيذ المهام
+crew.kickoff()
+```
+
+## أدوات CrewAI المتاحة
+
+- **معالجة الأخطاء**: جميع الأدوات مبنية بقدرات معالجة الأخطاء، مما يسمح للوكلاء بإدارة الاستثناءات بسلاسة ومتابعة مهامهم.
+- **آلية التخزين المؤقت**: جميع الأدوات تدعم التخزين المؤقت، مما يُمكّن الوكلاء من إعادة استخدام النتائج المحصلة سابقًا بكفاءة، مما يقلل الحمل على الموارد الخارجية ويسرّع وقت التنفيذ. يمكنك أيضًا تحديد تحكم أدق في آلية التخزين المؤقت باستخدام خاصية `cache_function` على الأداة.
+
+إليك قائمة بالأدوات المتاحة وأوصافها:
+
+| الأداة                             | الوصف                                                                                    |
+| :------------------------------- | :--------------------------------------------------------------------------------------------- |
+| **ApifyActorsTool**              | أداة تدمج Apify Actors مع سير عملك لمهام استخراج البيانات من الويب والأتمتة. |
+| **BrowserbaseLoadTool**          | أداة للتفاعل مع المتصفحات واستخراج البيانات منها.                             |
+| **CodeDocsSearchTool**           | أداة RAG محسّنة للبحث في وثائق الكود والمستندات التقنية ذات الصلة. |
+| **CodeInterpreterTool**          | أداة لتفسير كود Python.                                                           |
+| **ComposioTool**                 | تُمكّن استخدام أدوات Composio.                                                                 |
+| **CSVSearchTool**                | أداة RAG مصممة للبحث في ملفات CSV، مخصصة للتعامل مع البيانات المنظمة.        |
+| **DALL-E Tool**                  | أداة لإنشاء الصور باستخدام DALL-E API.                                             |
+| **DirectorySearchTool**          | أداة RAG للبحث في المجلدات، مفيدة للتنقل في أنظمة الملفات.       |
+| **DOCXSearchTool**               | أداة RAG للبحث في مستندات DOCX، مثالية لمعالجة ملفات Word.          |
+| **DirectoryReadTool**            | تسهّل قراءة ومعالجة هياكل المجلدات ومحتوياتها.                 |
+| **ExaSearchTool**                | أداة مصممة لإجراء عمليات بحث شاملة عبر مصادر بيانات متنوعة.                |
+| **FileReadTool**                 | تُمكّن قراءة واستخراج البيانات من الملفات، مع دعم تنسيقات ملفات متنوعة.               |
+| **FirecrawlSearchTool**          | أداة للبحث في صفحات الويب باستخدام Firecrawl وإرجاع النتائج.                              |
+| **FirecrawlCrawlWebsiteTool**    | أداة لزحف صفحات الويب باستخدام Firecrawl.                                                  |
+| **FirecrawlScrapeWebsiteTool**   | أداة لاستخراج محتوى عناوين URL لصفحات الويب باستخدام Firecrawl.                   |
+| **GithubSearchTool**             | أداة RAG للبحث في مستودعات GitHub، مفيدة لبحث الكود والوثائق. |
+| **SerperDevTool**                | أداة متخصصة لأغراض التطوير، مع وظائف محددة قيد التطوير.  |
+| **TXTSearchTool**                | أداة RAG مركّزة على البحث في ملفات النص (.txt)، مناسبة للبيانات غير المنظمة.      |
+| **JSONSearchTool**               | أداة RAG مصممة للبحث في ملفات JSON، تخدم التعامل مع البيانات المنظمة.     |
+| **LlamaIndexTool**               | تُمكّن استخدام أدوات LlamaIndex.                                                           |
+| **MDXSearchTool**                | أداة RAG مخصصة للبحث في ملفات Markdown (MDX)، مفيدة للوثائق.       |
+| **PDFSearchTool**                | أداة RAG للبحث في مستندات PDF، مثالية لمعالجة المستندات الممسوحة ضوئيًا.    |
+| **PGSearchTool**                 | أداة RAG محسّنة للبحث في قواعد بيانات PostgreSQL، مناسبة لاستعلامات قواعد البيانات. |
+| **Vision Tool**                  | أداة لإنشاء الصور باستخدام DALL-E API.                                             |
+| **RagTool**                      | أداة RAG للأغراض العامة قادرة على التعامل مع مصادر وأنواع بيانات متنوعة.                 |
+| **ScrapeElementFromWebsiteTool** | تُمكّن استخراج عناصر محددة من المواقع، مفيدة لاستخراج البيانات المستهدف.         |
+| **ScrapeWebsiteTool**            | تسهّل استخراج المواقع بالكامل، مثالية لجمع البيانات الشامل.                 |
+| **WebsiteSearchTool**            | أداة RAG للبحث في محتوى المواقع، محسّنة لاستخراج بيانات الويب.                   |
+| **XMLSearchTool**                | أداة RAG مصممة للبحث في ملفات XML، مناسبة لتنسيقات البيانات المنظمة.      |
+| **YoutubeChannelSearchTool**     | أداة RAG للبحث في قنوات YouTube، مفيدة لتحليل محتوى الفيديو.           |
+| **YoutubeVideoSearchTool**       | أداة RAG للبحث في مقاطع فيديو YouTube، مثالية لاستخراج بيانات الفيديو.          |
+
+## إنشاء أدواتك الخاصة
+
+<Tip>
+  يمكن للمطورين إنشاء `أدوات مخصصة` مصممة خصيصًا لاحتياجات وكلائهم أو
+  استخدام الخيارات الجاهزة.
+</Tip>
+
+هناك طريقتان رئيسيتان لإنشاء أداة CrewAI:
+
+### الوراثة من `BaseTool`
+
+```python Code
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
+
+class MyToolInput(BaseModel):
+    """Input schema for MyCustomTool."""
+    argument: str = Field(..., description="Description of the argument.")
+
+class MyCustomTool(BaseTool):
+    name: str = "Name of my tool"
+    description: str = "What this tool does. It's vital for effective utilization."
+    args_schema: Type[BaseModel] = MyToolInput
+
+    def _run(self, argument: str) -> str:
+        # منطق أداتك هنا
+        return "Tool's result"
+```
+
+## دعم الأدوات غير المتزامنة
+
+يدعم CrewAI الأدوات غير المتزامنة، مما يتيح لك تنفيذ أدوات تجري عمليات غير حاجبة مثل طلبات الشبكة وعمليات الإدخال/الإخراج على الملفات أو عمليات async أخرى بدون حجب مسار التنفيذ الرئيسي.
+
+### إنشاء أدوات غير متزامنة
+
+يمكنك إنشاء أدوات غير متزامنة بطريقتين:
+
+#### 1. استخدام مزيّن `tool` مع دوال Async
+
+```python Code
+from crewai.tools import tool
+
+@tool("fetch_data_async")
+async def fetch_data_async(query: str) -> str:
+    """Asynchronously fetch data based on the query."""
+    # محاكاة عملية غير متزامنة
+    await asyncio.sleep(1)
+    return f"Data retrieved for {query}"
+```
+
+#### 2. تنفيذ طرق Async في فئات الأدوات المخصصة
+
+```python Code
+from crewai.tools import BaseTool
+
+class AsyncCustomTool(BaseTool):
+    name: str = "async_custom_tool"
+    description: str = "An asynchronous custom tool"
+
+    async def _run(self, query: str = "") -> str:
+        """Asynchronously run the tool"""
+        # تنفيذك غير المتزامن هنا
+        await asyncio.sleep(1)
+        return f"Processed {query} asynchronously"
+```
+
+### استخدام الأدوات غير المتزامنة
+
+تعمل الأدوات غير المتزامنة بسلاسة في كل من سير عمل الطاقم القياسي وسير عمل التدفق:
+
+```python Code
+# في طاقم قياسي
+agent = Agent(role="researcher", tools=[async_custom_tool])
+
+# في تدفق
+class MyFlow(Flow):
+    @start()
+    async def begin(self):
+        crew = Crew(agents=[agent])
+        result = await crew.kickoff_async()
+        return result
+```
+
+يتعامل إطار عمل CrewAI تلقائيًا مع تنفيذ الأدوات المتزامنة وغير المتزامنة، لذا لا تحتاج للقلق بشأن كيفية استدعائها بشكل مختلف.
+
+### استخدام مزيّن `tool`
+
+```python Code
+from crewai.tools import tool
+@tool("Name of my tool")
+def my_tool(question: str) -> str:
+    """Clear description for what this tool is useful for, your agent will need this information to use it."""
+    # منطق الدالة هنا
+    return "Result from your custom tool"
+```
+
+### آلية التخزين المؤقت المخصصة
+
+<Tip>
+  يمكن للأدوات اختياريًا تنفيذ `cache_function` لضبط سلوك
+  التخزين المؤقت. تحدد هذه الدالة متى يتم تخزين النتائج مؤقتًا بناءً على شروط
+  محددة، مما يوفر تحكمًا دقيقًا في منطق التخزين المؤقت.
+</Tip>
+
+```python Code
+from crewai.tools import tool
+
+@tool
+def multiplication_tool(first_number: int, second_number: int) -> str:
+    """Useful for when you need to multiply two numbers together."""
+    return first_number * second_number
+
+def cache_func(args, result):
+    # في هذه الحالة، نخزّن النتيجة مؤقتًا فقط إذا كانت من مضاعفات 2
+    cache = result % 2 == 0
+    return cache
+
+multiplication_tool.cache_function = cache_func
+
+writer1 = Agent(
+        role="Writer",
+        goal="You write lessons of math for kids.",
+        backstory="You're an expert in writing and you love to teach kids but you know nothing of math.",
+        tools=[multiplication_tool],
+        allow_delegation=False,
+    )
+    #...
+```
+
+## الخلاصة
+
+الأدوات محورية في توسيع قدرات وكلاء CrewAI، مما يمكّنهم من تنفيذ مجموعة واسعة من المهام والتعاون بفعالية.
+عند بناء حلول مع CrewAI، استفد من كل من الأدوات المخصصة والموجودة لتمكين وكلائك وتعزيز نظام الذكاء الاصطناعي البيئي. فكّر في استخدام معالجة الأخطاء وآليات التخزين المؤقت ومرونة معاملات الأدوات لتحسين أداء وقدرات وكلائك.

docs/edge/ar/concepts/training.mdx

@@ -0,0 +1,197 @@
+---
+title: التدريب
+description: تعرّف على كيفية تدريب وكلاء CrewAI من خلال تقديم ملاحظات مبكرة والحصول على نتائج متسقة.
+icon: dumbbell
+mode: "wide"
+---
+
+## نظرة عامة
+
+تتيح لك ميزة التدريب في CrewAI تدريب وكلاء الذكاء الاصطناعي باستخدام واجهة سطر الأوامر (CLI).
+بتشغيل الأمر `crewai train -n <n_iterations>`، يمكنك تحديد عدد التكرارات لعملية التدريب.
+
+أثناء التدريب، يستخدم CrewAI تقنيات لتحسين أداء وكلائك مع التغذية الراجعة البشرية.
+يساعد هذا الوكلاء على تحسين فهمهم واتخاذ القرارات وحل المشكلات.
+
+### تدريب طاقمك باستخدام CLI
+
+لاستخدام ميزة التدريب، اتبع الخطوات التالية:
+
+1. افتح الطرفية أو موجه الأوامر.
+2. انتقل إلى المجلد حيث يقع مشروع CrewAI.
+3. شغّل الأمر التالي:
+
+```shell
+crewai train -n <n_iterations> -f <filename.pkl>
+```
+<Tip>
+  استبدل `<n_iterations>` بعدد تكرارات التدريب المرغوب و`<filename>` باسم الملف المناسب المنتهي بـ `.pkl`.
+</Tip>
+
+<Note>
+  إذا حذفت `-f`، فإن المخرجات تُحفظ افتراضيًا في `trained_agents_data.pkl` في مجلد العمل الحالي. يمكنك تمرير مسار مطلق للتحكم في مكان كتابة الملف.
+</Note>
+
+### تدريب طاقمك برمجيًا
+
+لتدريب طاقمك برمجيًا، استخدم الخطوات التالية:
+
+1. حدد عدد التكرارات للتدريب.
+2. حدد معاملات الإدخال لعملية التدريب.
+3. نفّذ أمر التدريب داخل كتلة try-except للتعامل مع الأخطاء المحتملة.
+
+```python Code
+n_iterations = 2
+inputs = {"topic": "CrewAI Training"}
+filename = "your_model.pkl"
+
+try:
+    YourCrewName_Crew().crew().train(
+      n_iterations=n_iterations,
+      inputs=inputs,
+      filename=filename
+    )
+
+except Exception as e:
+    raise Exception(f"An error occurred while training the crew: {e}")
+```
+
+## كيف تُستخدم بيانات التدريب من قبل الوكلاء
+
+يستخدم CrewAI مخرجات التدريب بطريقتين: أثناء التدريب لدمج ملاحظاتك البشرية، وبعد التدريب لتوجيه الوكلاء باقتراحات موحدة.
+
+### تدفق بيانات التدريب
+
+```mermaid
+flowchart TD
+  A["Start training<br/>CLI: crewai train -n -f<br/>or Python: crew.train(...)"] --> B["Setup training mode<br/>- task.human_input = true<br/>- disable delegation<br/>- init training_data.pkl + trained file"]
+
+  subgraph "Iterations"
+    direction LR
+    C["Iteration i<br/>initial_output"] --> D["User human_feedback"]
+    D --> E["improved_output"]
+    E --> F["Append to training_data.pkl<br/>by agent_id and iteration"]
+  end
+
+  B --> C
+  F --> G{"More iterations?"}
+  G -- "Yes" --> C
+  G -- "No" --> H["Evaluate per agent<br/>aggregate iterations"]
+
+  H --> I["Consolidate<br/>suggestions[] + quality + final_summary"]
+  I --> J["Save by agent role to trained file<br/>(default: trained_agents_data.pkl)"]
+
+  J --> K["Normal (non-training) runs"]
+  K --> L["Auto-load suggestions<br/>from trained_agents_data.pkl"]
+  L --> M["Append to prompt<br/>for consistent improvements"]
+```
+
+### أثناء تشغيلات التدريب
+
+- في كل تكرار، يسجل النظام لكل وكيل:
+  - `initial_output`: الإجابة الأولى للوكيل
+  - `human_feedback`: ملاحظاتك المضمّنة عند الطلب
+  - `improved_output`: إجابة المتابعة للوكيل بعد الملاحظات
+- تُخزن هذه البيانات في ملف عمل باسم `training_data.pkl` مفهرس بمعرّف الوكيل الداخلي والتكرار.
+- أثناء نشاط التدريب، يُلحق الوكيل تلقائيًا ملاحظاتك البشرية السابقة بأمره لتطبيق تلك التعليمات في المحاولات اللاحقة ضمن جلسة التدريب.
+  التدريب تفاعلي: تُعيّن المهام `human_input = true`، لذا سيتوقف التشغيل في بيئة غير تفاعلية بانتظار مدخلات المستخدم.
+
+### بعد اكتمال التدريب
+
+- عند انتهاء `train(...)`، يقيّم CrewAI بيانات التدريب المجمعة لكل وكيل وينتج نتيجة موحدة تحتوي على:
+  - `suggestions`: تعليمات واضحة وقابلة للتنفيذ مستخلصة من ملاحظاتك والفرق بين المخرجات الأولية/المحسنة
+  - `quality`: درجة من 0-10 تعكس التحسن
+  - `final_summary`: مجموعة خطوات عمل تفصيلية للمهام المستقبلية
+- تُحفظ هذه النتائج الموحدة في اسم الملف الذي تمرره إلى `train(...)` (الافتراضي عبر CLI هو `trained_agents_data.pkl`). تُفهرس الإدخالات بدور الوكيل `role` لتطبيقها عبر الجلسات.
+- أثناء التنفيذ العادي (غير التدريب)، يحمّل كل وكيل تلقائيًا `suggestions` الموحدة ويلحقها بأمر المهمة كتعليمات إلزامية. يمنحك هذا تحسينات متسقة بدون تغيير تعريفات الوكلاء.
+
+### ملخص الملفات
+
+- `training_data.pkl` (مؤقت، لكل جلسة):
+  - الهيكل: `agent_id -> { iteration_number: { initial_output, human_feedback, improved_output } }`
+  - الغرض: التقاط البيانات الخام والملاحظات البشرية أثناء التدريب
+  - الموقع: يُحفظ في مجلد العمل الحالي (CWD)
+- `trained_agents_data.pkl` (أو اسم ملفك المخصص):
+  - الهيكل: `agent_role -> { suggestions: string[], quality: number, final_summary: string }`
+  - الغرض: استمرار التوجيه الموحد للتشغيلات المستقبلية
+  - الموقع: يُكتب في CWD افتراضيًا؛ استخدم `-f` لتعيين مسار مخصص (بما في ذلك المطلق)
+
+## اعتبارات نماذج اللغة الصغيرة
+
+<Warning>
+  عند استخدام نماذج لغة أصغر (≤7 مليار معامل) لتقييم بيانات التدريب، كن على علم أنها قد تواجه تحديات في إنتاج مخرجات منظمة واتباع التعليمات المعقدة.
+</Warning>
+
+### قيود النماذج الصغيرة في تقييم التدريب
+
+<CardGroup cols={2}>
+  <Card title="دقة مخرجات JSON" icon="triangle-exclamation">
+    غالبًا ما تواجه النماذج الأصغر صعوبة في إنتاج استجابات JSON صالحة مطلوبة لتقييمات التدريب المنظمة، مما يؤدي إلى أخطاء تحليل وبيانات غير مكتملة.
+  </Card>
+  <Card title="جودة التقييم" icon="chart-line">
+    قد توفر النماذج تحت 7 مليار معامل تقييمات أقل دقة مع عمق استدلال محدود مقارنة بالنماذج الأكبر.
+  </Card>
+  <Card title="اتباع التعليمات" icon="list-check">
+    قد لا تُتبع معايير تقييم التدريب المعقدة بالكامل أو تُراعى من قبل النماذج الأصغر.
+  </Card>
+  <Card title="الاتساق" icon="rotate">
+    قد تفتقر التقييمات عبر تكرارات تدريب متعددة إلى الاتساق مع النماذج الأصغر.
+  </Card>
+</CardGroup>
+
+### توصيات للتدريب
+
+<Tabs>
+  <Tab title="أفضل ممارسة">
+    لجودة تدريب مثالية وتقييمات موثوقة، نوصي بشدة باستخدام نماذج بحد أدنى 7 مليار معامل أو أكبر:
+
+    ```python
+    from crewai import Agent, Crew, Task, LLM
+
+    # الحد الأدنى الموصى به لتقييم التدريب
+    llm = LLM(model="mistral/open-mistral-7b")
+
+    # خيارات أفضل لتقييم تدريب موثوق
+    llm = LLM(model="anthropic/claude-3-sonnet-20240229-v1:0")
+    llm = LLM(model="gpt-4o")
+
+    # استخدم هذا LLM مع وكلائك
+    agent = Agent(
+        role="Training Evaluator",
+        goal="Provide accurate training feedback",
+        llm=llm
+    )
+    ```
+
+    <Tip>
+      توفر النماذج الأكثر قوة ملاحظات أعلى جودة مع استدلال أفضل، مما يؤدي إلى تكرارات تدريب أكثر فعالية.
+    </Tip>
+  </Tab>
+  <Tab title="استخدام النماذج الصغيرة">
+    إذا كان يجب عليك استخدام نماذج أصغر لتقييم التدريب، كن على علم بهذه القيود:
+
+    ```python
+    # استخدام نموذج أصغر (توقع بعض القيود)
+    llm = LLM(model="huggingface/microsoft/Phi-3-mini-4k-instruct")
+    ```
+
+    <Warning>
+      بينما يتضمن CrewAI تحسينات للنماذج الصغيرة، توقع نتائج تقييم أقل موثوقية ودقة قد تتطلب تدخلاً بشريًا أكبر أثناء التدريب.
+    </Warning>
+  </Tab>
+</Tabs>
+
+### نقاط مهمة يجب ملاحظتها
+
+- **متطلب العدد الصحيح الموجب:** تأكد من أن عدد التكرارات (`n_iterations`) هو عدد صحيح موجب. سيرمي الكود `ValueError` إذا لم يتحقق هذا الشرط.
+- **متطلب اسم الملف:** تأكد من أن اسم الملف ينتهي بـ `.pkl`. سيرمي الكود `ValueError` إذا لم يتحقق هذا الشرط.
+- **معالجة الأخطاء:** يتعامل الكود مع أخطاء العمليات الفرعية والاستثناءات غير المتوقعة، ويوفر رسائل خطأ للمستخدم.
+- يُطبق التوجيه المدرّب في وقت الأمر؛ لا يعدّل تهيئة وكيل Python/YAML.
+- يحمّل الوكلاء تلقائيًا الاقتراحات المدربة من ملف باسم `trained_agents_data.pkl` الموجود في مجلد العمل الحالي. إذا درّبت إلى اسم ملف مختلف، أعد تسميته إلى `trained_agents_data.pkl` قبل التشغيل، أو اضبط المحمّل في الكود.
+- يمكنك تغيير اسم ملف المخرجات عند استدعاء `crewai train` بـ `-f/--filename`. المسارات المطلقة مدعومة إذا أردت الحفظ خارج CWD.
+
+من المهم ملاحظة أن عملية التدريب قد تستغرق بعض الوقت، اعتمادًا على تعقيد وكلائك وستتطلب أيضًا ملاحظاتك في كل تكرار.
+
+بمجرد اكتمال التدريب، سيكون وكلاؤك مجهزين بقدرات ومعرفة محسّنة، وجاهزين لمعالجة المهام المعقدة وتقديم رؤى أكثر اتساقًا وقيمة.
+
+تذكر تحديث وإعادة تدريب وكلائك بانتظام لضمان بقائهم على اطلاع بأحدث المعلومات والتطورات في المجال.

docs/edge/ar/examples/cookbooks.mdx

@@ -0,0 +1,49 @@
+---
+title: كتب وصفات CrewAI
+description: بدايات سريعة ودفاتر ملاحظات مركّزة على الميزات لتعلم الأنماط بسرعة.
+icon: book
+mode: "wide"
+---
+
+## بدايات سريعة وعروض توضيحية
+
+<CardGroup cols={3}>
+  <Card title="التعاون" icon="people-arrows" href="https://github.com/crewAIInc/crewAI-quickstarts/blob/main/Collaboration/crewai_collaboration.ipynb">
+    تنسيق عدة Agents على مهام مشتركة. يتضمن دفتر ملاحظات بنمط تعاون شامل.
+  </Card>
+
+  <Card title="التخطيط" icon="timeline" href="https://github.com/crewAIInc/crewAI-quickstarts/blob/main/Planning/crewai_planning.ipynb">
+    تعليم الـ Agents التفكير في خطط متعددة المراحل قبل التنفيذ باستخدام أدوات التخطيط.
+  </Card>
+
+  <Card title="الاستدلال" icon="lightbulb" href="https://github.com/crewAIInc/crewAI-quickstarts/blob/main/Reasoning/crewai_reasoning.ipynb">
+    استكشاف حلقات التأمل الذاتي، ومطالبات النقد، وأنماط التفكير المنظم.
+  </Card>
+</CardGroup>
+
+<CardGroup cols={3}>
+  <Card title="حواجز الحماية المنظمة" icon="shield-check" href="https://github.com/crewAIInc/crewAI-quickstarts/blob/main/Guardrails/task_guardrails.ipynb">
+    تطبيق حواجز حماية على مستوى المهام مع إعادة المحاولة ودوال التحقق والبدائل الآمنة.
+  </Card>
+
+  <Card title="بحث وتأريض Gemini" icon="magnifying-glass" href="https://github.com/crewAIInc/crewAI-quickstarts/blob/main/Custom%20LLM/gemini_search_grounding_crewai.ipynb">
+    ربط CrewAI بـ Gemini مع تأريض البحث للحصول على مخرجات واقعية غنية بالاستشهادات.
+  </Card>
+
+  <Card title="ملخصات فيديو Gemini" icon="video" href="https://github.com/crewAIInc/crewAI-quickstarts/blob/main/Custom%20LLM/summarize_video_gemini_crewai.ipynb">
+    إنشاء ملخصات فيديو باستخدام نموذج Gemini متعدد الوسائط وتنسيق CrewAI.
+  </Card>
+</CardGroup>
+
+<CardGroup cols={2}>
+  <Card title="تصفح البدايات السريعة" icon="bolt" href="https://github.com/crewAIInc/crewAI-quickstarts">
+    عرض جميع دفاتر الملاحظات والعروض التوضيحية التي تستعرض إمكانيات CrewAI المحددة.
+  </Card>
+  <Card title="اطلب كتاب وصفات" icon="message-plus" href="https://community.crewai.com">
+    هل يفتقد نمط معين؟ أرسل طلبًا في منتدى المجتمع وسنوسّع المكتبة.
+  </Card>
+</CardGroup>
+
+<Tip>
+استخدم كتب الوصفات لتعلم نمط بسرعة، ثم انتقل إلى الأمثلة الكاملة للتطبيقات الجاهزة للإنتاج.
+</Tip>

docs/edge/ar/examples/example.mdx

@@ -0,0 +1,86 @@
+---
+title: أمثلة CrewAI
+description: استكشف أمثلة منسّقة مرتبة حسب Crews وFlows والتكاملات ودفاتر الملاحظات.
+icon: rocket-launch
+mode: "wide"
+---
+
+## Crews
+
+<CardGroup cols={3}>
+  <Card title="استراتيجية التسويق" icon="bullhorn" href="https://github.com/crewAIInc/crewAI-examples/tree/main/crews/marketing_strategy">
+    تخطيط حملات تسويقية متعددة الـ Agents.
+  </Card>
+  <Card title="رحلة مفاجئة" icon="plane" href="https://github.com/crewAIInc/crewAI-examples/tree/main/crews/surprise_trip">
+    تخطيط رحلات مفاجئة مخصصة.
+  </Card>
+  <Card title="مطابقة الملف الشخصي بالوظائف" icon="id-card" href="https://github.com/crewAIInc/crewAI-examples/tree/main/crews/match_profile_to_positions">
+    مطابقة السيرة الذاتية بالوظائف باستخدام البحث المتجهي.
+  </Card>
+  <Card title="نشر وظيفة" icon="newspaper" href="https://github.com/crewAIInc/crewAI-examples/tree/main/crews/job-posting">
+    إنشاء أوصاف وظيفية آلية.
+  </Card>
+  <Card title="فريق بناء الألعاب" icon="gamepad" href="https://github.com/crewAIInc/crewAI-examples/tree/main/crews/game-builder-crew">
+    فريق متعدد الـ Agents يصمم ويبني ألعاب Python.
+  </Card>
+  <Card title="التوظيف" icon="user-group" href="https://github.com/crewAIInc/crewAI-examples/tree/main/crews/recruitment">
+    استقطاب المرشحين وتقييمهم.
+  </Card>
+  <Card title="تصفح جميع الـ Crews" icon="users" href="https://github.com/crewAIInc/crewAI-examples/tree/main/crews">
+    عرض القائمة الكاملة لأمثلة الـ Crews.
+  </Card>
+</CardGroup>
+
+## Flows
+
+<CardGroup cols={3}>
+  <Card title="Flow إنشاء المحتوى" icon="pen" href="https://github.com/crewAIInc/crewAI-examples/tree/main/flows/content_creator_flow">
+    إنشاء محتوى متعدد الـ Crews مع التوجيه.
+  </Card>
+  <Card title="الرد التلقائي على البريد الإلكتروني" icon="envelope" href="https://github.com/crewAIInc/crewAI-examples/tree/main/flows/email_auto_responder_flow">
+    مراقبة البريد الإلكتروني والرد الآلي.
+  </Card>
+  <Card title="Flow تقييم العملاء المحتملين" icon="chart-line" href="https://github.com/crewAIInc/crewAI-examples/tree/main/flows/lead_score_flow">
+    تأهيل العملاء المحتملين مع تدخل بشري.
+  </Card>
+  <Card title="Flow مساعد الاجتماعات" icon="calendar" href="https://github.com/crewAIInc/crewAI-examples/tree/main/flows/meeting_assistant_flow">
+    معالجة الملاحظات مع التكاملات.
+  </Card>
+  <Card title="حلقة التقييم الذاتي" icon="rotate" href="https://github.com/crewAIInc/crewAI-examples/tree/main/flows/self_evaluation_loop_flow">
+    سير عمل التحسين الذاتي التكراري.
+  </Card>
+  <Card title="كتابة كتاب (Flows)" icon="book" href="https://github.com/crewAIInc/crewAI-examples/tree/main/flows/write_a_book_with_flows">
+    إنشاء الفصول بالتوازي.
+  </Card>
+  <Card title="تصفح جميع الـ Flows" icon="diagram-project" href="https://github.com/crewAIInc/crewAI-examples/tree/main/flows">
+    عرض القائمة الكاملة لأمثلة الـ Flows.
+  </Card>
+</CardGroup>
+
+## التكاملات
+
+<CardGroup cols={3}>
+  <Card title="CrewAI ↔ LangGraph" icon="link" href="https://github.com/crewAIInc/crewAI-examples/tree/main/integrations/crewai-langgraph">
+    التكامل مع إطار عمل LangGraph.
+  </Card>
+  <Card title="Azure OpenAI" icon="cloud" href="https://github.com/crewAIInc/crewAI-examples/tree/main/integrations/azure_model">
+    استخدام CrewAI مع Azure OpenAI.
+  </Card>
+  <Card title="نماذج NVIDIA" icon="microchip" href="https://github.com/crewAIInc/crewAI-examples/tree/main/integrations/nvidia_models">
+    تكاملات منظومة NVIDIA.
+  </Card>
+  <Card title="تصفح التكاملات" icon="puzzle-piece" href="https://github.com/crewAIInc/crewAI-examples/tree/main/integrations">
+    عرض جميع أمثلة التكاملات.
+  </Card>
+</CardGroup>
+
+## دفاتر الملاحظات
+
+<CardGroup cols={2}>
+  <Card title="Simple QA Crew + Flow" icon="book" href="https://github.com/crewAIInc/crewAI-examples/tree/main/Notebooks/Simple%20QA%20Crew%20%2B%20Flow">
+    Simple QA Crew + Flow.
+  </Card>
+  <Card title="جميع دفاتر الملاحظات" icon="book" href="https://github.com/crewAIInc/crewAI-examples/tree/main/Notebooks">
+    أمثلة تفاعلية للتعلم والتجريب.
+  </Card>
+</CardGroup>

docs/edge/ar/guides/advanced/customizing-prompts.mdx

@@ -0,0 +1,331 @@
+---
+title: تخصيص المطالبات
+description: تعمّق في تخصيص المطالبات على المستوى المنخفض في CrewAI، مما يتيح حالات استخدام مخصصة ومعقدة لنماذج ولغات مختلفة.
+icon: message-pen
+mode: "wide"
+---
+
+## لماذا نخصص المطالبات؟
+
+على الرغم من أن مطالبات CrewAI الافتراضية تعمل بشكل جيد في كثير من السيناريوهات، إلا أن التخصيص على المستوى المنخفض يفتح الباب أمام سلوك أكثر مرونة وقوة للـ Agent. إليك لماذا قد ترغب في الاستفادة من هذا التحكم العميق:
+
+1. **التحسين لنماذج LLM محددة** – تزدهر النماذج المختلفة (مثل GPT-4 وClaude وLlama) مع تنسيقات مطالبات مصممة لبنيتها الفريدة.
+2. **تغيير اللغة** – بناء Agents تعمل حصريًا بلغات غير الإنجليزية مع التعامل مع الفروق الدقيقة بدقة.
+3. **التخصص في مجالات معقدة** – تكييف المطالبات لصناعات متخصصة للغاية مثل الرعاية الصحية والمالية والقانون.
+4. **ضبط النبرة والأسلوب** – جعل الـ Agents أكثر رسمية أو عفوية أو إبداعية أو تحليلية.
+5. **دعم حالات استخدام مخصصة للغاية** – استخدام هياكل وتنسيقات مطالبات متقدمة لتلبية متطلبات معقدة خاصة بالمشروع.
+
+يستكشف هذا الدليل كيفية الوصول إلى مطالبات CrewAI على مستوى أعمق، مما يمنحك تحكمًا دقيقًا في كيفية تفكير الـ Agents وتفاعلها.
+
+## فهم نظام المطالبات في CrewAI
+
+تحت الغطاء، يستخدم CrewAI نظام مطالبات معياري يمكنك تخصيصه على نطاق واسع:
+
+- **قوالب الـ Agent** – تحكم في نهج كل Agent تجاه دوره المعيّن.
+- **شرائح المطالبات** – تتحكم في السلوكيات المتخصصة مثل المهام واستخدام الأدوات وهيكل المخرجات.
+- **معالجة الأخطاء** – توجيه كيفية استجابة الـ Agents للإخفاقات والاستثناءات وحالات انتهاء المهلة.
+- **مطالبات خاصة بالأدوات** – تعريف تعليمات مفصلة لكيفية استدعاء الأدوات أو استخدامها.
+
+اطلع على [قوالب المطالبات الأصلية في مستودع CrewAI](https://github.com/crewAIInc/crewAI/blob/main/src/crewai/translations/en.json) لمعرفة كيفية تنظيم هذه العناصر. من هناك، يمكنك تجاوزها أو تكييفها حسب الحاجة لفتح سلوكيات متقدمة.
+
+## فهم تعليمات النظام الافتراضية
+
+<Warning>
+**مشكلة شفافية الإنتاج**: يحقن CrewAI تلقائيًا تعليمات افتراضية في مطالباتك قد لا تكون على علم بها. يشرح هذا القسم ما يحدث تحت الغطاء وكيفية الحصول على تحكم كامل.
+</Warning>
+
+عندما تعرّف Agent بـ `role` و`goal` و`backstory`، يضيف CrewAI تلقائيًا تعليمات نظام إضافية تتحكم في التنسيق والسلوك. فهم هذه الحقن الافتراضية أمر بالغ الأهمية لأنظمة الإنتاج التي تحتاج شفافية كاملة في المطالبات.
+
+### ما يحقنه CrewAI تلقائيًا
+
+بناءً على تهيئة الـ Agent، يضيف CrewAI تعليمات افتراضية مختلفة:
+
+#### للـ Agents بدون أدوات
+```text
+"I MUST use these formats, my job depends on it!"
+```
+
+#### للـ Agents مع أدوات
+```text
+"IMPORTANT: Use the following format in your response:
+
+Thought: you should always think about what to do
+Action: the action to take, only one name of [tool_names]
+Action Input: the input to the action, just a simple JSON object...
+```
+
+#### للمخرجات المنظمة (JSON/Pydantic)
+```text
+"Ensure your final answer contains only the content in the following format: {output_format}
+Ensure the final output does not include any code block markers like ```json or ```python."
+```
+
+### عرض مطالبة النظام الكاملة
+
+لمعرفة المطالبة المرسلة بالضبط إلى LLM، يمكنك فحص المطالبة المولّدة:
+
+```python
+from crewai import Agent, Crew, Task
+from crewai.utilities.prompts import Prompts
+
+# Create your agent
+agent = Agent(
+    role="Data Analyst",
+    goal="Analyze data and provide insights",
+    backstory="You are an expert data analyst with 10 years of experience.",
+    verbose=True
+)
+
+# Create a sample task
+task = Task(
+    description="Analyze the sales data and identify trends",
+    expected_output="A detailed analysis with key insights and trends",
+    agent=agent
+)
+
+# Create the prompt generator
+prompt_generator = Prompts(
+    agent=agent,
+    has_tools=len(agent.tools) > 0,
+    use_system_prompt=agent.use_system_prompt
+)
+
+# Generate and inspect the actual prompt
+generated_prompt = prompt_generator.task_execution()
+
+# Print the complete system prompt that will be sent to the LLM
+if "system" in generated_prompt:
+    print("=== SYSTEM PROMPT ===")
+    print(generated_prompt["system"])
+    print("\n=== USER PROMPT ===")
+    print(generated_prompt["user"])
+else:
+    print("=== COMPLETE PROMPT ===")
+    print(generated_prompt["prompt"])
+
+# You can also see how the task description gets formatted
+print("\n=== TASK CONTEXT ===")
+print(f"Task Description: {task.description}")
+print(f"Expected Output: {task.expected_output}")
+```
+
+### تجاوز التعليمات الافتراضية
+
+لديك عدة خيارات للحصول على تحكم كامل في المطالبات:
+
+#### الخيار 1: القوالب المخصصة (مُوصى به)
+```python
+from crewai import Agent
+
+# Define your own system template without default instructions
+custom_system_template = """You are {role}. {backstory}
+Your goal is: {goal}
+
+Respond naturally and conversationally. Focus on providing helpful, accurate information."""
+
+custom_prompt_template = """Task: {input}
+
+Please complete this task thoughtfully."""
+
+agent = Agent(
+    role="Research Assistant",
+    goal="Help users find accurate information",
+    backstory="You are a helpful research assistant.",
+    system_template=custom_system_template,
+    prompt_template=custom_prompt_template,
+    use_system_prompt=True  # Use separate system/user messages
+)
+```
+
+#### الخيار 2: ملف مطالبات مخصص
+أنشئ ملف `custom_prompts.json` لتجاوز شرائح مطالبات محددة:
+
+```json
+{
+  "slices": {
+    "no_tools": "\nProvide your best answer in a natural, conversational way.",
+    "tools": "\nYou have access to these tools: {tools}\n\nUse them when helpful, but respond naturally.",
+    "formatted_task_instructions": "Format your response as: {output_format}"
+  }
+}
+```
+
+ثم استخدمه في Crew:
+
+```python
+crew = Crew(
+    agents=[agent],
+    tasks=[task],
+    prompt_file="custom_prompts.json",
+    verbose=True
+)
+```
+
+<Note>
+يُحتفظ بـ `agent.i18n` للتوافق مع الإصدارات السابقة فقط، وقد تم إهماله. لتخصيص المطالبات أثناء التشغيل، مرّر `prompt_file` إلى `Crew`. وللوصول البرمجي المباشر إلى شرائح المطالبات، استخدم أداة i18n مباشرة:
+</Note>
+
+```python
+from crewai.utilities.i18n import get_i18n
+
+i18n = get_i18n("custom_prompts.json")
+format_slice = i18n.slice("format")
+tool_prompt = i18n.tools("ask_question")
+```
+
+#### الخيار 3: تعطيل مطالبات النظام لنماذج o1
+```python
+agent = Agent(
+    role="Analyst",
+    goal="Analyze data",
+    backstory="Expert analyst",
+    use_system_prompt=False  # Disables system prompt separation
+)
+```
+
+### التصحيح باستخدام أدوات المراقبة
+
+لشفافية الإنتاج، استخدم منصات المراقبة لمتابعة جميع المطالبات وتفاعلات LLM. يتيح لك ذلك رؤية المطالبات المرسلة بالضبط (بما في ذلك التعليمات الافتراضية) إلى نماذج LLM.
+
+راجع [توثيق المراقبة](/ar/observability/overview) للحصول على أدلة تكامل مفصلة مع منصات متعددة بما في ذلك Langfuse وMLflow وWeights & Biases وحلول التسجيل المخصصة.
+
+### أفضل الممارسات للإنتاج
+
+1. **افحص المطالبات المولّدة دائمًا** قبل النشر في الإنتاج
+2. **استخدم قوالب مخصصة** عندما تحتاج تحكمًا كاملاً في محتوى المطالبات
+3. **دمج أدوات المراقبة** للمتابعة المستمرة للمطالبات (راجع [توثيق المراقبة](/ar/observability/overview))
+4. **اختبر مع نماذج LLM مختلفة** حيث قد تعمل التعليمات الافتراضية بشكل مختلف عبر النماذج
+5. **وثّق تخصيصات المطالبات** لشفافية الفريق
+
+<Tip>
+التعليمات الافتراضية موجودة لضمان سلوك Agent متسق، لكنها قد تتعارض مع المتطلبات الخاصة بالمجال. استخدم خيارات التخصيص أعلاه للحفاظ على تحكم كامل في سلوك Agent في أنظمة الإنتاج.
+</Tip>
+
+## أفضل الممارسات لإدارة ملفات المطالبات
+
+عند الانخراط في تخصيص المطالبات على المستوى المنخفض، اتبع هذه الإرشادات للحفاظ على التنظيم وسهولة الصيانة:
+
+1. **احتفظ بالملفات منفصلة** – خزّن المطالبات المخصصة في ملفات JSON مخصصة خارج قاعدة الكود الرئيسية.
+2. **التحكم في الإصدارات** – تتبع التغييرات داخل المستودع مع ضمان توثيق واضح لتعديلات المطالبات بمرور الوقت.
+3. **التنظيم حسب النموذج أو اللغة** – استخدم تسميات مثل `prompts_llama.json` أو `prompts_es.json` لتحديد التهيئات المتخصصة بسرعة.
+4. **توثيق التغييرات** – قدم تعليقات أو حافظ على ملف يوضح غرض ونطاق تخصيصاتك.
+5. **قلل التعديلات** – تجاوز فقط الشرائح المحددة التي تحتاج حقًا لتعديلها مع الحفاظ على الوظائف الافتراضية لكل شيء آخر.
+
+## أبسط طريقة لتخصيص المطالبات
+
+إحدى الطرق المباشرة هي إنشاء ملف JSON للمطالبات التي تريد تجاوزها ثم توجيه Crew إلى ذلك الملف:
+
+1. أنشئ ملف JSON بشرائح المطالبات المحدّثة.
+2. أشر إلى ذلك الملف عبر معامل `prompt_file` في Crew.
+
+يدمج CrewAI بعد ذلك تخصيصاتك مع الإعدادات الافتراضية، فلا تحتاج لإعادة تعريف كل مطالبة. إليك الطريقة:
+
+بالنسبة للكود الذي يحتاج إلى قراءة شرائح المطالبات مباشرة، استخدم `crewai.utilities.i18n.get_i18n()` مع ملف المطالبات نفسه بدلًا من قراءة `agent.i18n`.
+
+### مثال: تخصيص أساسي للمطالبات
+
+أنشئ ملف `custom_prompts.json` بالمطالبات التي تريد تعديلها. تأكد من إدراج جميع المطالبات عالية المستوى التي يجب أن يحتويها، وليس فقط تغييراتك:
+
+```json
+{
+  "slices": {
+    "format": "When responding, follow this structure:\n\nTHOUGHTS: Your step-by-step thinking\nACTION: Any tool you're using\nRESULT: Your final answer or conclusion"
+  }
+}
+```
+
+ثم ادمجه هكذا:
+
+```python
+from crewai import Agent, Crew, Task, Process
+
+# Create agents and tasks as normal
+researcher = Agent(
+    role="Research Specialist",
+    goal="Find information on quantum computing",
+    backstory="You are a quantum physics expert",
+    verbose=True
+)
+
+research_task = Task(
+    description="Research quantum computing applications",
+    expected_output="A summary of practical applications",
+    agent=researcher
+)
+
+# Create a crew with your custom prompt file
+crew = Crew(
+    agents=[researcher],
+    tasks=[research_task],
+    prompt_file="path/to/custom_prompts.json",
+    verbose=True
+)
+
+# Run the crew
+result = crew.kickoff()
+```
+
+بهذه التعديلات البسيطة، تحصل على تحكم منخفض المستوى في كيفية تواصل الـ Agents وحل المهام.
+
+## التحسين لنماذج محددة
+
+تزدهر النماذج المختلفة مع مطالبات منظمة بطرق مختلفة. إجراء تعديلات أعمق يمكن أن يعزز الأداء بشكل كبير من خلال مواءمة مطالباتك مع خصائص النموذج.
+
+### مثال: قالب مطالبات Llama 3.3
+
+على سبيل المثال، عند التعامل مع Llama 3.3 من Meta، قد يعكس التخصيص على المستوى الأعمق الهيكل الموصى به الموضح في:
+https://www.llama.com/docs/model-cards-and-prompt-formats/llama3_1/#prompt-template
+
+إليك مثالاً يوضح كيف يمكنك ضبط Agent للاستفادة من Llama 3.3 في الكود:
+
+```python
+from crewai import Agent, Crew, Task, Process
+from crewai_tools import DirectoryReadTool, FileReadTool
+
+# Define templates for system, user (prompt), and assistant (response) messages
+system_template = """<|begin_of_text|><|start_header_id|>system<|end_header_id|>{{ .System }}<|eot_id|>"""
+prompt_template = """<|start_header_id|>user<|end_header_id|>{{ .Prompt }}<|eot_id|>"""
+response_template = """<|start_header_id|>assistant<|end_header_id|>{{ .Response }}<|eot_id|>"""
+
+# Create an Agent using Llama-specific layouts
+principal_engineer = Agent(
+    role="Principal Engineer",
+    goal="Oversee AI architecture and make high-level decisions",
+    backstory="You are the lead engineer responsible for critical AI systems",
+    verbose=True,
+    llm="groq/llama-3.3-70b-versatile",  # Using the Llama 3 model
+    system_template=system_template,
+    prompt_template=prompt_template,
+    response_template=response_template,
+    tools=[DirectoryReadTool(), FileReadTool()]
+)
+
+# Define a sample task
+engineering_task = Task(
+    description="Review AI implementation files for potential improvements",
+    expected_output="A summary of key findings and recommendations",
+    agent=principal_engineer
+)
+
+# Create a Crew for the task
+llama_crew = Crew(
+    agents=[principal_engineer],
+    tasks=[engineering_task],
+    process=Process.sequential,
+    verbose=True
+)
+
+# Execute the crew
+result = llama_crew.kickoff()
+print(result.raw)
+```
+
+من خلال هذه التهيئة العميقة، يمكنك ممارسة تحكم شامل منخفض المستوى في سير العمل القائمة على Llama دون الحاجة إلى ملف JSON منفصل.
+
+## الخلاصة
+
+يفتح تخصيص المطالبات على المستوى المنخفض في CrewAI الباب أمام حالات استخدام مخصصة ومعقدة للغاية. من خلال إنشاء ملفات مطالبات منظمة (أو قوالب مضمّنة مباشرة)، يمكنك استيعاب نماذج ولغات ومجالات متخصصة متنوعة. يضمن هذا المستوى من المرونة أنك تستطيع صياغة سلوك الذكاء الاصطناعي الذي تحتاجه بالضبط، مع العلم أن CrewAI لا يزال يوفر إعدادات افتراضية موثوقة عندما لا تتجاوزها.
+
+<Check>
+لديك الآن الأساس لتخصيصات المطالبات المتقدمة في CrewAI. سواء كنت تتكيف مع هياكل خاصة بالنموذج أو قيود خاصة بالمجال، يتيح لك هذا النهج المنخفض المستوى تشكيل تفاعلات الـ Agent بطرق متخصصة للغاية.
+</Check>

docs/edge/ar/guides/advanced/fingerprinting.mdx

@@ -0,0 +1,134 @@
+---
+title: البصمات الرقمية
+description: تعلم كيفية استخدام نظام البصمات الرقمية في CrewAI لتحديد وتتبع المكونات بشكل فريد طوال دورة حياتها.
+icon: fingerprint
+mode: "wide"
+---
+
+## نظرة عامة
+
+توفر البصمات الرقمية في CrewAI طريقة لتحديد وتتبع المكونات بشكل فريد طوال دورة حياتها. يتلقى كل `Agent` و`Crew` و`Task` بصمة رقمية فريدة تلقائيًا عند الإنشاء، ولا يمكن تجاوزها يدويًا.
+
+يمكن استخدام هذه البصمات لـ:
+- تدقيق وتتبع استخدام المكونات
+- ضمان سلامة هوية المكونات
+- إرفاق بيانات وصفية بالمكونات
+- إنشاء سلسلة عمليات قابلة للتتبع
+
+## كيف تعمل البصمات الرقمية
+
+البصمة الرقمية هي نسخة من فئة `Fingerprint` من وحدة `crewai.security`. تحتوي كل بصمة على:
+
+- سلسلة UUID: معرّف فريد للمكون يتم إنشاؤه تلقائيًا ولا يمكن تعيينه يدويًا
+- طابع زمني للإنشاء: متى تم إنشاء البصمة، يُعيَّن تلقائيًا ولا يمكن تعديله يدويًا
+- بيانات وصفية: قاموس معلومات إضافية يمكن تخصيصه
+
+تُنشأ البصمات الرقمية وتُعيَّن تلقائيًا عند إنشاء المكون. يكشف كل مكون بصمته من خلال خاصية للقراءة فقط.
+
+## الاستخدام الأساسي
+
+### الوصول إلى البصمات الرقمية
+
+```python
+from crewai import Agent, Crew, Task
+
+# Create components - fingerprints are automatically generated
+agent = Agent(
+    role="Data Scientist",
+    goal="Analyze data",
+    backstory="Expert in data analysis"
+)
+
+crew = Crew(
+    agents=[agent],
+    tasks=[]
+)
+
+task = Task(
+    description="Analyze customer data",
+    expected_output="Insights from data analysis",
+    agent=agent
+)
+
+# Access the fingerprints
+agent_fingerprint = agent.fingerprint
+crew_fingerprint = crew.fingerprint
+task_fingerprint = task.fingerprint
+
+# Print the UUID strings
+print(f"Agent fingerprint: {agent_fingerprint.uuid_str}")
+print(f"Crew fingerprint: {crew_fingerprint.uuid_str}")
+print(f"Task fingerprint: {task_fingerprint.uuid_str}")
+```
+
+### العمل مع البيانات الوصفية للبصمة
+
+يمكنك إضافة بيانات وصفية إلى البصمات لسياق إضافي:
+
+```python
+# Add metadata to the agent's fingerprint
+agent.security_config.fingerprint.metadata = {
+    "version": "1.0",
+    "department": "Data Science",
+    "project": "Customer Analysis"
+}
+
+# Access the metadata
+print(f"Agent metadata: {agent.fingerprint.metadata}")
+```
+
+## استمرارية البصمة
+
+صُممت البصمات لتبقى ثابتة دون تغيير طوال دورة حياة المكون. إذا عدّلت مكونًا، تظل البصمة كما هي:
+
+```python
+original_fingerprint = agent.fingerprint.uuid_str
+
+# Modify the agent
+agent.goal = "New goal for analysis"
+
+# The fingerprint remains unchanged
+assert agent.fingerprint.uuid_str == original_fingerprint
+```
+
+## البصمات الحتمية
+
+بينما لا يمكنك تعيين UUID والطابع الزمني مباشرة، يمكنك إنشاء بصمات حتمية باستخدام طريقة `generate` مع بذرة:
+
+```python
+from crewai.security import Fingerprint
+
+# Create a deterministic fingerprint using a seed string
+deterministic_fingerprint = Fingerprint.generate(seed="my-agent-id")
+
+# The same seed always produces the same fingerprint
+same_fingerprint = Fingerprint.generate(seed="my-agent-id")
+assert deterministic_fingerprint.uuid_str == same_fingerprint.uuid_str
+
+# You can also set metadata
+custom_fingerprint = Fingerprint.generate(
+    seed="my-agent-id",
+    metadata={"version": "1.0"}
+)
+```
+
+## الاستخدام المتقدم
+
+### هيكل البصمة
+
+لكل بصمة الهيكل التالي:
+
+```python
+from crewai.security import Fingerprint
+
+fingerprint = agent.fingerprint
+
+# UUID string - the unique identifier (auto-generated)
+uuid_str = fingerprint.uuid_str  # e.g., "123e4567-e89b-12d3-a456-426614174000"
+
+# Creation timestamp (auto-generated)
+created_at = fingerprint.created_at  # A datetime object
+
+# Metadata - for additional information (can be customized)
+metadata = fingerprint.metadata  # A dictionary, defaults to {}
+```

docs/edge/ar/guides/agents/crafting-effective-agents.mdx

@@ -0,0 +1,453 @@
+---
+title: صياغة Agents فعّالة
+description: تعلم أفضل الممارسات لتصميم Agents ذكاء اصطناعي قوية ومتخصصة تتعاون بفعالية لحل المشكلات المعقدة.
+icon: robot
+mode: "wide"
+---
+
+## فن وعلم تصميم الـ Agent
+
+في قلب CrewAI يكمن الـ Agent - كيان ذكاء اصطناعي متخصص مصمم لأداء أدوار محددة ضمن إطار تعاوني. بينما إنشاء Agents أساسية أمر بسيط، فإن صياغة Agents فعّالة حقًا تنتج نتائج استثنائية يتطلب فهم مبادئ التصميم الأساسية وأفضل الممارسات.
+
+سيساعدك هذا الدليل على إتقان فن تصميم الـ Agent، مما يمكّنك من إنشاء شخصيات AI متخصصة تتعاون بفعالية وتفكر بشكل نقدي وتنتج مخرجات عالية الجودة مصممة لاحتياجاتك المحددة.
+
+### لماذا يهم تصميم الـ Agent
+
+الطريقة التي تعرّف بها الـ Agents تؤثر بشكل كبير على:
+
+1. **جودة المخرجات**: الـ Agents المصممة جيدًا تنتج نتائج أكثر صلة وجودة
+2. **فعالية التعاون**: الـ Agents ذات المهارات المكملة تعمل معًا بكفاءة أكبر
+3. **أداء المهام**: الـ Agents ذات الأدوار والأهداف الواضحة تنفذ المهام بفعالية أكبر
+4. **قابلية التوسع**: الـ Agents المصممة بعناية يمكن إعادة استخدامها عبر Crews وسياقات متعددة
+
+لنستكشف أفضل الممارسات لإنشاء Agents تتفوق في هذه الأبعاد.
+
+## قاعدة 80/20: ركّز على المهام أكثر من الـ Agents
+
+عند بناء أنظمة AI فعّالة، تذكر هذا المبدأ الحاسم: **80% من جهدك يجب أن يذهب لتصميم المهام، و20% فقط لتعريف الـ Agents**.
+
+لماذا؟ لأن حتى أفضل Agent معرّف سيفشل مع مهام مصممة بشكل سيئ، لكن المهام المصممة جيدًا يمكنها رفع مستوى حتى Agent بسيط. هذا يعني:
+
+- اقضِ معظم وقتك في كتابة تعليمات مهام واضحة
+- حدد المدخلات والمخرجات المتوقعة بالتفصيل
+- أضف أمثلة وسياقًا لتوجيه التنفيذ
+- خصص الوقت المتبقي لدور Agent وهدفه وخلفيته
+
+هذا لا يعني أن تصميم الـ Agent ليس مهمًا - بل هو مهم بالتأكيد. لكن تصميم المهام هو حيث تحدث معظم إخفاقات التنفيذ، لذا رتّب أولوياتك وفقًا لذلك.
+
+## المبادئ الأساسية لتصميم Agent فعّال
+
+### 1. إطار الدور-الهدف-الخلفية
+
+أقوى الـ Agents في CrewAI مبنية على أساس قوي من ثلاثة عناصر رئيسية:
+
+#### الدور: الوظيفة المتخصصة للـ Agent
+
+يحدد الدور ما يفعله الـ Agent ومجال خبرته. عند صياغة الأدوار:
+
+- **كن محددًا ومتخصصًا**: بدلاً من "كاتب"، استخدم "متخصص في التوثيق التقني" أو "راوي قصص إبداعي"
+- **تماشَ مع المهن الواقعية**: ابنِ الأدوار على نماذج مهنية معروفة
+- **تضمين خبرة المجال**: حدد مجال معرفة الـ Agent (مثل "محلل مالي متخصص في اتجاهات السوق")
+
+**أمثلة على أدوار فعّالة:**
+```yaml
+role: "Senior UX Researcher specializing in user interview analysis"
+role: "Full-Stack Software Architect with expertise in distributed systems"
+role: "Corporate Communications Director specializing in crisis management"
+```
+
+#### الهدف: غرض الـ Agent ودافعه
+
+يوجه الهدف جهود الـ Agent ويشكّل عملية صنع القرار. الأهداف الفعّالة يجب أن:
+
+- **تكون واضحة ومركّزة على النتائج**: حدد ما يحاول الـ Agent تحقيقه
+- **تؤكد على معايير الجودة**: تضمين توقعات حول جودة العمل
+- **تتضمن معايير النجاح**: ساعد الـ Agent على فهم ما يعنيه "الجيد"
+
+**أمثلة على أهداف فعّالة:**
+```yaml
+goal: "Uncover actionable user insights by analyzing interview data and identifying recurring patterns, unmet needs, and improvement opportunities"
+goal: "Design robust, scalable system architectures that balance performance, maintainability, and cost-effectiveness"
+goal: "Craft clear, empathetic crisis communications that address stakeholder concerns while protecting organizational reputation"
+```
+
+#### الخلفية: تجربة الـ Agent ومنظوره
+
+تمنح الخلفية عمقًا لشخصية الـ Agent، مؤثرة في كيفية تعامله مع المشكلات وتفاعله مع الآخرين. الخلفيات الجيدة:
+
+- **تؤسس الخبرة والتجربة**: تشرح كيف اكتسب الـ Agent مهاراته
+- **تحدد أسلوب العمل والقيم**: تصف كيف يتعامل الـ Agent مع عمله
+- **تنشئ شخصية متماسكة**: تضمن أن جميع عناصر الخلفية تتماشى مع الدور والهدف
+
+**أمثلة على خلفيات فعّالة:**
+```yaml
+backstory: "You have spent 15 years conducting and analyzing user research for top tech companies. You have a talent for reading between the lines and identifying patterns that others miss. You believe that good UX is invisible and that the best insights come from listening to what users don't say as much as what they do say."
+
+backstory: "With 20+ years of experience building distributed systems at scale, you've developed a pragmatic approach to software architecture. You've seen both successful and failed systems and have learned valuable lessons from each. You balance theoretical best practices with practical constraints and always consider the maintenance and operational aspects of your designs."
+
+backstory: "As a seasoned communications professional who has guided multiple organizations through high-profile crises, you understand the importance of transparency, speed, and empathy in crisis response. You have a methodical approach to crafting messages that address concerns while maintaining organizational credibility."
+```
+
+### 2. المتخصصون أفضل من العموميين
+
+يؤدي الـ Agents أداءً أفضل بشكل ملحوظ عند منحهم أدوارًا متخصصة بدلاً من عامة. الـ Agent المركّز بشدة ينتج مخرجات أكثر دقة وصلة:
+
+**عام (أقل فعالية):**
+```yaml
+role: "Writer"
+```
+
+**متخصص (أكثر فعالية):**
+```yaml
+role: "Technical Blog Writer specializing in explaining complex AI concepts to non-technical audiences"
+```
+
+**فوائد التخصص:**
+- فهم أوضح للمخرجات المتوقعة
+- أداء أكثر اتساقًا
+- توافق أفضل مع المهام المحددة
+- قدرة محسّنة على إصدار أحكام خاصة بالمجال
+
+### 3. التوازن بين التخصص والمرونة
+
+الـ Agents الفعّالة تحقق التوازن الصحيح بين التخصص (القيام بشيء واحد بشكل ممتاز) والمرونة (التكيف مع مواقف متنوعة):
+
+- **تخصص في الدور، مرونة في التطبيق**: أنشئ Agents بمهارات متخصصة يمكن تطبيقها عبر سياقات متعددة
+- **تجنب التعريفات الضيقة جدًا**: تأكد من أن الـ Agents يمكنها التعامل مع التنوعات ضمن مجال خبرتها
+- **ضع في الاعتبار السياق التعاوني**: صمم Agents تكمّل تخصصاتها الـ Agents الأخرى التي ستعمل معها
+
+### 4. تعيين مستويات الخبرة المناسبة
+
+مستوى الخبرة الذي تعيّنه للـ Agent يشكّل كيفية تعامله مع المهام:
+
+- **Agents مبتدئة**: جيدة للمهام المباشرة والعصف الذهني والمسودات الأولية
+- **Agents متوسطة**: مناسبة لمعظم المهام القياسية مع تنفيذ موثوق
+- **Agents خبيرة**: الأفضل للمهام المعقدة والمتخصصة التي تتطلب عمقًا ودقة
+- **Agents على مستوى عالمي**: محجوزة للمهام الحرجة حيث الجودة الاستثنائية مطلوبة
+
+اختر مستوى الخبرة المناسب بناءً على تعقيد المهمة ومتطلبات الجودة. لمعظم Crews التعاونية، غالبًا ما يعمل مزيج من مستويات الخبرة بشكل أفضل، مع تعيين خبرة أعلى للوظائف المتخصصة الأساسية.
+
+## أمثلة عملية: قبل وبعد
+
+لنلقِ نظرة على بعض أمثلة تعريفات الـ Agent قبل وبعد تطبيق أفضل الممارسات:
+
+### مثال 1: Agent إنشاء المحتوى
+
+**قبل:**
+```yaml
+role: "Writer"
+goal: "Write good content"
+backstory: "You are a writer who creates content for websites."
+```
+
+**بعد:**
+```yaml
+role: "B2B Technology Content Strategist"
+goal: "Create compelling, technically accurate content that explains complex topics in accessible language while driving reader engagement and supporting business objectives"
+backstory: "You have spent a decade creating content for leading technology companies, specializing in translating technical concepts for business audiences. You excel at research, interviewing subject matter experts, and structuring information for maximum clarity and impact. You believe that the best B2B content educates first and sells second, building trust through genuine expertise rather than marketing hype."
+```
+
+### مثال 2: Agent البحث
+
+**قبل:**
+```yaml
+role: "Researcher"
+goal: "Find information"
+backstory: "You are good at finding information online."
+```
+
+**بعد:**
+```yaml
+role: "Academic Research Specialist in Emerging Technologies"
+goal: "Discover and synthesize cutting-edge research, identifying key trends, methodologies, and findings while evaluating the quality and reliability of sources"
+backstory: "With a background in both computer science and library science, you've mastered the art of digital research. You've worked with research teams at prestigious universities and know how to navigate academic databases, evaluate research quality, and synthesize findings across disciplines. You're methodical in your approach, always cross-referencing information and tracing claims to primary sources before drawing conclusions."
+```
+
+## صياغة مهام فعّالة للـ Agents
+
+بينما تصميم الـ Agent مهم، تصميم المهام حاسم للتنفيذ الناجح. إليك أفضل الممارسات لتصميم مهام تهيئ الـ Agents للنجاح:
+
+### تشريح المهمة الفعّالة
+
+المهمة المصممة جيدًا لها مكونان رئيسيان يخدمان أغراضًا مختلفة:
+
+#### وصف المهمة: العملية
+يجب أن يركز الوصف على ماذا تفعل وكيف تفعله، بما في ذلك:
+- تعليمات مفصلة للتنفيذ
+- سياق ومعلومات خلفية
+- النطاق والقيود
+- خطوات العملية المتبعة
+
+#### المخرجات المتوقعة: التسليم
+يجب أن تحدد المخرجات المتوقعة شكل النتيجة النهائية:
+- مواصفات التنسيق (markdown، JSON، إلخ)
+- متطلبات الهيكل
+- معايير الجودة
+- أمثلة على مخرجات جيدة (عند الإمكان)
+
+### أفضل ممارسات تصميم المهام
+
+#### 1. غرض واحد، مخرج واحد
+تؤدي المهام أفضل أداء عند التركيز على هدف واضح واحد:
+
+**مثال سيئ (واسع جدًا):**
+```yaml
+task_description: "Research market trends, analyze the data, and create a visualization."
+```
+
+**مثال جيد (مركّز):**
+```yaml
+# Task 1
+research_task:
+  description: "Research the top 5 market trends in the AI industry for 2024."
+  expected_output: "A markdown list of the 5 trends with supporting evidence."
+
+# Task 2
+analysis_task:
+  description: "Analyze the identified trends to determine potential business impacts."
+  expected_output: "A structured analysis with impact ratings (High/Medium/Low)."
+
+# Task 3
+visualization_task:
+  description: "Create a visual representation of the analyzed trends."
+  expected_output: "A description of a chart showing trends and their impact ratings."
+```
+
+#### 2. كن صريحًا بشأن المدخلات والمخرجات
+حدد دائمًا بوضوح ما المدخلات التي ستستخدمها المهمة وكيف يجب أن تبدو المخرجات:
+
+**مثال:**
+```yaml
+analysis_task:
+  description: >
+    Analyze the customer feedback data from the CSV file.
+    Focus on identifying recurring themes related to product usability.
+    Consider sentiment and frequency when determining importance.
+  expected_output: >
+    A markdown report with the following sections:
+    1. Executive summary (3-5 bullet points)
+    2. Top 3 usability issues with supporting data
+    3. Recommendations for improvement
+```
+
+#### 3. تضمين الغرض والسياق
+اشرح لماذا تهم المهمة وكيف تتناسب مع سير العمل الأكبر:
+
+**مثال:**
+```yaml
+competitor_analysis_task:
+  description: >
+    Analyze our three main competitors' pricing strategies.
+    This analysis will inform our upcoming pricing model revision.
+    Focus on identifying patterns in how they price premium features
+    and how they structure their tiered offerings.
+```
+
+#### 4. استخدام أدوات المخرجات المنظمة
+للمخرجات القابلة للقراءة آليًا، حدد التنسيق بوضوح:
+
+**مثال:**
+```yaml
+data_extraction_task:
+  description: "Extract key metrics from the quarterly report."
+  expected_output: "JSON object with the following keys: revenue, growth_rate, customer_acquisition_cost, and retention_rate."
+```
+
+## أخطاء شائعة يجب تجنبها
+
+بناءً على الدروس المستفادة من التطبيقات الواقعية، إليك أكثر المزالق شيوعًا في تصميم الـ Agent والمهام:
+
+### 1. تعليمات مهام غير واضحة
+
+**المشكلة:** تفتقر المهام لتفاصيل كافية مما يصعّب على الـ Agents تنفيذها بفعالية.
+
+**مثال تصميم سيئ:**
+```yaml
+research_task:
+  description: "Research AI trends."
+  expected_output: "A report on AI trends."
+```
+
+**نسخة محسّنة:**
+```yaml
+research_task:
+  description: >
+    Research the top emerging AI trends for 2024 with a focus on:
+    1. Enterprise adoption patterns
+    2. Technical breakthroughs in the past 6 months
+    3. Regulatory developments affecting implementation
+
+    For each trend, identify key companies, technologies, and potential business impacts.
+  expected_output: >
+    A comprehensive markdown report with:
+    - Executive summary (5 bullet points)
+    - 5-7 major trends with supporting evidence
+    - For each trend: definition, examples, and business implications
+    - References to authoritative sources
+```
+
+### 2. "مهام إلهية" تحاول فعل الكثير
+
+**المشكلة:** مهام تجمع عمليات معقدة متعددة في مجموعة تعليمات واحدة.
+
+**مثال تصميم سيئ:**
+```yaml
+comprehensive_task:
+  description: "Research market trends, analyze competitor strategies, create a marketing plan, and design a launch timeline."
+```
+
+**نسخة محسّنة:**
+قسّمها إلى مهام متسلسلة ومركّزة:
+```yaml
+# Task 1: Research
+market_research_task:
+  description: "Research current market trends in the SaaS project management space."
+  expected_output: "A markdown summary of key market trends."
+
+# Task 2: Competitive Analysis
+competitor_analysis_task:
+  description: "Analyze strategies of the top 3 competitors based on the market research."
+  expected_output: "A comparison table of competitor strategies."
+  context: [market_research_task]
+
+# Continue with additional focused tasks...
+```
+
+### 3. عدم توافق الوصف والمخرجات المتوقعة
+
+**المشكلة:** وصف المهمة يطلب شيئًا بينما المخرجات المتوقعة تحدد شيئًا مختلفًا.
+
+**مثال تصميم سيئ:**
+```yaml
+analysis_task:
+  description: "Analyze customer feedback to find areas of improvement."
+  expected_output: "A marketing plan for the next quarter."
+```
+
+**نسخة محسّنة:**
+```yaml
+analysis_task:
+  description: "Analyze customer feedback to identify the top 3 areas for product improvement."
+  expected_output: "A report listing the 3 priority improvement areas with supporting customer quotes and data points."
+```
+
+### 4. عدم فهم العملية بنفسك
+
+**المشكلة:** مطالبة الـ Agents بتنفيذ مهام لا تفهمها أنت بالكامل.
+
+**الحل:**
+1. حاول تنفيذ المهمة يدويًا أولاً
+2. وثّق عمليتك ونقاط القرار ومصادر المعلومات
+3. استخدم هذا التوثيق كأساس لوصف مهمتك
+
+### 5. الاستخدام المبكر للهياكل الهرمية
+
+**المشكلة:** إنشاء هرميات Agents معقدة بلا داعٍ حيث تعمل العمليات المتسلسلة بشكل أفضل.
+
+**الحل:** ابدأ بالعمليات المتسلسلة وانتقل إلى النماذج الهرمية فقط عندما يتطلب تعقيد سير العمل ذلك حقًا.
+
+### 6. تعريفات Agent غامضة أو عامة
+
+**المشكلة:** تعريفات Agent العامة تؤدي لمخرجات عامة.
+
+**مثال تصميم سيئ:**
+```yaml
+agent:
+  role: "Business Analyst"
+  goal: "Analyze business data"
+  backstory: "You are good at business analysis."
+```
+
+**نسخة محسّنة:**
+```yaml
+agent:
+  role: "SaaS Metrics Specialist focusing on growth-stage startups"
+  goal: "Identify actionable insights from business data that can directly impact customer retention and revenue growth"
+  backstory: "With 10+ years analyzing SaaS business models, you've developed a keen eye for the metrics that truly matter for sustainable growth. You've helped numerous companies identify the leverage points that turned around their business trajectory. You believe in connecting data to specific, actionable recommendations rather than general observations."
+```
+
+## استراتيجيات متقدمة لتصميم الـ Agent
+
+### التصميم للتعاون
+
+عند إنشاء Agents ستعمل معًا في Crew، ضع في اعتبارك:
+
+- **مهارات مكملة**: صمم Agents بقدرات مميزة ومكملة
+- **نقاط التسليم**: حدد واجهات واضحة لكيفية انتقال العمل بين الـ Agents
+- **توتر بنّاء**: أحيانًا، إنشاء Agents بمنظورات مختلفة قليلاً يمكن أن يؤدي لنتائج أفضل من خلال حوار منتج
+
+على سبيل المثال، قد يتضمن Crew إنشاء محتوى:
+
+```yaml
+# Research Agent
+role: "Research Specialist for technical topics"
+goal: "Gather comprehensive, accurate information from authoritative sources"
+backstory: "You are a meticulous researcher with a background in library science..."
+
+# Writer Agent
+role: "Technical Content Writer"
+goal: "Transform research into engaging, clear content that educates and informs"
+backstory: "You are an experienced writer who excels at explaining complex concepts..."
+
+# Editor Agent
+role: "Content Quality Editor"
+goal: "Ensure content is accurate, well-structured, and polished while maintaining consistency"
+backstory: "With years of experience in publishing, you have a keen eye for detail..."
+```
+
+### إنشاء مستخدمي أدوات متخصصين
+
+يمكن تصميم بعض الـ Agents خصيصًا للاستفادة من أدوات معينة بفعالية:
+
+```yaml
+role: "Data Analysis Specialist"
+goal: "Derive meaningful insights from complex datasets through statistical analysis"
+backstory: "With a background in data science, you excel at working with structured and unstructured data..."
+tools: [PythonREPLTool, DataVisualizationTool, CSVAnalysisTool]
+```
+
+### تكييف الـ Agents مع قدرات LLM
+
+للنماذج المختلفة نقاط قوة مختلفة. صمم الـ Agents مع وضع هذه القدرات في الاعتبار:
+
+```yaml
+# For complex reasoning tasks
+analyst:
+  role: "Data Insights Analyst"
+  goal: "..."
+  backstory: "..."
+  llm: openai/gpt-4o
+
+# For creative content
+writer:
+  role: "Creative Content Writer"
+  goal: "..."
+  backstory: "..."
+  llm: anthropic/claude-3-opus
+```
+
+## اختبار تصميم الـ Agent والتكرار عليه
+
+تصميم الـ Agent غالبًا عملية تكرارية. إليك نهجًا عمليًا:
+
+1. **ابدأ بنموذج أولي**: أنشئ تعريف Agent أولي
+2. **اختبر مع مهام نموذجية**: قيّم الأداء على مهام تمثيلية
+3. **حلل المخرجات**: حدد نقاط القوة والضعف
+4. **صقل التعريف**: اضبط الدور والهدف والخلفية بناءً على الملاحظات
+5. **اختبر في بيئة تعاونية**: قيّم كيف يعمل الـ Agent في إعداد Crew
+
+## الخلاصة
+
+صياغة Agents فعّالة هي فن وعلم في آن واحد. من خلال تعريف الأدوار والأهداف والخلفيات بعناية بما يتماشى مع احتياجاتك المحددة، ودمجها مع مهام مصممة جيدًا، يمكنك إنشاء متعاونين AI متخصصين ينتجون نتائج استثنائية.
+
+تذكر أن تصميم الـ Agent والمهام عملية تكرارية. ابدأ بأفضل الممارسات هذه، وراقب الـ Agents أثناء العمل، وصقل نهجك بناءً على ما تتعلمه. وتذكر دائمًا قاعدة 80/20 - ركّز معظم جهدك على إنشاء مهام واضحة ومركّزة للحصول على أفضل النتائج من الـ Agents.
+
+<Check>
+تهانينا! أنت الآن تفهم مبادئ وممارسات تصميم Agent الفعّال. طبّق هذه التقنيات لإنشاء Agents قوية ومتخصصة تعمل معًا بسلاسة لإنجاز مهام معقدة.
+</Check>
+
+## الخطوات التالية
+
+- جرّب تهيئات Agent مختلفة لحالة استخدامك المحددة
+- تعلم عن [بناء أول Crew](/ar/guides/crews/first-crew) لمعرفة كيف تعمل الـ Agents معًا
+- استكشف [CrewAI Flows](/ar/guides/flows/first-flow) لتنسيق أكثر تقدمًا

docs/edge/ar/guides/coding-tools/agents-md.mdx

@@ -0,0 +1,61 @@
+---
+title: أدوات البرمجة
+description: استخدم AGENTS.md لتوجيه أدوات البرمجة وبيئات التطوير عبر مشاريع CrewAI.
+icon: terminal
+mode: "wide"
+---
+
+## لماذا AGENTS.md
+
+`AGENTS.md` هو ملف تعليمات خفيف محلي للمستودع يمنح أدوات البرمجة توجيهات متسقة خاصة بالمشروع. ضعه في جذر المشروع واعتبره المصدر الموثوق لكيفية عمل المساعدين: الاصطلاحات والأوامر وملاحظات البنية والحدود.
+
+## إنشاء مشروع باستخدام CLI
+
+استخدم CLI الخاص بـ CrewAI لإنشاء هيكل مشروع، وسيُضاف `AGENTS.md` تلقائيًا في الجذر.
+
+```bash
+# Crew
+crewai create crew my_crew
+
+# Flow
+crewai create flow my_flow
+
+# Tool repository
+crewai tool create my_tool
+```
+
+## إعداد الأدوات: توجيه المساعدين إلى AGENTS.md
+
+### Codex
+
+يمكن توجيه Codex بملفات `AGENTS.md` الموضوعة في مستودعك. استخدمها لتوفير سياق مشروع مستمر مثل الاصطلاحات والأوامر وتوقعات سير العمل.
+
+### Claude Code
+
+يخزّن Claude Code ذاكرة المشروع في `CLAUDE.md`. يمكنك تهيئته بـ `/init` وتحريره باستخدام `/memory`. يدعم Claude Code أيضًا الاستيرادات داخل `CLAUDE.md`، فيمكنك إضافة سطر واحد مثل `@AGENTS.md` لسحب التعليمات المشتركة دون تكرارها.
+
+يمكنك ببساطة استخدام:
+
+```bash
+mv AGENTS.md CLAUDE.md
+```
+
+### Gemini CLI وGoogle Antigravity
+
+يقوم Gemini CLI وAntigravity بتحميل ملف سياق المشروع (الافتراضي: `GEMINI.md`) من جذر المستودع والمجلدات الأصلية. يمكنك تهيئته لقراءة `AGENTS.md` بدلاً من ذلك (أو بالإضافة إليه) بتعيين `context.fileName` في إعدادات Gemini CLI. على سبيل المثال، عيّنه إلى `AGENTS.md` فقط، أو أدرج كلاً من `AGENTS.md` و`GEMINI.md` إذا أردت الاحتفاظ بتنسيق كل أداة.
+
+يمكنك ببساطة استخدام:
+
+```bash
+mv AGENTS.md GEMINI.md
+```
+
+### Cursor
+
+يدعم Cursor ملف `AGENTS.md` كملف تعليمات مشروع. ضعه في جذر المشروع لتوفير توجيهات لمساعد البرمجة في Cursor.
+
+### Windsurf
+
+يوفر Claude Code تكاملاً رسميًا مع Windsurf. إذا كنت تستخدم Claude Code داخل Windsurf، اتبع توجيهات Claude Code أعلاه واستورد `AGENTS.md` من `CLAUDE.md`.
+
+إذا كنت تستخدم مساعد Windsurf الأصلي، هيّئ ميزة قواعد أو تعليمات المشروع (إذا كانت متاحة) لقراءة `AGENTS.md` أو الصق المحتويات مباشرة.

docs/edge/ar/guides/coding-tools/build-with-ai.mdx

@@ -0,0 +1,214 @@
+---
+title: "البناء باستخدام الذكاء الاصطناعي"
+description: "كل ما يحتاجه وكلاء البرمجة بالذكاء الاصطناعي للبناء والنشر والتوسع مع CrewAI — المهارات، وثائق مقروءة آلياً، النشر، وميزات المؤسسات."
+icon: robot
+mode: "wide"
+---
+
+# البناء باستخدام الذكاء الاصطناعي
+
+CrewAI مُصمَّم أصلاً للعمل مع الذكاء الاصطناعي. تجمع هذه الصفحة ما يحتاجه وكيل البرمجة بالذكاء الاصطناعي للبناء مع CrewAI — سواءً كان Claude Code أو Codex أو Cursor أو Gemini CLI أو أي مساعد آخر يساعد المطوّر على إيصال الـ crews والـ flows.
+
+### وكلاء البرمجة المدعومون
+
+<CardGroup cols={5}>
+  <Card title="Claude Code" icon="message-bot" color="#D97706" />
+  <Card title="Cursor" icon="arrow-pointer" color="#3B82F6" />
+  <Card title="Codex" icon="terminal" color="#10B981" />
+  <Card title="Windsurf" icon="wind" color="#06B6D4" />
+  <Card title="Gemini CLI" icon="sparkles" color="#8B5CF6" />
+</CardGroup>
+
+<Note>
+  صُممت هذه الصفحة للبشر وللمساعدين الذكيين على حدٍّ سواء. إذا كنت وكيل برمجة، ابدأ بـ **Skills** للحصول على سياق CrewAI، ثم استخدم **llms.txt** للوصول الكامل إلى الوثائق.
+</Note>
+
+---
+
+## 1. Skills — علِّم وكيلك CrewAI
+
+**Skills** حزم تعليمات تمنح وكلاء البرمجة معرفة عميقة بـ CrewAI — كيفية إنشاء هيكل Flows، وضبط Crews، استخدام الأدوات، واتباع اتفاقيات الإطار.
+
+<Tabs>
+  <Tab title="Claude Code (سوق الإضافات)">
+    <img src="https://cdn.simpleicons.org/anthropic/D97706" alt="Anthropic" width="28" style={{display: "inline", verticalAlign: "middle", marginRight: "8px"}} />
+    مهارات CrewAI متاحة في **سوق إضافات Claude Code** — نفس قناة التوزيع التي تستخدمها شركات رائدة في مجال الذكاء الاصطناعي:
+    ```shell
+    /plugin marketplace add crewAIInc/skills
+    /plugin install crewai-skills@crewai-plugins
+    /reload-plugins
+    ```
+
+    تُفعَّل أربع مهارات تلقائياً عند طرح أسئلة متعلقة بـ CrewAI:
+
+    | المهارة | متى تُستخدم |
+    |---------|-------------|
+    | `getting-started` | مشاريع جديدة، الاختيار بين `LLM.call()` / `Agent` / `Crew` / `Flow`، ربط `crew.jsonc` / `main.py` |
+    | `design-agent` | ضبط الوكلاء — الدور، الهدف، الخلفية، الأدوات، نماذج اللغة، الذاكرة، الحدود الآمنة |
+    | `design-task` | وصف المهام، التبعيات، المخرجات المنظمة (`output_pydantic`، `output_json`)، المراجعة البشرية |
+    | `ask-docs` | الاستعلام من [خادم CrewAI docs MCP](https://docs.crewai.com/mcp) للحصول على تفاصيل واجهة البرمجة الحالية |
+  </Tab>
+  <Tab title="npx (أي وكيل)">
+    يعمل مع Claude Code أو Codex أو Cursor أو Gemini CLI أو أي وكيل برمجة:
+    ```shell
+    npx skills add crewaiinc/skills
+    ```
+    يُجلب من [سجل skills.sh](https://skills.sh/crewaiinc/skills).
+  </Tab>
+</Tabs>
+
+<Steps>
+  <Step title="ثبِّت حزمة المهارات الرسمية">
+    استخدم إحدى الطريقتين أعلاه — سوق إضافات Claude Code أو `npx skills add`. كلاهما يثبّت الحزمة الرسمية [crewAIInc/skills](https://github.com/crewAIInc/skills).
+  </Step>
+  <Step title="يحصل وكيلك فوراً على خبرة CrewAI">
+    تعلّم الحزمة وكيلك:
+    - **Flows** — تطبيقات ذات حالة، خطوات، وتشغيل crews
+    - **Crews والوكلاء** — أنماط JSON-first (`crew.jsonc` و `agents/*.jsonc`)، الأدوار، المهام، التفويض
+    - **الأدوات والتكاملات** — البحث، واجهات API، خوادم MCP، وأدوات CrewAI الشائعة
+    - **هيكل المشروع** — هياكل CLI واتفاقيات المستودع
+    - **أنماط محدثة** — يتماشى مع وثائق CrewAI الحالية وأفضل الممارسات
+  </Step>
+  <Step title="ابدأ البناء">
+    يمكن لوكيلك الآن إنشاء هيكل وبناء مشاريع CrewAI دون أن تعيد شرح الإطار في كل جلسة.
+  </Step>
+</Steps>
+
+<CardGroup cols={2}>
+  <Card title="مفهوم Skills" icon="bolt" href="/ar/concepts/skills">
+    كيف تعمل المهارات في وكلاء CrewAI — الحقن، التفعيل، والأنماط.
+  </Card>
+  <Card title="صفحة Skills" icon="wand-magic-sparkles" href="/ar/skills">
+    نظرة على حزمة crewAIInc/skills وما تتضمنه.
+  </Card>
+  <Card title="AGENTS.md والأدوات" icon="terminal" href="/ar/guides/coding-tools/agents-md">
+    إعداد AGENTS.md لـ Claude Code وCodex وCursor وGemini CLI.
+  </Card>
+  <Card title="سجل skills.sh" icon="globe" href="https://skills.sh/crewaiinc/skills">
+    القائمة الرسمية — المهارات، إحصاءات التثبيت، والتدقيق.
+  </Card>
+</CardGroup>
+
+---
+
+## 2. llms.txt — وثائق مقروءة آلياً
+
+ينشر CrewAI ملف `llms.txt` يمنح المساعدين الذكيين وصولاً مباشراً إلى الوثائق الكاملة بصيغة مقروءة آلياً.
+
+```
+https://docs.crewai.com/llms.txt
+```
+
+<Tabs>
+  <Tab title="ما هو llms.txt؟">
+    [`llms.txt`](https://llmstxt.org/) معيار ناشئ لجعل الوثائق قابلة للاستهلاك من قبل نماذج اللغة الكبيرة. بدلاً من استخراج HTML، يمكن لوكيلك جلب ملف نصي واحد منظم بكل المحتوى المطلوب.
+
+    ملف `llms.txt` الخاص بـ CrewAI **متاح فعلياً** — يمكن لوكيلك استخدامه الآن.
+  </Tab>
+  <Tab title="كيفية الاستخدام">
+    وجِّه وكيل البرمجة إلى عنوان URL عندما يحتاج إلى مرجع CrewAI:
+
+    ```
+    Fetch https://docs.crewai.com/llms.txt for CrewAI documentation.
+    ```
+
+    يمكن للعديد من وكلاء البرمجة (Claude Code، Cursor، وغيرهما) جلب عناوين URL مباشرة. يحتوي الملف على وثائق منظمة تغطي مفاهيم CrewAI وواجهات البرمجة والأدلة.
+  </Tab>
+  <Tab title="لماذا يهم">
+    - **دون استخراج ويب** — محتوى نظيف ومنظم في طلب واحد
+    - **دائماً محدث** — يُقدَّم مباشرة من docs.crewai.com
+    - **محسّن لنماذج اللغة** — مُنسَّق لنوافذ السياق لا للمتصفحات
+    - **يُكمّل Skills** — المهارات تعلّم الأنماط، وllms.txt يوفّر المرجع
+  </Tab>
+</Tabs>
+
+---
+
+## 3. النشر للمؤسسات
+
+انتقل من crew محلي إلى الإنتاج على **CrewAI AMP** (منصة إدارة الوكلاء) في دقائق.
+
+<Steps>
+  <Step title="ابنِ محلياً">
+    أنشئ الهيكل واختبر crew أو flow:
+    ```bash
+    crewai create crew my_crew
+    cd my_crew
+    crewai run
+    ```
+  </Step>
+  <Step title="جهّز للنشر">
+    تأكد أن هيكل مشروعك جاهز:
+    ```bash
+    crewai deploy --prepare
+    ```
+    راجع [دليل التحضير](https://docs-platform.crewai.com/platform/ar/guides/prepare-for-deployment) لتفاصيل الهيكل والمتطلبات.
+  </Step>
+  <Step title="انشر على AMP">
+    ادفع إلى منصة CrewAI AMP:
+    ```bash
+    crewai deploy
+    ```
+    يمكنك أيضاً النشر عبر [تكامل GitHub](https://docs-platform.crewai.com/platform/ar/guides/deploy-to-amp) أو [Crew Studio](https://docs-platform.crewai.com/platform/ar/guides/enable-crew-studio).
+  </Step>
+  <Step title="الوصول عبر API">
+    يحصل الـ crew المنشور على نقطة نهاية REST. دمجه في أي تطبيق:
+    ```bash
+    curl -X POST https://app.crewai.com/api/v1/crews/<crew-id>/kickoff \
+      -H "Authorization: Bearer $CREWAI_API_KEY" \
+      -H "Content-Type: application/json" \
+      -d '{"inputs": {"topic": "AI agents"}}'
+    ```
+  </Step>
+</Steps>
+
+<CardGroup cols={2}>
+  <Card title="النشر على AMP" icon="rocket" href="https://docs-platform.crewai.com/platform/ar/guides/deploy-to-amp">
+    دليل النشر الكامل — CLI وGitHub وCrew Studio.
+  </Card>
+  <Card title="مقدمة عن AMP" icon="globe" href="https://docs-platform.crewai.com/platform/ar/introduction">
+    نظرة على المنصة — ما يوفّره AMP لـ crews في الإنتاج.
+  </Card>
+</CardGroup>
+
+---
+
+## 4. ميزات المؤسسات
+
+CrewAI AMP مُصمَّم لفرق الإنتاج. إليك ما تحصل عليه بعد النشر.
+
+<CardGroup cols={2}>
+  <Card title="المراقبة والرصد" icon="chart-line">
+    مسارات تنفيذ مفصّلة، وسجلات، ومقاييس أداء لكل تشغيل crew. راقب قرارات الوكلاء، استدعاءات الأدوات، وإكمال المهام في الوقت الفعلي.
+  </Card>
+  <Card title="Crew Studio" icon="paintbrush">
+    واجهة منخفضة/بدون كود لإنشاء crews وتخصيصها ونشرها بصرياً — ثم التصدير إلى الشيفرة أو النشر مباشرة.
+  </Card>
+  <Card title="بث الويبهوك" icon="webhook">
+    بث أحداث فورية من تنفيذات الـ crews إلى أنظمتك. تكامل مع Slack أو Zapier أو أي مستهلك ويبهوك.
+  </Card>
+  <Card title="إدارة الفريق" icon="users">
+    SSO وRBAC وضوابط على مستوى المؤسسة. أدر من يمكنه إنشاء crews ونشرها والوصول إليها.
+  </Card>
+  <Card title="مستودع الأدوات" icon="toolbox">
+    انشر وشارك أدواتاً مخصصة عبر مؤسستك. ثبّت أدوات المجتمع من السجل.
+  </Card>
+  <Card title="Factory (استضافة ذاتية)" icon="server">
+    شغّل CrewAI AMP على بنيتك التحتية. قدرات المنصة كاملة مع ضوابط إقامة البيانات والامتثال.
+  </Card>
+</CardGroup>
+
+<AccordionGroup>
+  <Accordion title="لمن مخصص AMP؟">
+    لفرق تحتاج نقل سير عمل وكلاء الذكاء الاصطناعي من النماذج الأولية إلى الإنتاج — مع المراقبة وضوابط الوصول والبنية التحتية القابلة للتوسع. سواءً كنت ناشئاً أو مؤسسة كبيرة، يتولى AMP التعقيد التشغيلي لتتفرغ لبناء الوكلاء.
+  </Accordion>
+  <Accordion title="ما خيارات النشر المتاحة؟">
+    - **السحابة (app.crewai.com)** — تُدار من CrewAI، أسرع طريق إلى الإنتاج
+    - **Factory (استضافة ذاتية)** — على بنيتك التحتية لسيطرة كاملة على البيانات
+    - **هجين** — دمج السحابة والاستضافة الذاتية حسب حساسية البيانات
+  </Accordion>
+</AccordionGroup>
+
+<Card title="استكشف CrewAI AMP →" icon="arrow-right" href="https://app.crewai.com">
+  سجّل وانشر أول crew لك في الإنتاج.
+</Card>

docs/edge/ar/guides/concepts/evaluating-use-cases.mdx

@@ -0,0 +1,485 @@
+---
+title: تقييم حالات الاستخدام لـ CrewAI
+description: تعلم كيفية تقييم احتياجات تطبيقات الذكاء الاصطناعي واختيار النهج الصحيح بين Crews وFlows بناءً على متطلبات التعقيد والدقة.
+icon: scale-balanced
+mode: "wide"
+---
+
+## فهم إطار القرار
+
+عند بناء تطبيقات ذكاء اصطناعي مع CrewAI، أحد أهم القرارات التي ستتخذها هو اختيار النهج الصحيح لحالة الاستخدام المحددة. هل يجب استخدام Crew؟ أم Flow؟ أم مزيج من كليهما؟ سيساعدك هذا الدليل على تقييم متطلباتك واتخاذ قرارات معمارية مدروسة.
+
+في جوهر هذا القرار فهم العلاقة بين **التعقيد** و**الدقة** في تطبيقك:
+
+<Frame caption="مصفوفة التعقيد مقابل الدقة لتطبيقات CrewAI">
+  <img src="/images/complexity_precision.png" alt="مصفوفة التعقيد مقابل الدقة" />
+</Frame>
+
+تساعد هذه المصفوفة في تصور كيف تتوافق النهج المختلفة مع متطلبات متفاوتة للتعقيد والدقة. لنستكشف ما يعنيه كل ربع وكيف يوجه خياراتك المعمارية.
+
+## شرح مصفوفة التعقيد-الدقة
+
+### ما هو التعقيد؟
+
+في سياق تطبيقات CrewAI، يشير **التعقيد** إلى:
+
+- عدد الخطوات أو العمليات المميزة المطلوبة
+- تنوع المهام التي يجب تنفيذها
+- التبعيات المتبادلة بين المكونات المختلفة
+- الحاجة للمنطق الشرطي والتفرع
+- تطور سير العمل الكلي
+
+### ما هي الدقة؟
+
+**الدقة** في هذا السياق تشير إلى:
+
+- الدقة المطلوبة في المخرجات النهائية
+- الحاجة لنتائج منظمة وقابلة للتنبؤ
+- أهمية إمكانية التكرار
+- مستوى التحكم المطلوب في كل خطوة
+- تحمّل التباين في المخرجات
+
+### الأرباع الأربعة
+
+#### 1. تعقيد منخفض، دقة منخفضة
+
+**الخصائص:**
+- مهام بسيطة ومباشرة
+- تحمّل بعض التباين في المخرجات
+- عدد محدود من الخطوات
+- تطبيقات إبداعية أو استكشافية
+
+**النهج الموصى به:** Crews بسيطة مع عدد قليل من الـ Agents
+
+**أمثلة على حالات الاستخدام:**
+- إنشاء محتوى أساسي
+- العصف الذهني
+- مهام التلخيص البسيطة
+- مساعدة الكتابة الإبداعية
+
+#### 2. تعقيد منخفض، دقة عالية
+
+**الخصائص:**
+- سير عمل بسيطة تتطلب مخرجات دقيقة ومنظمة
+- حاجة لنتائج قابلة للتكرار
+- خطوات محدودة مع متطلبات دقة عالية
+- غالبًا تتضمن معالجة أو تحويل بيانات
+
+**النهج الموصى به:** Flows مع استدعاءات LLM مباشرة أو Crews بسيطة مع مخرجات منظمة
+
+**أمثلة على حالات الاستخدام:**
+- استخراج البيانات وتحويلها
+- ملء النماذج والتحقق منها
+- إنشاء محتوى منظم (JSON، XML)
+- مهام التصنيف البسيطة
+
+#### 3. تعقيد عالٍ، دقة منخفضة
+
+**الخصائص:**
+- عمليات متعددة المراحل بخطوات كثيرة
+- مخرجات إبداعية أو استكشافية
+- تفاعلات معقدة بين المكونات
+- تحمّل التباين في النتائج النهائية
+
+**النهج الموصى به:** Crews معقدة مع عدة Agents متخصصة
+
+**أمثلة على حالات الاستخدام:**
+- البحث والتحليل
+- خطوط إنتاج المحتوى
+- تحليل البيانات الاستكشافي
+- حل المشكلات الإبداعي
+
+#### 4. تعقيد عالٍ، دقة عالية
+
+**الخصائص:**
+- سير عمل معقدة تتطلب مخرجات منظمة
+- خطوات مترابطة متعددة مع متطلبات دقة صارمة
+- حاجة لمعالجة متطورة ونتائج دقيقة معًا
+- غالبًا تطبيقات حرجة المهمة
+
+**النهج الموصى به:** Flows تنسّق عدة Crews مع خطوات تحقق
+
+**أمثلة على حالات الاستخدام:**
+- أنظمة دعم القرار المؤسسية
+- خطوط معالجة بيانات معقدة
+- معالجة مستندات متعددة المراحل
+- تطبيقات الصناعات المنظمة
+
+## الاختيار بين Crews وFlows
+
+### متى تختار Crews
+
+الـ Crews مثالية عندما:
+
+1. **تحتاج ذكاء تعاوني** - عدة Agents بتخصصات مختلفة تحتاج للعمل معًا
+2. **المشكلة تتطلب تفكيرًا ناشئًا** - الحل يستفيد من منظورات ونُهج مختلفة
+3. **المهمة إبداعية أو تحليلية بالأساس** - العمل يتضمن بحثًا أو إنشاء محتوى أو تحليل
+4. **تقدّر القدرة على التكيف على الهيكل الصارم** - سير العمل يمكن أن يستفيد من استقلالية الـ Agent
+5. **تنسيق المخرجات يمكن أن يكون مرنًا نوعًا ما** - بعض التباين في هيكل المخرجات مقبول
+
+```python
+# Example: Research Crew for market analysis
+from crewai import Agent, Crew, Process, Task
+
+# Create specialized agents
+researcher = Agent(
+    role="Market Research Specialist",
+    goal="Find comprehensive market data on emerging technologies",
+    backstory="You are an expert at discovering market trends and gathering data."
+)
+
+analyst = Agent(
+    role="Market Analyst",
+    goal="Analyze market data and identify key opportunities",
+    backstory="You excel at interpreting market data and spotting valuable insights."
+)
+
+# Define their tasks
+research_task = Task(
+    description="Research the current market landscape for AI-powered healthcare solutions",
+    expected_output="Comprehensive market data including key players, market size, and growth trends",
+    agent=researcher
+)
+
+analysis_task = Task(
+    description="Analyze the market data and identify the top 3 investment opportunities",
+    expected_output="Analysis report with 3 recommended investment opportunities and rationale",
+    agent=analyst,
+    context=[research_task]
+)
+
+# Create the crew
+market_analysis_crew = Crew(
+    agents=[researcher, analyst],
+    tasks=[research_task, analysis_task],
+    process=Process.sequential,
+    verbose=True
+)
+
+# Run the crew
+result = market_analysis_crew.kickoff()
+```
+
+### متى تختار Flows
+
+الـ Flows مثالية عندما:
+
+1. **تحتاج تحكمًا دقيقًا في التنفيذ** - سير العمل يتطلب تسلسلًا دقيقًا وإدارة حالة
+2. **التطبيق له متطلبات حالة معقدة** - تحتاج لصيانة وتحويل الحالة عبر خطوات متعددة
+3. **تحتاج مخرجات منظمة وقابلة للتنبؤ** - التطبيق يتطلب نتائج متسقة ومنسّقة
+4. **سير العمل يتضمن منطقًا شرطيًا** - مسارات مختلفة يجب اتخاذها بناءً على نتائج وسيطة
+5. **تحتاج الجمع بين AI وكود إجرائي** - الحل يتطلب قدرات AI وبرمجة تقليدية معًا
+
+```python
+# Example: Customer Support Flow with structured processing
+from crewai.flow.flow import Flow, listen, router, start
+from pydantic import BaseModel
+from typing import List, Dict
+
+# Define structured state
+class SupportTicketState(BaseModel):
+    ticket_id: str = ""
+    customer_name: str = ""
+    issue_description: str = ""
+    category: str = ""
+    priority: str = "medium"
+    resolution: str = ""
+    satisfaction_score: int = 0
+
+class CustomerSupportFlow(Flow[SupportTicketState]):
+    @start()
+    def receive_ticket(self):
+        self.state.ticket_id = "TKT-12345"
+        self.state.customer_name = "Alex Johnson"
+        self.state.issue_description = "Unable to access premium features after payment"
+        return "Ticket received"
+
+    @listen(receive_ticket)
+    def categorize_ticket(self, _):
+        from crewai import LLM
+        llm = LLM(model="openai/gpt-4o-mini")
+
+        prompt = f"""
+        Categorize the following customer support issue into one of these categories:
+        - Billing
+        - Account Access
+        - Technical Issue
+        - Feature Request
+        - Other
+
+        Issue: {self.state.issue_description}
+
+        Return only the category name.
+        """
+
+        self.state.category = llm.call(prompt).strip()
+        return self.state.category
+
+    @router(categorize_ticket)
+    def route_by_category(self, category):
+        return category.lower().replace(" ", "_")
+
+    @listen("billing")
+    def handle_billing_issue(self):
+        self.state.priority = "high"
+        return "Billing issue handled"
+
+    @listen("account_access")
+    def handle_access_issue(self):
+        self.state.priority = "high"
+        return "Access issue handled"
+
+    @listen("billing", "account_access", "technical_issue", "feature_request", "other")
+    def resolve_ticket(self, resolution_info):
+        self.state.resolution = f"Issue resolved: {resolution_info}"
+        return self.state.resolution
+
+# Run the flow
+support_flow = CustomerSupportFlow()
+result = support_flow.kickoff()
+```
+
+### متى تجمع بين Crews وFlows
+
+أكثر التطبيقات تطورًا غالبًا تستفيد من الجمع بين Crews وFlows:
+
+1. **عمليات معقدة متعددة المراحل** - استخدم Flows لتنسيق العملية الكلية وCrews للمهام الفرعية المعقدة
+2. **تطبيقات تتطلب إبداعًا وهيكلاً معًا** - استخدم Crews للمهام الإبداعية وFlows للمعالجة المنظمة
+3. **تطبيقات AI مؤسسية** - استخدم Flows لإدارة الحالة وتدفق العمليات مع الاستفادة من Crews للعمل المتخصص
+
+```python
+# Example: Content Production Pipeline combining Crews and Flows
+from crewai.flow.flow import Flow, listen, start
+from crewai import Agent, Crew, Process, Task
+from pydantic import BaseModel
+from typing import List, Dict
+
+class ContentState(BaseModel):
+    topic: str = ""
+    target_audience: str = ""
+    content_type: str = ""
+    outline: Dict = {}
+    draft_content: str = ""
+    final_content: str = ""
+    seo_score: int = 0
+
+class ContentProductionFlow(Flow[ContentState]):
+    @start()
+    def initialize_project(self):
+        self.state.topic = "Sustainable Investing"
+        self.state.target_audience = "Millennial Investors"
+        self.state.content_type = "Blog Post"
+        return "Project initialized"
+
+    @listen(initialize_project)
+    def create_outline(self, _):
+        researcher = Agent(
+            role="Content Researcher",
+            goal=f"Research {self.state.topic} for {self.state.target_audience}",
+            backstory="You are an expert researcher with deep knowledge of content creation."
+        )
+
+        outliner = Agent(
+            role="Content Strategist",
+            goal=f"Create an engaging outline for a {self.state.content_type}",
+            backstory="You excel at structuring content for maximum engagement."
+        )
+
+        research_task = Task(
+            description=f"Research {self.state.topic} focusing on what would interest {self.state.target_audience}",
+            expected_output="Comprehensive research notes with key points and statistics",
+            agent=researcher
+        )
+
+        outline_task = Task(
+            description=f"Create an outline for a {self.state.content_type} about {self.state.topic}",
+            expected_output="Detailed content outline with sections and key points",
+            agent=outliner,
+            context=[research_task]
+        )
+
+        outline_crew = Crew(
+            agents=[researcher, outliner],
+            tasks=[research_task, outline_task],
+            process=Process.sequential,
+            verbose=True
+        )
+
+        result = outline_crew.kickoff()
+
+        import json
+        try:
+            self.state.outline = json.loads(result.raw)
+        except:
+            self.state.outline = {"sections": result.raw}
+
+        return "Outline created"
+
+    @listen(create_outline)
+    def write_content(self, _):
+        writer = Agent(
+            role="Content Writer",
+            goal=f"Write engaging content for {self.state.target_audience}",
+            backstory="You are a skilled writer who creates compelling content."
+        )
+
+        editor = Agent(
+            role="Content Editor",
+            goal="Ensure content is polished, accurate, and engaging",
+            backstory="You have a keen eye for detail and a talent for improving content."
+        )
+
+        writing_task = Task(
+            description=f"Write a {self.state.content_type} about {self.state.topic} following this outline: {self.state.outline}",
+            expected_output="Complete draft content in markdown format",
+            agent=writer
+        )
+
+        editing_task = Task(
+            description="Edit and improve the draft content for clarity, engagement, and accuracy",
+            expected_output="Polished final content in markdown format",
+            agent=editor,
+            context=[writing_task]
+        )
+
+        writing_crew = Crew(
+            agents=[writer, editor],
+            tasks=[writing_task, editing_task],
+            process=Process.sequential,
+            verbose=True
+        )
+
+        result = writing_crew.kickoff()
+        self.state.final_content = result.raw
+
+        return "Content created"
+
+    @listen(write_content)
+    def optimize_for_seo(self, _):
+        from crewai import LLM
+        llm = LLM(model="openai/gpt-4o-mini")
+
+        prompt = f"""
+        Analyze this content for SEO effectiveness for the keyword "{self.state.topic}".
+        Rate it on a scale of 1-100 and provide 3 specific recommendations for improvement.
+
+        Content: {self.state.final_content[:1000]}... (truncated for brevity)
+
+        Format your response as JSON with the following structure:
+        {{
+            "score": 85,
+            "recommendations": [
+                "Recommendation 1",
+                "Recommendation 2",
+                "Recommendation 3"
+            ]
+        }}
+        """
+
+        seo_analysis = llm.call(prompt)
+
+        import json
+        try:
+            analysis = json.loads(seo_analysis)
+            self.state.seo_score = analysis.get("score", 0)
+            return analysis
+        except:
+            self.state.seo_score = 50
+            return {"score": 50, "recommendations": ["Unable to parse SEO analysis"]}
+
+# Run the flow
+content_flow = ContentProductionFlow()
+result = content_flow.kickoff()
+```
+
+## إطار التقييم العملي
+
+لتحديد النهج الصحيح لحالة استخدامك المحددة، اتبع إطار التقييم التدريجي هذا:
+
+### الخطوة 1: تقييم التعقيد
+
+قيّم تعقيد تطبيقك على مقياس من 1-10 من خلال النظر في:
+
+1. **عدد الخطوات**: كم عدد العمليات المميزة المطلوبة؟
+   - 1-3 خطوات: تعقيد منخفض (1-3)
+   - 4-7 خطوات: تعقيد متوسط (4-7)
+   - 8+ خطوات: تعقيد عالٍ (8-10)
+
+2. **التبعيات المتبادلة**: ما مدى ترابط الأجزاء المختلفة؟
+   - تبعيات قليلة: تعقيد منخفض (1-3)
+   - بعض التبعيات: تعقيد متوسط (4-7)
+   - تبعيات معقدة كثيرة: تعقيد عالٍ (8-10)
+
+3. **المنطق الشرطي**: ما مقدار التفرع وصنع القرار المطلوب؟
+   - عملية خطية: تعقيد منخفض (1-3)
+   - بعض التفرع: تعقيد متوسط (4-7)
+   - أشجار قرار معقدة: تعقيد عالٍ (8-10)
+
+4. **المعرفة التخصصية**: ما مدى تخصص المعرفة المطلوبة؟
+   - معرفة عامة: تعقيد منخفض (1-3)
+   - بعض المعرفة المتخصصة: تعقيد متوسط (4-7)
+   - خبرة عميقة في مجالات متعددة: تعقيد عالٍ (8-10)
+
+احسب متوسط درجتك لتحديد التعقيد الكلي.
+
+### الخطوة 2: تقييم متطلبات الدقة
+
+قيّم متطلبات الدقة على مقياس من 1-10 من خلال النظر في:
+
+1. **هيكل المخرجات**: ما مدى التنظيم المطلوب في المخرجات؟
+   - نص حر: دقة منخفضة (1-3)
+   - شبه منظم: دقة متوسطة (4-7)
+   - منسّق بشكل صارم (JSON، XML): دقة عالية (8-10)
+
+2. **احتياجات الدقة**: ما أهمية الدقة الواقعية؟
+   - محتوى إبداعي: دقة منخفضة (1-3)
+   - محتوى معلوماتي: دقة متوسطة (4-7)
+   - معلومات حرجة: دقة عالية (8-10)
+
+3. **إمكانية التكرار**: ما مدى اتساق النتائج عبر التشغيلات؟
+   - التباين مقبول: دقة منخفضة (1-3)
+   - بعض الاتساق مطلوب: دقة متوسطة (4-7)
+   - تكرار دقيق مطلوب: دقة عالية (8-10)
+
+4. **تحمّل الأخطاء**: ما تأثير الأخطاء؟
+   - تأثير منخفض: دقة منخفضة (1-3)
+   - تأثير معتدل: دقة متوسطة (4-7)
+   - تأثير عالٍ: دقة عالية (8-10)
+
+احسب متوسط درجتك لتحديد متطلبات الدقة الكلية.
+
+### الخطوة 3: التعيين على المصفوفة
+
+ارسم درجات التعقيد والدقة على المصفوفة:
+
+- **تعقيد منخفض (1-4)، دقة منخفضة (1-4)**: Crews بسيطة
+- **تعقيد منخفض (1-4)، دقة عالية (5-10)**: Flows مع استدعاءات LLM مباشرة
+- **تعقيد عالٍ (5-10)، دقة منخفضة (1-4)**: Crews معقدة
+- **تعقيد عالٍ (5-10)، دقة عالية (5-10)**: Flows تنسّق Crews
+
+### الخطوة 4: مراعاة عوامل إضافية
+
+بالإضافة إلى التعقيد والدقة، ضع في اعتبارك:
+
+1. **وقت التطوير**: غالبًا ما تكون Crews أسرع في النماذج الأولية
+2. **احتياجات الصيانة**: توفر Flows قابلية صيانة أفضل على المدى الطويل
+3. **خبرة الفريق**: ضع في اعتبارك ألفة فريقك مع النُهج المختلفة
+4. **متطلبات التوسع**: عادةً ما تتوسع Flows بشكل أفضل للتطبيقات المعقدة
+5. **احتياجات التكامل**: ضع في اعتبارك كيف سيتكامل الحل مع الأنظمة الحالية
+
+## الخلاصة
+
+الاختيار بين Crews وFlows — أو الجمع بينهما — قرار معماري حاسم يؤثر على فعالية وقابلية صيانة وتوسع تطبيق CrewAI. من خلال تقييم حالة الاستخدام على أبعاد التعقيد والدقة، يمكنك اتخاذ قرارات مدروسة تتماشى مع متطلباتك المحددة.
+
+تذكر أن أفضل نهج غالبًا يتطور مع نضج تطبيقك. ابدأ بأبسط حل يلبي احتياجاتك، وكن مستعدًا لصقل بنيتك مع اكتساب الخبرة ووضوح المتطلبات.
+
+<Check>
+لديك الآن إطار لتقييم حالات استخدام CrewAI واختيار النهج الصحيح بناءً على متطلبات التعقيد والدقة. سيساعدك هذا في بناء تطبيقات AI أكثر فعالية وقابلية للصيانة والتوسع.
+</Check>
+
+## الخطوات التالية
+
+- تعلم المزيد عن [صياغة Agents فعّالة](/ar/guides/agents/crafting-effective-agents)
+- استكشف [بناء أول Crew](/ar/guides/crews/first-crew)
+- تعمّق في [إتقان إدارة حالة Flow](/ar/guides/flows/mastering-flow-state)
+- اطلع على [المفاهيم الأساسية](/ar/concepts/agents) لفهم أعمق

docs/edge/ar/guides/crews/first-crew.mdx

@@ -0,0 +1,140 @@
+---
+title: ابنِ أول Crew
+description: دليل خطوة بخطوة لإنشاء فريق AI تعاوني باستخدام تهيئة JSON-first.
+icon: users-gear
+mode: "wide"
+---
+
+## بناء Crew للبحث
+
+في هذا الدليل ستنشئ crew من Agentين: واحد للبحث وآخر لكتابة تقرير markdown. مشاريع الـ crew الجديدة هي JSON-first: تُعرّف الـ Agents في `agents/*.jsonc`، وتُعرّف المهام وإعدادات الـ crew في `crew.jsonc`، ويحمّل `crewai run` هذا التعريف مباشرة.
+
+### المتطلبات
+
+1. تثبيت CrewAI من [دليل التثبيت](/ar/installation)
+2. إعداد مفتاح LLM من [دليل LLMs](/ar/concepts/llms#setting-up-your-llm)
+3. مفتاح [Serper.dev](https://serper.dev/) إذا أردت استخدام البحث على الويب
+
+## الخطوة 1: إنشاء Crew جديدة
+
+```bash
+crewai create crew research_crew
+cd research_crew
+```
+
+البنية الناتجة:
+
+```text
+research_crew/
+├── .gitignore
+├── .env
+├── agents/
+│   └── researcher.jsonc
+├── crew.jsonc
+├── knowledge/
+├── pyproject.toml
+├── README.md
+├── skills/
+└── tools/
+```
+
+<Tip>
+إذا احتجت إلى البنية القديمة التي تحتوي على `crew.py` و `config/agents.yaml` و `config/tasks.yaml`، استخدم `crewai create crew research_crew --classic`.
+</Tip>
+
+## الخطوة 2: تعريف الـ Agents
+
+عدّل ملف `agents/researcher.jsonc` الذي أنشأه القالب، ثم أضف `agents/analyst.jsonc`. يجب أن تطابق أسماء الملفات الأسماء المشار إليها في `crew.jsonc`.
+
+```jsonc agents/researcher.jsonc
+{
+  "role": "Senior Research Specialist for {topic}",
+  "goal": "Find comprehensive and accurate information about {topic}, with a focus on recent developments and key insights.",
+  "backstory": "You are an experienced research specialist who organizes complex information into clear, useful notes.",
+  // استبدله بالنموذج الذي تستخدمه، مثل "openai/gpt-4o".
+  "llm": "provider/model-id",
+  "tools": ["SerperDevTool"],
+  "settings": {
+    "verbose": true,
+    "allow_delegation": false
+  }
+}
+```
+
+```jsonc agents/analyst.jsonc
+{
+  "role": "Report Analyst for {topic}",
+  "goal": "Turn research findings into a clear, well-structured report.",
+  "backstory": "You are a careful analyst with strong technical writing skills and a talent for extracting useful insights.",
+  // استبدله بالنموذج الذي تستخدمه، مثل "openai/gpt-4o".
+  "llm": "provider/model-id",
+  "settings": {
+    "verbose": true,
+    "allow_delegation": false
+  }
+}
+```
+
+استبدل `provider/model-id` بالنموذج الذي تستخدمه، مثل `openai/gpt-4o` أو `anthropic/claude-sonnet-4-6` أو `gemini/gemini-2.0-flash-001`.
+
+## الخطوة 3: تعريف المهام وإعدادات الـ Crew
+
+استبدل `crew.jsonc` بما يلي:
+
+```jsonc crew.jsonc
+{
+  "name": "Research Crew",
+  "agents": ["researcher", "analyst"],
+  "tasks": [
+    {
+      "name": "research_task",
+      "description": "Conduct thorough research on {topic}. Focus on key concepts, recent developments, major challenges, notable applications, and future outlook.",
+      "expected_output": "A comprehensive research document with organized sections, specific facts, and useful examples about {topic}.",
+      "agent": "researcher"
+    },
+    {
+      "name": "analysis_task",
+      "description": "Analyze the research findings and create a polished report on {topic}. Include an executive summary, key insights, trend analysis, and recommendations.",
+      "expected_output": "A professional markdown report with clear headings, a concise summary, main findings, and recommendations.",
+      "agent": "analyst",
+      "context": ["research_task"],
+      "output_file": "output/report.md",
+      "markdown": true
+    }
+  ],
+  "process": "sequential",
+  "verbose": true,
+  "memory": true,
+  "inputs": {
+    "topic": "Artificial Intelligence in Healthcare"
+  }
+}
+```
+
+يشير `context` إلى أسماء مهام سابقة، لذلك يحصل analyst على مخرجات مهمة البحث. يوفر `inputs` قيمة افتراضية لـ `{topic}`. إذا حذفت القيمة الافتراضية، سيطلبها `crewai run`.
+
+## الخطوة 4: متغيرات البيئة
+
+عدّل `.env`:
+
+```sh
+SERPER_API_KEY=your_serper_api_key
+# أضف مفتاح مزود النموذج أيضًا.
+```
+
+## الخطوة 5: التثبيت والتشغيل
+
+```bash
+crewai install
+crewai run
+```
+
+بعد انتهاء التشغيل، افتح `output/report.md`.
+
+<Warning>
+شغّل مشاريع JSON crew من مصادر تثق بها فقط. أدوات `custom:<name>` ومراجع `{"python": "module.attribute"}` تنفذ Python محليًا عند تحميل الـ crew.
+</Warning>
+
+<Check>
+أصبحت لديك crew تعمل بأسلوب JSON-first تبحث في موضوع وتكتب تقريرًا.
+</Check>

docs/edge/ar/guides/flows/conversational-flows.mdx

@@ -0,0 +1,473 @@
+---
+title: تدفقات المحادثة
+description: أنشئ تطبيقات دردشة متعددة الجولات مع kickoff لكل جولة وسجل الرسائل وتوجيه النية والتتبع وجسور WebSocket.
+icon: comments
+mode: "wide"
+---
+
+## نظرة عامة
+
+تعامل التطبيقات المحادثية مع كل سطر من المستخدم كـ **تشغيل flow جديد** بنفس **معرّف الجلسة**. توفر CrewAI مساعدات لسجل الرسائل وتصنيف النية الاختياري وتأجيل التتبع وجسور الواجهة، إضافة إلى REPL محلي `flow.chat()` للتدفقات المحادثية.
+
+| المفهوم | التنفيذ |
+|---------|---------|
+| معرّف الجلسة | `handle_turn(..., session_id=...)` → `kickoff(inputs={"id": ...})` → `state.id` |
+| سطر المستخدم | `handle_turn(message)` يضيف الرسالة إلى `state.messages` قبل تشغيل الرسم |
+| اكتمال الجولة | `FlowFinished` لهذا **التشغيل** فقط؛ تستمر المحادثة في `handle_turn` التالي |
+| تتبع الجلسة | `ConversationConfig(defer_trace_finalization=True)` + `finalize_session_traces()` |
+
+## واجهات الجولات
+
+استخدم **`flow.handle_turn(message, session_id=...)`** لكل رسالة مستخدم من REST أو WebSocket أو الاختبارات أو الواجهات المخصصة. استخدم **`flow.chat()`** عندما تريد حلقة دردشة محلية في الطرفية لـ `Flow` محادثي.
+
+لا يقبل `Flow.kickoff()` الوسيطين `user_message=` أو `session_id=`. في التدفقات المحادثية، يخزن `handle_turn()` الرسالة المعلقة ويستدعي داخلياً `kickoff(inputs={"id": session_id})`.
+
+| API | الاستخدام |
+|-----|-----------|
+| `handle_turn(message, session_id=...)` | غلاف مريح لجولة واحدة في `Flow` محادثي |
+| `chat()` | REPL محلي في الطرفية لـ `Flow` محادثي |
+| `kickoff(inputs={...})` | تشغيل متقدم للـ flow بدون معالجة جولة محادثية |
+| `ask()` | مطالبة حاجزة **داخل** خطوة واحدة |
+| `@human_feedback` | الموافقة/الرفض على **مخرجات خطوة** — وليس السطر التالي |
+| `ChatSession.handle_turn(...)` | طبقة نقل فوق `handle_turn` |
+
+## بداية سريعة
+
+```python
+from uuid import uuid4
+
+from crewai import Flow
+from crewai.flow import listen
+from crewai.experimental.conversational import (
+    ConversationConfig,
+    ConversationState,
+)
+
+
+@ConversationConfig(defer_trace_finalization=True)
+class SupportFlow(Flow[ConversationState]):
+    conversational = True
+
+    def route_turn(self, context):
+        message = (self.state.current_user_message or "").lower()
+        if "طلب" in message or "order" in message:
+            return "order"
+        if "وداع" in message or "goodbye" in message:
+            return "goodbye"
+        return "help"
+
+    @listen("order")
+    def handle_order(self):
+        reply = "طلبك في الطريق."
+        self.append_assistant_message(reply)
+        return reply
+
+    @listen("help")
+    def handle_help(self):
+        reply = "كيف يمكنني المساعدة؟"
+        self.append_assistant_message(reply)
+        return reply
+
+    @listen("goodbye")
+    def handle_goodbye(self):
+        reply = "وداعاً!"
+        self.append_assistant_message(reply)
+        return reply
+
+
+session_id = str(uuid4())
+flow = SupportFlow()
+
+try:
+    flow.handle_turn("أين طلبي؟", session_id=session_id)
+    flow.handle_turn("وماذا عن الإرجاع؟", session_id=session_id)
+finally:
+    flow.finalize_session_traces()
+```
+
+## دورة حياة الجولة
+
+كل `handle_turn` يشغّل:
+
+1. **`_configure_conversational_kickoff`** — دمج `session_id` / `user_message` في `inputs` وتطبيق `ConversationalConfig`.
+2. **استعادة الحالة** — عند وجود `inputs["id"]` و`@persist`.
+3. **`FlowStarted`** — في أول جولة للجلسة المؤجلة فقط.
+4. **`prepare_conversational_turn`** — إضافة رسالة المستخدم و`last_user_message` وتصنيف اختياري.
+5. **تنفيذ الرسم** — `@start` → `@router` → معالجات `@listen`.
+6. **نهاية التشغيل** — يُتخطى `flow_finished` والتتبع لكل جولة عند التأجيل؛ `Agent.kickoff()` / crews لا تغلق دفعة الأب.
+
+استدعِ **`append_assistant_message(reply)`** في المعالجات. سطر المستخدم محفوظ عبر `handle_turn` — لا تُضفه مرة أخرى.
+
+## `ConversationalConfig` (افتراضيات على مستوى الصنف)
+
+عيّن على صنف `Flow` كـ `conversational_config: ClassVar[ConversationalConfig | None]`.
+
+| الحقل | الافتراضي | الغرض |
+|-------|-----------|--------|
+| `default_intents` | `None` | تسميات outcome للتصنيف التلقائي قبل kickoff |
+| `intent_llm` | `None` | نموذج التصنيف (مطلوب عند وجود intents) |
+| `interactive_prompt` | `"You: "` | مطالبة `kickoff(interactive=True)` |
+| `interactive_timeout` | `None` | مهلة لكل سطر في الوضع التفاعلي |
+| `exit_commands` | `exit`, `quit` | كلمات إنهاء الوضع التفاعلي |
+| `defer_trace_finalization` | `True` | إبقاء دفعة trace واحدة مفتوحة بين الجولات |
+
+يمكن التجاوز لكل kickoff عبر `intents=` و`intent_llm=`.
+
+## `ChatState` (شكل الحالة الموصى به للحفظ)
+
+```python
+from crewai.flow import ChatState
+
+
+class MyChatState(ChatState):
+    # موروث: id, messages, last_user_message, last_intent, session_ready
+    research_turn_count: int = 0
+    custom_flag: bool = False
+```
+
+| الحقل | الدور |
+|-------|------|
+| `id` | UUID الجلسة (مثل `session_id` / `inputs["id"]`) |
+| `messages` | قائمة `{role, content}` لسجل LLM |
+| `last_user_message` | آخر سطر مستخدم في هذه الجولة |
+| `last_intent` | تسمية المسار بعد التصنيف (إن وُجد) |
+| `session_ready` | علم bootstrap لمرة واحدة |
+
+`ConversationalInputs` هو `TypedDict` لـ `kickoff(inputs={...})`: `id`, `user_message`, `last_intent`.
+
+## API المحادثة على `Flow`
+
+### معاملات `kickoff` / `kickoff_async`
+
+| المعامل | الغرض |
+|---------|--------|
+| `user_message` | نص هذه الجولة (أو `{"role": "user", "content": "..."}`) |
+| `session_id` | UUID المحادثة → `inputs["id"]` / `state.id` |
+| `intents` | تسميات outcome لـ `classify_intent` قبل kickoff |
+| `intent_llm` | LLM للتصنيف (مطلوب مع `intents`) |
+| `interactive` | حلقة CLI عبر `ask()` (للعروض المحلية فقط) |
+| `interactive_prompt` | مطالبة الوضع التفاعلي |
+| `interactive_timeout` | مهلة `ask()` لكل سطر |
+| `exit_commands` | كلمات إنهاء الوضع التفاعلي |
+| `inputs` | حقول حالة إضافية |
+| `restore_from_state_id` | استنساخ من flow محفوظ آخر |
+
+### سمات المثيل
+
+| السمة | الغرض |
+|-------|--------|
+| `conversational_config` | افتراضيات `ConversationalConfig` على مستوى الصنف |
+| `defer_trace_finalization` | علم المثيل؛ يُضبط تلقائياً من config عند kickoff |
+| `suppress_flow_events` | يخفي لوحات console؛ **التتبع يُسجّل** |
+| `stream` | بث؛ مع `ChatSession.handle_turn(..., stream=True)` |
+
+### طرق وخصائص
+
+| الاسم | الوصف |
+|------|--------|
+| `append_message(role, content, **extra)` | إضافة إلى `state.messages` |
+| `conversation_messages` | سجل للقراءة فقط لاستدعاءات LLM |
+| `classify_intent(text, outcomes, *, llm, context=None)` | تعيين outcome |
+| `receive_user_message(text, *, outcomes=None, llm=None)` | إضافة رسالة مستخدم؛ `last_intent` اختياري |
+| `finalize_session_traces()` | إصدار `flow_finished` المؤجل وإنهاء دفعة trace |
+| `_should_defer_trace_finalization()` | هل يُؤجل إنهاء trace لكل جولة |
+| `input_history` | سجل تدقيق مطالبات وردود `ask()` |
+
+### مساعدات الوحدة (`crewai.flow.conversation`)
+
+| الدالة | الوصف |
+|--------|--------|
+| `normalize_kickoff_inputs(...)` | دمج kwargs المحادثة في `inputs` |
+| `get_conversation_messages(flow)` | قراءة الرسائل من الحالة أو المخزن |
+| `append_message(flow, ...)` | مثل طريقة المثيل |
+| `prepare_conversational_turn(flow, ...)` | تهيئة الجولة (عادةً kickoff يستدعيها) |
+| `receive_user_message(flow, ...)` | مثل طريقة المثيل |
+| `set_state_field(flow, name, value)` | تعيين حقل dict أو Pydantic |
+| `get_conversational_config(flow)` | قراءة `conversational_config` |
+| `input_history_to_messages(entries)` | تحويل `input_history` لصيغة رسائل LLM |
+
+## أنماط توجيه النية
+
+### أ. تصنيف مسبق عبر `ConversationalConfig` (الأبسط)
+
+عيّن `default_intents` و`intent_llm`. كل kickoff يصنّف قبل `@router`؛ اقرأ `self.state.last_intent` في `route()`.
+
+### ب. تصنيف داخل `@router` (مطالبات أغنى)
+
+عيّن `default_intents=None` ليضيف kickoff الرسالة فقط. في `route()` استدعِ `classify_intent`:
+
+```python
+@router(bootstrap)
+def route(self):
+    intent = self.classify_intent(
+        self._routing_prompt(self.state.last_user_message),
+        ("GREETING", "ORDER", "RESEARCH", "GOODBYE"),
+        llm=self.conversational_config.intent_llm or "gpt-4o-mini",
+    )
+    self.state.last_intent = intent
+    return intent
+```
+
+للبحث على الويب أو أدوات متعددة الخطوات استخدم **`@listen("RESEARCH")`** مع `Agent.kickoff()` وأدوات — وليس `LLM.call()` فقط.
+
+## عندما ينتهي الـ flow ويستمر المستخدم
+
+`FlowFinished` يعني أن **تنفيذ الرسم هذا** اكتمل. تستمر المحادثة بـ `kickoff` آخر ونفس `session_id`. `@persist` يستعيد `messages` والأعلام والسياق.
+
+**نمط الحفظ:** يُفضّل `@persist` على **خطوة نهائية واحدة** (مثل `finalize`) وليس على صنف `Flow` بالكامل. الحفظ على مستوى الصنف بعد كل method قد يفقد تحديثات المعالجات في نفس الجولة.
+
+لا تستخدم `@human_feedback` لأسطر المتابعة في الدردشة إلا عند الحاجة لموافقة بشرية على مخرجات خطوة محددة.
+
+## `Flow` المحادثاتي (تجريبي)
+
+<Warning>
+  **ميزة تجريبية.** سطح `Flow` المحادثاتي (`conversational = True`،
+  `handle_turn`، `ConversationConfig`، `RouterConfig`،
+  `ConversationState`، الرسم البياني المدمج والمساعدات) يقع تحت
+  `crewai.experimental` وقد يتغير شكله قبل التخرج. ثبّت إصدار CrewAI إذا
+  كنت تعتمد على سلوك محدد، وراقب changelog للتحديثات الكاسرة. الملاحظات
+  والمشاكل مرحب بها.
+</Warning>
+
+فعّل الرسم المحادثاتي بتعيين `conversational = True` على صنف فرعي من `Flow`. عندئذٍ يُظهر `Flow` الأساسي رسم `@start` / `@router` / `converse_turn` / `end_conversation` مدمجاً، ويدير `state.messages`، ويُشغّل LLM التوجيه، ويبقي دفعة trace مفتوحة عبر الجولات. أنت تكتب **المسارات المخصصة** فقط؛ والإطار يتولى الباقي.
+
+استخدمه عندما تريد دردشة متعددة الجولات مع موجّه قائم على LLM ومعالجات لكل مسار دون توصيل دورة الحياة يدوياً. استخدم `Flow[ChatState]` (النمط الأدنى مستوى في الأعلى) عندما تحتاج تحكماً كاملاً.
+
+### مثال سريع
+
+```python
+from crewai import LLM, Flow
+from crewai.flow import listen
+from crewai.experimental.conversational import (
+    ConversationConfig,
+    ConversationState,
+    RouterConfig,
+)
+
+
+ROUTER_LLM = LLM(model="gpt-4o-mini")
+
+
+@ConversationConfig(
+    system_prompt="A multi-agent assistant for ordinary chat and tool-backed tasks.",
+    llm=ROUTER_LLM,
+    router=RouterConfig(),  # المسارات + الأوصاف تُكتشف تلقائياً من معالجات @listen
+)
+class SupportFlow(Flow[ConversationState]):
+    conversational = True
+
+    @listen("INTERNET_SEARCH")
+    def handle_internet_search(self) -> str:
+        """Fresh web research, current news, real-time lookups."""
+        ...
+        self.append_assistant_message(reply)
+        return reply
+
+    @listen("CREWAI_DOCS")
+    def handle_crewai_docs(self) -> str:
+        """Look up the CrewAI documentation for framework/API questions."""
+        ...
+        self.append_assistant_message(reply)
+        return reply
+
+
+flow = SupportFlow()
+try:
+    flow.handle_turn("ماذا يمكنك أن تفعل؟")                   # يوجَّه إلى converse (مدمج)
+    flow.handle_turn("ابحث في الويب عن أخبار الذكاء الاصطناعي.")  # يوجَّه إلى INTERNET_SEARCH
+    flow.handle_turn("لخص النتيجة الأولى.")                    # يعود إلى converse
+finally:
+    flow.finalize_session_traces()
+```
+
+للدردشة المحلية في الطرفية، استخدم `chat()`:
+
+```python
+def kickoff() -> None:
+    SupportFlow().chat()
+```
+
+يلف `chat()` استدعاءات `handle_turn()` داخل REPL، ويخرج عند `exit` / `quit`، ويتجاهل الأسطر الفارغة افتراضياً، ويستدعي `finalize_session_traces()` عند انتهاء الجلسة.
+
+### `ConversationConfig`
+
+مزخرف صنف يُلحق افتراضيات الدردشة على مستوى الصنف.
+
+| الحقل | الافتراضي | الغرض |
+|-------|-----------|-------|
+| `system_prompt` | `slices.conversational_system_prompt` من i18n | رسالة system يستخدمها `converse_turn` المدمج. مرر `""` للتعطيل التام. |
+| `llm` | `None` | LLM المحادثة (يستخدمه `converse_turn` وكاحتياطي للموجّه). |
+| `router` | `None` | `RouterConfig` للتوجيه عبر LLM. بدونه، يسقط الـ flow دائماً إلى `converse`. |
+| `answer_from_history_prompt` | افتراضي الإطار | رسالة system للمسار الاختياري `answer_from_history`. |
+| `answer_from_history_llm` | `None` | يُفعّل الاختصار `answer_from_history` عند تعيينه. |
+| `intent_llm` | `None` | LLM لمسار التصنيف المسبق القديم `intents=`/`default_intents`. |
+| `default_intents` | `None` | تسميات النتائج للتصنيف المسبق القديم. |
+| `visible_agent_outputs` | `None` | `"all"` أو قائمة بأسماء الـ agents الذين تُرفع مخرجاتهم من `append_agent_result()` إلى رسائل عامة. |
+| `defer_trace_finalization` | `True` | يبقي دفعة trace واحدة مفتوحة عبر استدعاءات `handle_turn()`. |
+
+### `RouterConfig` وفهرس المسارات المُولَّد تلقائياً
+
+```python
+RouterConfig(
+    prompt="تأطير اختياري للنطاق (سياسة، صوت، شخصية).",
+    response_format=MyRoute,        # اختياري؛ يُولَّد تلقائياً عند الإغفال
+    llm=ROUTER_LLM,                  # يسقط إلى ConversationConfig.llm
+    routes=["INTERNET_SEARCH", "CREWAI_DOCS"],   # اختياري؛ يُستنتج من المستمعين
+    route_descriptions={
+        "INTERNET_SEARCH": "تجاوز الـ docstring لهذا المسار فقط.",
+    },
+    default_intent="converse",       # يُستخدم عند فشل LLM أو غيابه
+    fallback_intent="converse",      # يُستخدم عندما يعيد LLM مساراً غير صالح
+    intent_field="intent",
+)
+```
+
+تُبنى رسالة الموجّه إلى LLM تلقائياً. لكل مسار يختار الإطار وصفاً بهذا الترتيب من الأولوية:
+
+1. `RouterConfig.route_descriptions[label]` — تجاوز صريح.
+2. `Flow.builtin_route_descriptions[label]` — نص جاهز من الإطار لـ `converse` و`end` و`answer_from_history` (مصاغ لـ LLM التوجيه).
+3. أول سطر غير فارغ من docstring معالج `@listen(label)`.
+4. فارغ (المسار يظهر في الفهرس بلا وصف).
+
+عملياً، **إضافة مسار جديد = `@listen("X")` + docstring من سطر واحد**:
+
+```python
+@listen("INTERNET_SEARCH")
+def handle_internet_search(self) -> str:
+    """Fresh web research, current news, real-time lookups."""
+    ...
+```
+
+…وسيرى LLM التوجيه:
+
+```
+Routes:
+- CREWAI_DOCS: Look up the CrewAI documentation for framework/API questions.
+- INTERNET_SEARCH: Fresh web research, current news, real-time lookups.
+- converse: Ordinary chat, follow-ups, summaries, clarifications…
+- end: User signals the conversation is finished (goodbye, exit, done).
+```
+
+`RouterConfig.prompt` مخصص لـ **تأطير النطاق** (شخصية المساعد، قواعد العمل، النبرة). فهرس المسارات يُبنى تلقائياً — لا تُدرج المسارات في `prompt`؛ سيختل التزامن لحظة إضافة معالج جديد.
+
+### المسارات المدمجة
+
+| المسار | المعالج | الغرض |
+|--------|---------|-------|
+| `converse` | `converse_turn` | معالج الدردشة الافتراضي. يستدعي `ConversationConfig.llm` بـ system prompt + التاريخ القانوني للرسائل. |
+| `end` | `end_conversation` | يضبط `state.ended = True` ويُصدر رد إنهاء. |
+| `answer_from_history` | `answer_from_history_turn` | اختياري. يُوجَّه إليه عندما يكون `ConversationConfig.answer_from_history_llm` مُعيَّناً ويمكن الإجابة على الرسالة من التاريخ فقط. |
+
+يمكنك تجاوز أي من هذه بتعريف معالج بنفس الاسم في الصنف الفرعي.
+
+### دلالات `handle_turn()`
+
+`flow.handle_turn(message)` يُشغّل جولة واحدة:
+
+1. يعيد ضبط تعقّب التنفيذ لكل جولة (`_completed_methods`, `_method_outputs`) ليُعاد تشغيل الرسم — بدون ذلك، استدعاءات `kickoff` المتكررة على نفس النسخة ستُحدث دائرة قصر من الجولة الثانية لأن `Flow.kickoff_async` يعتبر `inputs={"id": ...}` استعادة من نقطة تفتيش.
+2. يُلحق رسالة المستخدم بـ `state.messages` ويضبط `current_user_message` / `last_user_message`. يُحافَظ على `last_intent` **من الجولة السابقة** كي يستخدمها LLM التوجيه كإشارة.
+3. يُشغّل `conversation_start` → `route_conversation` → معالج `@listen` المختار.
+4. يخزّن الموجّه قراره في `state.last_intent` (يكون مرئياً لسياق التوجيه في الجولة التالية).
+5. إذا أعاد معالجك سلسلة نصية ولم يستدعِ `append_assistant_message`، فإن `handle_turn` يُلحقها نيابةً عنك.
+
+استدعِ `handle_turn()` لرسائل الدردشة. استدعاء `kickoff(inputs={"id": ...})` مباشرةً يشغل الرسم بدون غلاف الجولة المحادثية.
+
+### `chat()` للـ REPL المحلي
+
+`flow.chat()` هو غلاف الطرفية الجاهز فوق `handle_turn()`:
+
+```python
+flow = SupportFlow()
+flow.chat()
+```
+
+يتولى الحلقة المحلية الشائعة:
+
+1. يطلب رسالة من المستخدم.
+2. يتوقف عند `exit` / `quit` أو `EOFError` أو `KeyboardInterrupt`.
+3. يستدعي `handle_turn(message, session_id=...)`.
+4. يطبع نتيجة المساعد.
+5. ينهي traces الجلسة المؤجلة داخل كتلة `finally`.
+
+خصص سلوك الطرفية عبر I/O قابل للحقن:
+
+```python
+flow.chat(
+    session_id="demo-session",
+    prompt="You: ",
+    assistant_prefix="Assistant: ",
+    exit_commands=("exit", "quit", "bye"),
+)
+```
+
+لتطبيقات الويب والـ workers الخلفية والاختبارات ووسائط النقل المخصصة، استمر في استخدام `handle_turn()` مباشرةً.
+
+### سلوك موجّه مخصص
+
+لتشغيل آثار جانبية (إعداد ناقل أحداث، قياس عن بُعد) في كل قرار توجيه، تجاوز `route_turn`:
+
+```python
+class SupportFlow(Flow[ConversationState]):
+    conversational = True
+
+    def route_turn(self, context: dict[str, Any]) -> str | None:
+        self.event_bus = MyBus(self)
+        return super().route_turn(context)
+```
+
+لتجاوز موجّه LLM واختيار مسار برمجياً، أعد سلسلة نصية من `route_turn`؛ إعادة `None` تسقط إلى `_route_with_config(...)`.
+
+### `append_assistant_message` و`append_agent_result`
+
+داخل معالج `@listen(label)`، اختر:
+
+- `self.append_assistant_message(text)` — يضيف جولة مساعد مرئية للمستخدم إلى `state.messages`. سيراها `converse_turn` في الجولة التالية.
+- `self.append_agent_result(agent_name, result, visibility="private")` — يسجّل حدثاً منظماً في `state.events` وموضوعاً في `state.agent_threads[agent_name]`. الرؤية العامة تستدعي `append_assistant_message` أيضاً. استخدم النتائج الخاصة للعمل الجانبي الذي يجب ألا يلوث التاريخ القانوني.
+
+يمكن لـ `ConversationConfig.visible_agent_outputs` رفع النتائج الخاصة لـ agents محددين إلى عامة عالمياً (`"all"` أو قائمة بالأسماء).
+
+## التتبع عبر الجولات
+
+مع `defer_trace_finalization=True` (افتراضي في `ConversationalConfig`):
+
+- **دفعة trace واحدة** لجلسة الدردشة.
+- **`flow_started`** في الجولة الأولى فقط؛ **`flow_finished`** مرة في `finalize_session_traces()`.
+- **`kickoff` لكل جولة** لا يطبع "Trace batch finalized".
+- **العمل المتداخل** (`Agent.kickoff()`, crews, Exa) يُلحق بدفعة **الأب**؛ flow داخلي من `AgentExecutor` لا يغلق دفعة الجلسة مبكراً.
+
+```python
+flow.chat(session_id=session_id)
+```
+
+`flow.chat()` يستدعي `finalize_session_traces()` نيابةً عنك. عندما تملك الحلقة عبر `handle_turn()` أو `kickoff(...)`، استدعِ `finalize_session_traces()` عند انتهاء الجلسة.
+
+`suppress_flow_events=True` يخفي لوحات Rich فقط؛ أحداث trace والـ methods تُصدر.
+
+### دورة حياة trace لـ `Flow` المحادثاتي
+
+يستخدم [`Flow` المحادثاتي](#flow-المحادثاتي-تجريبي) التجريبي نفس دورة حياة tracing: `defer_trace_finalization` افتراضياً `True`، فيبقي كل `handle_turn()` أثر الجلسة مفتوحاً. أنهِ دوماً عند نهاية الجلسة — لُف حلقتك بـ `try/finally` واستدعِ `flow.finalize_session_traces()` عند الخروج. بدون ذلك، تبقى الدفعة مفتوحة وقد لا تُصدَّر آخر محادثة أبداً.
+
+## البث
+
+اضبط `stream = True` على صنف `Flow`. عندئذٍ يُصدر `kickoff(...)` أحداث `assistant_delta` (وما يرتبط بها) عبر ناقل الأحداث القياسي.
+
+## الاستيراد
+
+```python
+from crewai.flow import (
+    ChatState,
+    ConversationalConfig,
+    ConversationalInputs,
+    Flow,
+    listen,
+    persist,
+    router,
+    start,
+)
+```
+
+## مراجع
+
+- [إتقان إدارة حالة Flow](/ar/guides/flows/mastering-flow-state)
+- [أنشئ أول Flow](/ar/guides/flows/first-flow)
+- Demo: `lib/crewai/runner_conversational_flow_simple.py` — REPL بسيط مع `RESEARCH` ووكيل Exa

docs/edge/ar/guides/flows/first-flow.mdx

@@ -0,0 +1,222 @@
+---
+title: ابنِ أول Flow لك
+description: تعلم كيفية إنشاء سير عمل منظمة قائمة على الأحداث مع تحكم دقيق في التنفيذ.
+icon: diagram-project
+mode: "wide"
+---
+
+## التحكم في سير عمل AI مع Flows
+
+تمثل CrewAI Flows المستوى التالي في تنسيق AI - الجمع بين القوة التعاونية لفرق Agents AI مع دقة ومرونة البرمجة الإجرائية. بينما تتفوق Crews في تعاون الـ Agents، تمنحك Flows تحكمًا دقيقًا في كيفية ووقت تفاعل المكونات المختلفة لنظام AI.
+
+في هذا الدليل، سنمشي عبر إنشاء CrewAI Flow قوي ينشئ دليلًا تعليميًا شاملاً حول أي موضوع.
+
+### ما يجعل Flows قوية
+
+تمكّنك Flows من:
+
+1. **الجمع بين أنماط تفاعل AI مختلفة** - استخدام Crews للمهام التعاونية المعقدة واستدعاءات LLM المباشرة للعمليات الأبسط والكود العادي للمنطق الإجرائي
+2. **بناء أنظمة قائمة على الأحداث** - تحديد كيفية استجابة المكونات لأحداث وتغييرات بيانات محددة
+3. **الحفاظ على الحالة عبر المكونات** - مشاركة وتحويل البيانات بين أجزاء مختلفة من تطبيقك
+4. **التكامل مع الأنظمة الخارجية** - ربط سير عمل AI بسلاسة مع قواعد البيانات وواجهات API وواجهات المستخدم
+5. **إنشاء مسارات تنفيذ معقدة** - تصميم فروع شرطية ومعالجة متوازية وسير عمل ديناميكية
+
+### المتطلبات المسبقة
+
+قبل البدء، تأكد من:
+
+1. تثبيت CrewAI باتباع [دليل التثبيت](/ar/installation)
+2. إعداد مفتاح API لنموذج LLM في بيئتك، باتباع [دليل إعداد LLM](/ar/concepts/llms#setting-up-your-llm)
+3. فهم أساسي لـ Python
+
+## الخطوة 1: إنشاء مشروع CrewAI Flow جديد
+
+```bash
+crewai create flow guide_creator_flow
+cd guide_creator_flow
+```
+
+<Frame caption="نظرة عامة على إطار عمل CrewAI">
+  <img src="/images/flows.png" alt="نظرة عامة على إطار عمل CrewAI" />
+</Frame>
+
+## الخطوة 2: فهم هيكل المشروع
+
+يستخدم الـ crew المبدئي المضمّن في مشروع Flow بنية Python/YAML الكلاسيكية. لاستخدام crew بنمط JSON-first داخل Flow، أنشئ `crew.jsonc` و `agents/*.jsonc` داخل مجلد الـ crew وحمّله عبر `crewai.project.load_crew` كما في [Flows](/ar/concepts/flows#building-your-crews).
+
+```
+guide_creator_flow/
+├── .gitignore
+├── pyproject.toml
+├── README.md
+├── .env
+└── src/
+    └── guide_creator_flow/
+        ├── __init__.py
+        ├── main.py
+        ├── crews/
+        │   └── poem_crew/
+        │       ├── config/
+        │       │   ├── agents.yaml
+        │       │   └── tasks.yaml
+        │       └── poem_crew.py
+        └── tools/
+            └── custom_tool.py
+```
+
+يوفر هذا الهيكل فصلاً واضحًا بين مكونات Flow المختلفة. سنعدّل هذا الهيكل لإنشاء Flow منشئ الدليل.
+
+## الخطوة 3: إضافة Crew كتابة المحتوى
+
+```bash
+crewai flow add-crew content-crew
+```
+
+## الخطوة 4: تهيئة Crew كتابة المحتوى
+
+سنهيئ crew كتابة المحتوى باستخدام JSONC. سنعرّف Agent للكتابة وAgent للمراجعة، ثم نحمّل `crew.jsonc` من خطوة Flow.
+
+1. أنشئ `src/guide_creator_flow/crews/content_crew/agents/content_writer.jsonc`:
+
+```jsonc
+{
+  "role": "Educational Content Writer",
+  "goal": "Create engaging, informative content that thoroughly explains the assigned topic and provides valuable insights to the reader.",
+  "backstory": "You are a talented educational writer who explains complex concepts in accessible language and organizes information clearly.",
+  "llm": "provider/model-id",
+  "settings": {
+    "verbose": true
+  }
+}
+```
+
+2. أنشئ `src/guide_creator_flow/crews/content_crew/agents/content_reviewer.jsonc`:
+
+```jsonc
+{
+  "role": "Educational Content Reviewer and Editor",
+  "goal": "Ensure content is accurate, comprehensive, well-structured, and consistent with previously written sections.",
+  "backstory": "You are a meticulous editor with an eye for detail, clarity, and coherence.",
+  "llm": "provider/model-id",
+  "settings": {
+    "verbose": true
+  }
+}
+```
+
+استبدل `provider/model-id` بالنموذج الذي تستخدمه، مثل `openai/gpt-4o` أو `gemini/gemini-2.0-flash-001` أو `anthropic/claude-sonnet-4-6`.
+
+3. أنشئ `src/guide_creator_flow/crews/content_crew/crew.jsonc`:
+
+```jsonc
+{
+  "name": "Content Crew",
+  "agents": ["content_writer", "content_reviewer"],
+  "tasks": [
+    {
+      "name": "write_section_task",
+      "description": "Write a comprehensive section on the topic: \"{section_title}\".\n\nSection description: {section_description}\nTarget audience: {audience_level} level learners\n\nYour content should begin with a brief introduction, explain key concepts clearly with examples, include practical applications where appropriate, end with a summary, and be approximately 500-800 words.\n\nPreviously written sections:\n{previous_sections}",
+      "expected_output": "A well-structured, comprehensive section in Markdown format that thoroughly explains the topic and is appropriate for the target audience.",
+      "agent": "content_writer",
+      "markdown": true
+    },
+    {
+      "name": "review_section_task",
+      "description": "Review and improve this section on \"{section_title}\":\n\n{draft_content}\n\nTarget audience: {audience_level} level learners\nPreviously written sections:\n{previous_sections}\n\nFix errors, improve clarity, verify consistency, enhance structure, and add missing key information.",
+      "expected_output": "An improved, polished version of the section that maintains the original structure but enhances clarity, accuracy, and consistency.",
+      "agent": "content_reviewer",
+      "context": ["write_section_task"],
+      "markdown": true
+    }
+  ],
+  "process": "sequential",
+  "verbose": true
+}
+```
+
+4. استبدل `src/guide_creator_flow/crews/content_crew/content_crew.py` بمحمل صغير:
+
+```python
+from pathlib import Path
+
+from crewai.project import load_crew
+
+
+def kickoff_content_crew(inputs: dict):
+    crew, default_inputs = load_crew(Path(__file__).with_name("crew.jsonc"))
+    return crew.kickoff(inputs={**default_inputs, **inputs})
+```
+
+## الخطوة 5: إنشاء Flow
+
+الآن الجزء المثير - إنشاء Flow الذي سينسّق عملية إنشاء الدليل بالكامل. راجع الملف الإنجليزي الأصلي للكود الكامل لـ `main.py` حيث أن الكود يبقى كما هو.
+
+## الخطوة 6: إعداد متغيرات البيئة
+
+أنشئ ملف `.env` في جذر مشروعك بمفاتيح API. راجع [دليل إعداد LLM](/ar/concepts/llms#setting-up-your-llm) لتفاصيل تهيئة المزود.
+
+```sh .env
+OPENAI_API_KEY=your_openai_api_key
+# or
+GEMINI_API_KEY=your_gemini_api_key
+# or
+ANTHROPIC_API_KEY=your_anthropic_api_key
+```
+
+## الخطوة 7: تثبيت التبعيات
+
+```bash
+crewai install
+```
+
+## الخطوة 8: تشغيل Flow
+
+```bash
+crewai run
+```
+
+عند تشغيل هذا الأمر، ستشاهد Flow يعمل:
+1. سيطلب منك موضوعًا ومستوى الجمهور
+2. سينشئ مخططًا منظمًا لدليلك
+3. سيعالج كل قسم مع تعاون الكاتب والمراجع
+4. أخيرًا سيجمع كل شيء في دليل شامل
+
+## الخطوة 9: تصوير Flow
+
+```bash
+crewai flow plot
+```
+
+سينشئ ملف HTML يوضح هيكل Flow بما في ذلك العلاقات بين الخطوات المختلفة.
+
+## الخطوة 10: مراجعة المخرجات
+
+بمجرد اكتمال Flow، ستجد ملفين في مجلد `output`:
+
+1. `guide_outline.json`: يحتوي على المخطط المنظم للدليل
+2. `complete_guide.md`: الدليل الشامل بجميع الأقسام
+
+## الميزات الرئيسية الموضّحة
+
+يوضح Flow منشئ الدليل عدة ميزات قوية لـ CrewAI:
+
+1. **تفاعل المستخدم**: يجمع Flow مدخلات مباشرة من المستخدم
+2. **استدعاءات LLM المباشرة**: يستخدم فئة LLM لتفاعلات AI فعّالة وأحادية الغرض
+3. **بيانات منظمة مع Pydantic**: يستخدم نماذج Pydantic لضمان سلامة الأنواع
+4. **معالجة تسلسلية مع سياق**: يكتب الأقسام بالترتيب ويوفر الأقسام السابقة كسياق
+5. **Crews متعددة الـ Agents**: يستفيد من Agents متخصصة (كاتب ومراجع) لإنشاء المحتوى
+6. **إدارة الحالة**: يحافظ على الحالة عبر خطوات العملية المختلفة
+7. **بنية قائمة على الأحداث**: يستخدم مزخرف `@listen` للاستجابة للأحداث
+
+## الخطوات التالية
+
+1. جرّب هياكل Flow أكثر تعقيدًا وأنماطًا
+2. جرّب استخدام `@router()` لإنشاء فروع شرطية
+3. استكشف دوال `and_` و`or_` لتنفيذ متوازٍ أكثر تعقيدًا
+4. اربط Flow بواجهات API خارجية وقواعد بيانات وواجهات مستخدم
+5. ادمج عدة Crews متخصصة في Flow واحد
+6. أنشئ تطبيقات دردشة متعددة الجولات مع [تدفقات المحادثة](/ar/guides/flows/conversational-flows) (`kickoff` لكل رسالة، `ChatSession`، تأجيل التتبع)
+
+<Check>
+تهانينا! لقد بنيت بنجاح أول CrewAI Flow يجمع بين الكود العادي واستدعاءات LLM المباشرة ومعالجة Crew لإنشاء دليل شامل. هذه المهارات الأساسية تمكّنك من إنشاء تطبيقات AI متطورة بشكل متزايد.
+</Check>

docs/edge/ar/guides/flows/inputs-id-deprecation.mdx

@@ -0,0 +1,102 @@
+---
+title: "الانتقال من inputs.id إلى restore_from_state_id"
+description: "نقل تدفقات @persist من ترطيب inputs.id المهجور إلى حقل restore_from_state_id المدعوم"
+icon: "arrow-right-arrow-left"
+---
+
+<Warning>
+  تمرير `id` داخل `inputs` لترطيب تدفق `@persist` هو **مهجور** ومقرر إزالته في إصدار مستقبلي. البديل، `restore_from_state_id`، متاح في CrewAI **v1.14.5 وما بعده** — الخطوات أدناه تنطبق بمجرد أن تقوم بالتحديث.
+</Warning>
+
+## نظرة عامة
+
+الطريقة الموثقة لترطيب تدفق `@persist` من تنفيذ سابق هي تمرير UUID لذلك التنفيذ كـ `inputs.id`. الآن، تكشف CrewAI عن حقل مخصص، `restore_from_state_id`، الذي يقوم بنفس الترطيب دون تحميل حمولة `inputs` — ودون ربط مفتاح الترطيب بهوية التنفيذ الجديد.
+
+## الانتقال
+
+إذا كنت حالياً تبدأ تدفق `@persist` باستخدام `inputs={"id": ...}`:
+
+```python
+# مهجور
+flow = CounterFlow()
+flow.kickoff(inputs={"id": "abcd1234-5678-90ef-ghij-klmnopqrstuv"})
+```
+
+انتقل إلى `restore_from_state_id`:
+
+```python
+# مدعوم
+flow = CounterFlow()
+flow.kickoff(restore_from_state_id="abcd1234-5678-90ef-ghij-klmnopqrstuv")
+```
+
+تتمتع الوضعيتان بمعاني سلالة مختلفة:
+
+- `inputs={"id": <uuid>}` (مهجور) — **استئناف**: تكتب الكتابات تحت المعرف المقدم، مما يمدد نفس تاريخ `flow_uuid`.
+- `restore_from_state_id=<uuid>` — **تفرع**: يترطب الحالة من اللقطة، ثم يكتب تحت `state.id` جديدة. يتم الحفاظ على تاريخ التدفق المصدر.
+
+لأغلب سيناريوهات الإنتاج — إعادة تشغيل تدفق تم تهيئته من حالة سابقة — فإن التفرع هو ما تريده. راجع [إتقان حالة التدفق](/ar/guides/flows/mastering-flow-state) للحصول على النموذج الذهني الكامل.
+
+إذا كنت تبدأ تدفقك عبر واجهة برمجة تطبيقات CrewAI AMP REST، راجع [AMP](#amp) أدناه لهجرة الحمولة المعادلة.
+
+## لماذا نقوم بإهمال `inputs.id` لـ `@persist`
+
+`inputs.id` هو حالياً الطريقة الموثقة لاستئناف تدفق `@persist` من تنفيذ سابق. المشكلة هي أن نفس UUID يقوم بوظيفتين في وقت واحد:
+
+1. **يحدد أي لقطة يترطب منها `@persist`** — تحميل الحالة المحفوظة تحت ذلك UUID.
+2. **يصبح معرف تنفيذ التدفق الجديد** (`state.id` في SDK؛ يظهر كـ `flow_id` في بعض السياقات) — كل كتابة `@persist` من هذه البداية أيضاً تقع تحت نفس UUID.
+
+هذه الوظيفة المزدوجة هي السبب الجذري للمشاكل التي يصفها هذا الدليل. لأن UUID المقدم هو أيضاً معرف التنفيذ الجديد، فإن بدايتين تمرران نفس `inputs.id` ليست تنفيذين متميزين — إنهما تشتركان في معرف، وتشاركان في سجل الاستمرارية، و(على AMP) تشتركان في صف في قائمة التنفيذات. لا توجد طريقة للقول "ترطب من هذه اللقطة، ولكن سجل هذا التشغيل بشكل منفصل" دون تقسيم المسؤوليتين.
+
+`restore_from_state_id` هو هذا الانقسام. إنه يخبر `@persist` من أي لقطة يترطب، بينما يترك التنفيذ الجديد حراً لاستلام `state.id` جديدة. لم يعد مصدر الترطيب والتشغيل المسجل نفس UUID — وهو ما تريده معظم سيناريوهات الإنتاج فعلياً.
+
+## جدول إزالة
+
+من المقرر إزالة `inputs.id` لترطيب `@persist` في إصدار مستقبلي من CrewAI. لا يوجد قطع صارم فوري — تظل التدفقات الحالية تعمل — ولكن بمجرد أن تقوم بالتحديث إلى v1.14.5 أو ما بعده، يجب أن يستخدم الكود الجديد `restore_from_state_id`، ويجب أن تهاجر التدفقات الحالية في الفرصة المناسبة التالية.
+
+## AMP
+
+إذا كنت تنشر تدفقك إلى CrewAI AMP، فإن الهجرة تمتد إلى الحمولة التي تبدأ بها المرسلة إلى طاقمك المنشور، وتظهر الأعراض المرئية لإعادة استخدام `inputs.id` على لوحة معلومات النشر. تغطي القسمان الفرعيان أدناه كلاهما.
+
+### هجرة حمولة البداية
+
+إذا كنت حالياً تبدأ تدفقاً منشوراً عن طريق تضمين `id` في `inputs`:
+
+```bash
+# مهجور
+curl -X POST \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  -d '{"inputs": {"id": "abcd1234-5678-90ef-ghij-klmnopqrstuv", "topic": "AI Agent Frameworks"}}' \
+  https://your-crew-url.crewai.com/kickoff
+```
+
+نقل UUID إلى حقل `restoreFromStateId` في المستوى الأعلى:
+
+```bash
+# مدعوم
+curl -X POST \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  -d '{
+        "inputs": {"topic": "AI Agent Frameworks"},
+        "restoreFromStateId": "abcd1234-5678-90ef-ghij-klmnopqrstuv"
+      }' \
+  https://your-crew-url.crewai.com/kickoff
+```
+
+يجلس `restoreFromStateId` بجانب `inputs` في حمولة البداية، وليس داخلها. الآن، يحمل كائن `inputs` فقط القيم التي تستهلكها تدفقك فعلياً.
+
+### ماذا يحدث عند إعادة استخدام `inputs.id`
+
+عندما تتلقى AMP بداية لتدفق يتطابق `inputs.id` الخاص به مع تنفيذ موجود، فإنه يحل إلى السجل الموجود بدلاً من إنشاء سجل جديد. من لوحة معلومات النشر سترى:
+
+- **حالة التنفيذ** — حالة التشغيل الجديد تحل محل حالة التشغيل السابق. يمكن أن تعود تنفيذات مكتملة إلى `جارية`، أو يمكن أن تتحول تشغيلات `مكتملة` إلى `خطأ` إذا فشلت البداية الجديدة — في كلتا الحالتين، لم تعد لوحة المعلومات تعكس التشغيل الأصلي.
+- **التتبع** — تتراكم تتبعات OTel عبر البدايات لأنها تشترك في نفس معرف التنفيذ؛ تتبعات التشغيل السابق إما تُستبدل بـ، أو تُخلط مع، تشغيل الجديد. لم يعد إعادة التشغيل خطوة بخطوة يتوافق مع تنفيذ واحد.
+- **قائمة التنفيذات** — البدايات التي يجب أن تظهر كصفوف منفصلة تتقلص إلى إدخال واحد، مما يخفي التاريخ.
+
+تساعد الهجرة إلى `restoreFromStateId` في الحفاظ على كل بداية كتنفيذ خاص بها — مع حالتها الخاصة، وتتبعها، وصفها في القائمة — بينما لا تزال ترطب الحالة من تشغيل سابق.
+
+<Card title="هل تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+  اتصل بفريق الدعم لدينا إذا لم تكن متأكداً من أي وضع يحتاجه تدفقك أو واجهت مشاكل أثناء الهجرة.
+</Card>

docs/edge/ar/guides/flows/mastering-flow-state.mdx

@@ -0,0 +1,228 @@
+---
+title: إتقان إدارة حالة Flow
+description: دليل شامل لإدارة الحالة وحفظها والاستفادة منها في CrewAI Flows لبناء تطبيقات AI قوية.
+icon: diagram-project
+mode: "wide"
+---
+
+## فهم قوة الحالة في Flows
+
+إدارة الحالة هي العمود الفقري لأي سير عمل AI متطور. في CrewAI Flows، يتيح لك نظام الحالة الحفاظ على السياق ومشاركة البيانات بين الخطوات وبناء منطق تطبيق معقد. إتقان إدارة الحالة ضروري لإنشاء تطبيقات AI موثوقة وقابلة للصيانة وقوية.
+
+### لماذا تهم إدارة الحالة
+
+تمكّنك إدارة الحالة الفعّالة من:
+
+1. **الحفاظ على السياق عبر خطوات التنفيذ** - تمرير المعلومات بسلاسة بين مراحل سير العمل المختلفة
+2. **بناء منطق شرطي معقد** - اتخاذ قرارات بناءً على البيانات المتراكمة
+3. **إنشاء تطبيقات مستمرة** - حفظ واستعادة تقدم سير العمل
+4. **معالجة الأخطاء بلطف** - تنفيذ أنماط استرداد لتطبيقات أكثر قوة
+5. **توسيع تطبيقاتك** - دعم سير العمل المعقدة بتنظيم بيانات مناسب
+6. **تمكين التطبيقات الحوارية** - تخزين والوصول إلى سجل المحادثات للتفاعلات الواعية بالسياق
+
+للدردشة متعددة الجولات (`kickoff` لكل سطر مستخدم، `ChatState`، توجيه النية، تأجيل التتبع، و`ChatSession`)، راجع [تدفقات المحادثة](/ar/guides/flows/conversational-flows).
+
+## أساسيات إدارة الحالة
+
+### نهجان لإدارة الحالة
+
+يوفر CrewAI طريقتين لإدارة الحالة في Flows:
+
+1. **الحالة غير المنظمة** - استخدام كائنات شبيهة بالقاموس للمرونة
+2. **الحالة المنظمة** - استخدام نماذج Pydantic لسلامة الأنواع والتحقق
+
+### مثال الحالة غير المنظمة
+
+```python
+from crewai.flow.flow import Flow, listen, start
+
+class UnstructuredStateFlow(Flow):
+    @start()
+    def initialize_data(self):
+        self.state["user_name"] = "Alex"
+        self.state["preferences"] = {"theme": "dark", "language": "English"}
+        self.state["items"] = []
+        return "Initialized"
+
+    @listen(initialize_data)
+    def process_data(self, previous_result):
+        user = self.state["user_name"]
+        self.state["items"].append("item1")
+        self.state["processed"] = True
+        return "Processed"
+
+flow = UnstructuredStateFlow()
+result = flow.kickoff()
+```
+
+### مثال الحالة المنظمة
+
+```python
+from crewai.flow.flow import Flow, listen, start
+from pydantic import BaseModel, Field
+from typing import List, Dict, Optional
+
+class AppState(BaseModel):
+    user_name: str = ""
+    items: List[str] = []
+    processed: bool = False
+    completion_percentage: float = 0.0
+
+class StructuredStateFlow(Flow[AppState]):
+    @start()
+    def initialize_data(self):
+        self.state.user_name = "Taylor"
+        return "Initialized"
+
+    @listen(initialize_data)
+    def process_data(self, previous_result):
+        self.state.items.append("item1")
+        self.state.processed = True
+        self.state.completion_percentage = 50.0
+        return "Processed"
+
+flow = StructuredStateFlow()
+result = flow.kickoff()
+```
+
+### فوائد الحالة المنظمة
+
+1. **سلامة الأنواع** - اكتشاف أخطاء الأنواع في وقت التطوير
+2. **توثيق ذاتي** - نموذج الحالة يوثّق بوضوح البيانات المتاحة
+3. **التحقق** - التحقق التلقائي من أنواع البيانات والقيود
+4. **دعم IDE** - إكمال تلقائي وتوثيق مضمّن
+5. **قيم افتراضية** - تعريف بدائل سهلة للبيانات المفقودة
+
+## حفظ حالة Flow
+
+يوفر مزخرف `@persist()` حفظ حالة تلقائي عند نقاط رئيسية في التنفيذ.
+
+```python
+from crewai.flow.flow import Flow, listen, start
+from crewai.flow.persistence import persist
+from pydantic import BaseModel
+
+class CounterState(BaseModel):
+    value: int = 0
+
+@persist()
+class PersistentCounterFlow(Flow[CounterState]):
+    @start()
+    def increment(self):
+        self.state.value += 1
+        return self.state.value
+
+    @listen(increment)
+    def double(self, value):
+        self.state.value = value * 2
+        return self.state.value
+```
+
+#### تفرع الحالة المستمرة
+
+يدعم `@persist` نمطين متميزين للترطيب في `kickoff` / `kickoff_async`. استخدم **استئناف** (`inputs["id"]`) لمواصلة نفس النسب؛ استخدم **تفرع** (`restore_from_state_id`) لبدء نسبٍ جديد من لقطة:
+
+| | `state.id` بعد kickoff | كتابات `@persist` تذهب إلى |
+|---|---|---|
+| `inputs["id"]` (استئناف) | المعرّف المقدم | المعرّف المقدم (يمد التاريخ) |
+| `restore_from_state_id` (تفرع) | معرّف جديد، أو `inputs["id"]` إذا ثُبّت | المعرّف الجديد (المصدر محفوظ) |
+
+```python
+from crewai.flow.flow import Flow, start
+from crewai.flow.persistence import persist
+from pydantic import BaseModel
+
+class CounterState(BaseModel):
+    id: str = ""
+    counter: int = 0
+
+@persist
+class CounterFlow(Flow[CounterState]):
+    @start()
+    def step(self):
+        self.state.counter += 1
+
+# التشغيل 1: حالة جديدة، العداد 0 -> 1
+flow_1 = CounterFlow()
+flow_1.kickoff()
+
+# التفرع: الترطيب من أحدث لقطة لـ flow_1، لكن الكتابة تحت state.id جديد
+flow_2 = CounterFlow()
+flow_2.kickoff(restore_from_state_id=flow_1.state.id)
+# يبدأ flow_2 بـ counter=1 (مرطّب)، ثم تزيده step() إلى 2.
+# تاريخ flow_uuid لـ flow_1 لم يتغيّر.
+```
+
+ملاحظات السلوك:
+
+- `restore_from_state_id` غير موجود في الاستمرارية → يعود kickoff بصمت إلى السلوك الافتراضي (يعكس سلوك `inputs["id"]` عند عدم العثور عليه). لا يُطلق أي استثناء.
+- الجمع بين `restore_from_state_id` و `from_checkpoint` يطلق `ValueError` — يستهدفان نظامي حالة مختلفين (`@persist` مقابل Checkpointing) ولا يمكن الجمع بينهما.
+- `restore_from_state_id=None` (افتراضي) متطابق بايت ببايت مع kickoff بدون المعامل.
+- تثبيت `inputs["id"]` أثناء التفرع يعني أن التشغيل الجديد يشارك مفتاح الاستمرارية مع تدفق آخر — عادةً ما تريد فقط `restore_from_state_id`.
+
+## أنماط حالة متقدمة
+
+### المنطق الشرطي المبني على الحالة
+
+```python
+from crewai.flow.flow import Flow, listen, router, start
+from pydantic import BaseModel
+
+class PaymentState(BaseModel):
+    amount: float = 0.0
+    is_approved: bool = False
+    retry_count: int = 0
+
+class PaymentFlow(Flow[PaymentState]):
+    @start()
+    def process_payment(self):
+        self.state.amount = 100.0
+        self.state.is_approved = self.state.amount < 1000
+        return "Payment processed"
+
+    @router(process_payment)
+    def check_approval(self, previous_result):
+        if self.state.is_approved:
+            return "approved"
+        elif self.state.retry_count < 3:
+            return "retry"
+        else:
+            return "rejected"
+
+    @listen("approved")
+    def handle_approval(self):
+        return f"Payment of ${self.state.amount} approved!"
+
+    @listen("retry")
+    def handle_retry(self):
+        self.state.retry_count += 1
+        return "Retry initiated"
+
+    @listen("rejected")
+    def handle_rejection(self):
+        return f"Payment of ${self.state.amount} rejected after {self.state.retry_count} retries."
+```
+
+## أفضل الممارسات لإدارة الحالة
+
+1. **اجعل الحالة مركّزة** - صمم الحالة لتحتوي فقط على ما هو ضروري
+2. **استخدم الحالة المنظمة للـ Flows المعقدة** - مع نمو التعقيد تصبح الحالة المنظمة أكثر قيمة
+3. **وثّق انتقالات الحالة** - للـ Flows المعقدة، وثّق كيف تتغير الحالة عبر التنفيذ
+4. **عالج أخطاء الحالة بلطف** - طبّق معالجة أخطاء للوصول إلى الحالة
+5. **استخدم الحالة لتتبع التقدم** - استفد من الحالة لتتبع التقدم في Flows طويلة التشغيل
+6. **استخدم العمليات غير المتغيرة عند الإمكان** - خاصة مع الحالة المنظمة
+
+## الخلاصة
+
+إتقان إدارة الحالة في CrewAI Flows يمنحك القدرة على بناء تطبيقات AI متطورة وقوية تحافظ على السياق وتتخذ قرارات معقدة وتقدم نتائج متسقة.
+
+<Check>
+لقد أتقنت الآن مفاهيم وممارسات إدارة الحالة في CrewAI Flows! بهذه المعرفة، يمكنك إنشاء سير عمل AI قوية تحافظ على السياق بفعالية وتشارك البيانات بين الخطوات وتبني منطق تطبيق متطور.
+</Check>
+
+## الخطوات التالية
+
+- جرّب الحالة المنظمة وغير المنظمة في Flows
+- جرّب تطبيق حفظ الحالة لسير العمل طويلة التشغيل
+- استكشف [بناء أول Crew](/ar/guides/crews/first-crew) لمعرفة كيف تعمل Crews وFlows معًا
+- اطلع على [توثيق مرجع Flow](/ar/concepts/flows) لمزيد من الميزات المتقدمة

docs/edge/ar/guides/migration/migrating-from-langgraph.mdx

@@ -0,0 +1,103 @@
+---
+title: "الانتقال من LangGraph إلى CrewAI: دليل عملي للمهندسين"
+description: إذا كنت قد بنيت بالفعل مع LangGraph، تعلم كيفية نقل مشاريعك بسرعة إلى CrewAI
+icon: switch
+mode: "wide"
+---
+
+لقد بنيت Agents مع LangGraph. لقد تعاملت مع `StateGraph`، وربطت الحواف الشرطية، وصححت أخطاء قواميس الحالة في الثانية صباحًا. إنه يعمل — لكن في مرحلة ما، بدأت تتساءل عما إذا كان هناك مسار أفضل نحو الإنتاج.
+
+هناك بالفعل. **CrewAI Flows** يمنحك نفس القوة — تنسيق قائم على الأحداث، توجيه شرطي، حالة مشتركة — مع نموذج كود أبسط بشكل كبير ونموذج ذهني يتماشى مع طريقة تفكيرك الفعلية في سير عمل AI متعدد الخطوات.
+
+تمشي هذه المقالة عبر المفاهيم الأساسية جنبًا إلى جنب، وتعرض مقارنات كود حقيقية، وتوضح لماذا CrewAI Flows هو إطار العمل الذي ستريد الوصول إليه بعد ذلك.
+
+---
+
+## تحول النموذج الذهني
+
+LangGraph يطلب منك التفكير في **رسوم بيانية**: عقد وحواف وقواميس حالة. كل سير عمل هو رسم بياني موجّه تربط فيه الانتقالات صراحةً بين خطوات الحساب.
+
+CrewAI Flows يطلب منك التفكير في **أحداث**: طرق تبدأ الأشياء، وطرق تستمع للنتائج، وطرق توجّه التنفيذ. طوبولوجيا سير العمل تنبثق من تعليقات المزخرفات بدلاً من بناء رسم بياني صريح.
+
+إليك الخريطة الأساسية:
+
+| مفهوم LangGraph | المكافئ في CrewAI Flows |
+| --- | --- |
+| `StateGraph` class | `Flow` class |
+| `add_node()` | طرق مزخرفة بـ `@start`، `@listen` |
+| `add_edge()` / `add_conditional_edges()` | مزخرفات `@listen()` / `@router()` |
+| `TypedDict` state | حالة Pydantic `BaseModel` |
+| `START` / `END` constants | مزخرف `@start()` / إرجاع طبيعي للطريقة |
+| `graph.compile()` | `flow.kickoff()` |
+| Checkpointer / persistence | ذاكرة مدمجة (مدعومة بـ LanceDB) |
+
+---
+
+## العرض 1: خط أنابيب تسلسلي بسيط
+
+تخيل أنك تبني خط أنابيب يأخذ موضوعًا، ويبحث فيه، ويكتب ملخصًا، وينسّق المخرجات. راجع الملف الإنجليزي الأصلي لأمثلة الكود الكاملة لكلا النهجين.
+
+الفرق الرئيسي: لا بناء رسم بياني، لا ربط حواف، لا خطوة ترجمة. ترتيب التنفيذ مُعلَن مباشرة حيث يوجد المنطق. `@start()` يحدد نقطة الدخول، و`@listen(method_name)` يربط الخطوات.
+
+---
+
+## العرض 2: التوجيه الشرطي
+
+مزخرف `@router()` يحوّل طريقة إلى نقطة قرار. يعيد سلسلة تطابق مستمعًا — بلا قواميس تعيين، بلا دوال توجيه منفصلة. منطق التفرع يُقرأ كتعبير `if` في Python لأنه كذلك فعلاً.
+
+---
+
+## العرض 3: دمج فرق Agents AI في Flows
+
+هنا تتجلى القوة الحقيقية لـ CrewAI. الـ Flows لا تقتصر على ربط استدعاءات LLM — بل تنسّق **Crews** كاملة من Agents مستقلة.
+
+الفكرة الرئيسية: **الـ Flows توفر طبقة التنسيق، والـ Crews توفر طبقة الذكاء.** كل خطوة في Flow يمكنها تشغيل فريق كامل من Agents متعاونة.
+
+---
+
+## العرض 4: التنفيذ المتوازي والمزامنة
+
+المشغّل `and_()` على مزخرف `@listen` يضمن أن الطريقة تُنفَّذ فقط بعد اكتمال *جميع* الطرق السابقة. هناك أيضًا `or_()` للمتابعة بمجرد اكتمال *أي* مهمة سابقة.
+
+---
+
+## لماذا CrewAI Flows للإنتاج
+
+- **حفظ حالة مدمج.** حالة Flow مدعومة بـ LanceDB.
+- **إدارة حالة آمنة الأنواع.** نماذج Pydantic توفر التحقق والتسلسل ودعم IDE.
+- **تنسيق Agents أصلي.** الـ Crews بنية أساسية أصلية.
+- **نموذج ذهني أبسط.** المزخرفات تعلن عن النية.
+- **تكامل CLI.** شغّل Flows بـ `crewai run`.
+
+---
+
+## ورقة الغش للترحيل
+
+1. **عيّن حالتك.** حوّل `TypedDict` إلى Pydantic `BaseModel`.
+2. **حوّل العقد إلى طرق.** كل دالة `add_node` تصبح طريقة على فئة `Flow` الفرعية.
+3. **استبدل الحواف بمزخرفات.** `add_edge(START, "first_node")` يصبح `@start()`. `add_edge("a", "b")` يصبح `@listen(a)`.
+4. **استبدل الحواف الشرطية بـ `@router`.** دالة التوجيه و`add_conditional_edges()` تصبح طريقة `@router()` واحدة.
+5. **استبدل compile + invoke بـ kickoff.** احذف `graph.compile()`. استدعِ `flow.kickoff()` بدلاً منه.
+6. **فكّر أين تناسب الـ Crews.** أي عقدة بها منطق Agent معقد متعدد الخطوات هي مرشحة لاستخراجها في Crew.
+
+---
+
+## البدء
+
+```bash
+pip install crewai
+crewai create flow my_first_flow
+cd my_first_flow
+```
+
+```bash
+crewai run
+```
+
+---
+
+## أفكار أخيرة
+
+LangGraph علّم المنظومة أن سير عمل AI تحتاج هيكلاً. كان ذلك درسًا مهمًا. لكن CrewAI Flows يأخذ ذلك الدرس ويقدمه في شكل أسرع في الكتابة وأسهل في القراءة وأقوى في الإنتاج — خاصة عندما تتضمن سير عملك عدة Agents متعاونة.
+
+ابدأ بـ `crewai create flow`. لن تنظر للخلف.

docs/edge/ar/guides/migration/upgrading-crewai.mdx

@@ -0,0 +1,190 @@
+---
+title: "ترقية CrewAI"
+description: "كيفية ترقية CrewAI في مشروعك والتكيّف مع التغييرات الجذرية بين الإصدارات."
+icon: "arrow-up-circle"
+---
+
+## نظرة عامة
+
+تجلب إصدارات CrewAI قدرات جديدة بانتظام. يرشدك هذا الدليل خلال الخطوات العملية للحفاظ على تثبيتك محدّثًا — سواء أداة سطر الأوامر أو البيئة الافتراضية لمشروعك.
+
+إذا كنت تبدأ من الصفر، راجع [التثبيت](/ar/installation). إذا كنت قادمًا من إطار عمل آخر، راجع [الترحيل من LangGraph](/ar/guides/migration/migrating-from-langgraph).
+
+---
+
+## الشيئان اللذان قد ترغب في ترقيتهما
+
+يوجد CrewAI في مكانين على جهازك، ويتم ترقيتهما بشكل مستقل:
+
+| ماذا | كيف يُثبَّت | كيف تتم الترقية |
+|---|---|---|
+| **أداة سطر الأوامر العامة `crewai`** | `uv tool install crewai` | `uv tool install crewai --upgrade` |
+| **بيئة venv للمشروع** (حيث يعمل الكود) | `crewai install` / `uv sync` | `uv add "crewai[...]>=X.Y.Z"` ثم `crewai install` |
+
+يمكن لهما — وغالبًا ما يحدث — أن يخرجا عن التزامن. تشغيل `crewai --version` يُظهر إصدار سطر الأوامر. تشغيل `uv pip show crewai` داخل مشروعك يُظهر إصدار venv. إذا اختلفا، فهذا طبيعي؛ ما يهم بالنسبة للكود قيد التشغيل هو إصدار venv.
+
+## لماذا لا يقوم `crewai install` وحده بالترقية
+
+`crewai install` هو غلاف رفيع حول `uv sync`. يُثبّت بالضبط ما يقوله ملف `uv.lock` الحالي — وهو **لا** يرفع أي قيود إصدار.
+
+إذا كان `pyproject.toml` يقول `crewai>=1.11.1` وقد قام ملف القفل بحلّه إلى `1.11.1`، فإن تشغيل `crewai install` سيُبقيك على `1.11.1` للأبد، حتى وإن كان الإصدار `1.14.4` متاحًا.
+
+للترقية فعلًا، عليك:
+
+1. تحديث قيد الإصدار في `pyproject.toml`
+2. إعادة حلّ ملف القفل
+3. مزامنة venv
+
+`uv add` يقوم بالثلاثة في خطوة واحدة.
+
+## كيفية ترقية مشروعك
+
+```bash
+# يرفع القيد ويعيد القفل في أمر واحد
+uv add "crewai[tools]>=1.14.4"
+
+# يزامن venv (crewai install يستدعي uv sync تحت الغطاء)
+crewai install
+
+# تحقّق
+uv pip show crewai
+# → Version: 1.14.4
+```
+
+استبدل `[tools]` بأي إضافات يستخدمها مشروعك (مثلًا `[tools,anthropic]`). تحقّق من قائمة `dependencies` في `pyproject.toml` إن لم تكن متأكدًا.
+
+<Note>
+  يحدّث `uv add` كلا من `pyproject.toml` **و** `uv.lock` بشكل ذرّي. إذا قمت بتحرير `pyproject.toml` يدويًا، فإنك لا تزال بحاجة إلى تشغيل `uv lock --upgrade-package crewai` لإعادة حلّ ملف القفل قبل أن يلتقط `crewai install` الإصدار الجديد.
+</Note>
+
+## ترقية أداة سطر الأوامر العامة
+
+أداة سطر الأوامر العامة منفصلة عن مشروعك. قم بترقيتها عبر:
+
+```bash
+uv tool install crewai --upgrade
+```
+
+إذا حذّرك الـ shell بشأن `PATH` بعد الترقية، قم بتحديثه:
+
+```bash
+uv tool update-shell
+```
+
+هذا **لا** يمسّ بيئة venv الخاصة بمشروعك — لا تزال بحاجة إلى `uv add` + `crewai install` داخل المشروع.
+
+## التحقق من تزامن الاثنين
+
+```bash
+# إصدار سطر الأوامر العام
+crewai --version
+
+# إصدار venv للمشروع
+uv pip show crewai | grep Version
+```
+
+ليس من الضروري أن يتطابقا — لكن إصدار venv للمشروع هو ما يهم لسلوك التشغيل.
+
+<Note>
+  يتطلب CrewAI `Python >=3.10, <3.14`. إذا كان `uv` مثبَّتًا مقابل مفسّر أقدم، فأعد إنشاء venv للمشروع باستخدام إصدار Python مدعوم قبل تشغيل `crewai install`.
+</Note>
+
+---
+
+## التغييرات الجذرية وملاحظات الترحيل
+
+تتطلب معظم الترقيات تعديلات صغيرة فقط. المناطق أدناه هي تلك التي تنكسر بصمت أو بتتبعات مكدّس مربكة.
+
+### مسارات الاستيراد: tools و`BaseTool`
+
+الموقع الرسمي لاستيراد الـ tools هو `crewai.tools`. لا تزال المسارات القديمة تظهر في الدروس لكن يجب تحديثها.
+
+```python
+# قبل
+from crewai_tools import BaseTool
+from crewai.agents.tools import tool
+
+# بعد
+from crewai.tools import BaseTool, tool
+```
+
+كلٌ من المُزخرف `@tool` والفئة الفرعية `BaseTool` يقعان في `crewai.tools`. `AgentFinish` والرموز الأخرى الداخلية للوكيل لم تعد جزءًا من السطح العام — إذا كنت تستوردها، فانتقل إلى event listeners أو callbacks الـ `Task` بدلًا منها.
+
+### تغييرات معاملات `Agent`
+
+```python
+from crewai import Agent
+
+agent = Agent(
+    role="Researcher",
+    goal="Find authoritative sources on {topic}",
+    backstory="You are a careful, source-driven researcher.",
+    llm="gpt-4o-mini",   # اسم نموذج كسلسلة نصية أو كائن LLM
+    verbose=True,        # bool وليس مستوى عددي صحيح
+    max_iter=15,         # تغيّر الافتراضي بين الإصدارات — حدّده بشكل صريح
+    allow_delegation=False,
+)
+```
+
+- يقبل `llm` إما اسم نموذج كسلسلة نصية (يُحلَّ عبر المزوّد المهيّأ) أو كائن `LLM` للتحكم الدقيق.
+- `verbose` هو `bool` بسيط. تمرير عدد صحيح لم يعد يبدّل مستويات السجل.
+- تغيّرت افتراضات `max_iter` بين الإصدارات. إذا توقف وكيلك بصمت عن التكرار بعد أول استدعاء tool، فحدّد `max_iter` صراحةً.
+
+### معاملات `Crew`
+
+```python
+from crewai import Crew, Process
+
+crew = Crew(
+    agents=[...],
+    tasks=[...],
+    process=Process.sequential,   # أو Process.hierarchical
+    memory=True,
+    cache=True,
+    embedder={"provider": "openai", "config": {"model": "text-embedding-3-small"}},
+)
+```
+
+- يتطلب `process=Process.hierarchical` إما `manager_llm=` أو `manager_agent=`. بدون أحدهما، يرفع kickoff خطأً عند التحقّق.
+- `memory=True` مع مزوّد embedding غير افتراضي يحتاج إلى قاموس `embedder` — راجع [إعداد الذاكرة وembedder](#memory-embedder-config) أدناه.
+
+### الإخراج المُهيكل لـ `Task`
+
+استخدم `output_pydantic` أو `output_json` أو `output_file` لإلزام نتيجة المهمة بشكل مكتوب الأنواع:
+
+```python
+from pydantic import BaseModel
+from crewai import Task
+
+class Article(BaseModel):
+    title: str
+    body: str
+
+write = Task(
+    description="Write an article about {topic}",
+    expected_output="A short article with a title and body",
+    agent=writer,
+    output_pydantic=Article,        # الفئة، وليس مثيلًا منها
+    output_file="output/article.md",
+)
+```
+
+`output_pydantic` يأخذ **الفئة** نفسها. تمرير `Article(title="", body="")` خطأ شائع ويفشل بخطأ تحقّق مربك.
+
+### إعداد الذاكرة وembedder {#memory-embedder-config}
+
+إذا كان `memory=True` وأنت لا تستخدم embeddings الافتراضية الخاصة بـ OpenAI، فيجب أن تمرّر `embedder`:
+
+```python
+crew = Crew(
+    agents=[...],
+    tasks=[...],
+    memory=True,
+    embedder={
+        "provider": "ollama",
+        "config": {"model": "nomic-embed-text"},
+    },
+)
+```
+
+ضع بيانات اعتماد المزوّد المعنيّة (`OPENAI_API_KEY`, `OLLAMA_HOST`, إلخ) في ملف `.env`. مسارات تخزين الذاكرة محلية بالنسبة للمشروع افتراضيًا — احذف مجلد ذاكرة المشروع إذا غيّرت embedders، لأن الأبعاد لا تختلط.

docs/edge/ar/guides/tools/publish-custom-tools.mdx

@@ -0,0 +1,96 @@
+---
+title: نشر أدوات مخصصة
+description: كيفية بناء وتعبئة ونشر أدواتك الخاصة المتوافقة مع CrewAI على PyPI ليتمكن أي مستخدم CrewAI من تثبيتها واستخدامها.
+icon: box-open
+mode: "wide"
+---
+
+## نظرة عامة
+
+نظام الأدوات في CrewAI مصمم للتوسيع. إذا بنيت أداة يمكن أن تفيد الآخرين، يمكنك تعبئتها كمكتبة Python مستقلة ونشرها على PyPI وإتاحتها لأي مستخدم CrewAI — دون الحاجة لطلب سحب إلى مستودع CrewAI.
+
+يمشي هذا الدليل عبر العملية الكاملة: تنفيذ عقد الأدوات، وهيكلة حزمتك، والنشر على PyPI.
+
+<Note type="info" title="لا تبحث عن النشر؟">
+إذا كنت تحتاج فقط أداة مخصصة لمشروعك، راجع دليل [إنشاء أدوات مخصصة](/ar/learn/create-custom-tools) بدلاً من ذلك.
+</Note>
+
+## عقد الأدوات
+
+كل أداة CrewAI يجب أن تستوفي إحدى الواجهتين:
+
+### الخيار 1: وراثة `BaseTool`
+
+ورث من `crewai.tools.BaseTool` وطبّق طريقة `_run`. عرّف `name` و`description` واختياريًا `args_schema` للتحقق من المدخلات.
+
+```python
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
+
+
+class GeolocateInput(BaseModel):
+    """Input schema for GeolocateTool."""
+    address: str = Field(..., description="The street address to geolocate.")
+
+
+class GeolocateTool(BaseTool):
+    name: str = "Geolocate"
+    description: str = "Converts a street address into latitude/longitude coordinates."
+    args_schema: type[BaseModel] = GeolocateInput
+
+    def _run(self, address: str) -> str:
+        return f"40.7128, -74.0060"
+```
+
+### الخيار 2: استخدام مزخرف `@tool`
+
+للأدوات الأبسط، يحوّل مزخرف `@tool` دالة إلى أداة CrewAI. يجب أن تحتوي الدالة على سلسلة توثيق (تُستخدم كوصف الأداة) وتعليقات أنواع.
+
+```python
+from crewai.tools import tool
+
+
+@tool("Geolocate")
+def geolocate(address: str) -> str:
+    """Converts a street address into latitude/longitude coordinates."""
+    return "40.7128, -74.0060"
+```
+
+### المتطلبات الأساسية
+
+بغض النظر عن النهج الذي تستخدمه، يجب أن تحتوي أداتك على:
+
+- **`name`** — معرّف قصير ووصفي.
+- **`description`** — يخبر الـ Agent متى وكيف يستخدم الأداة.
+- **`_run`** (BaseTool) أو **جسم الدالة** (@tool) — منطق التنفيذ المتزامن.
+- **تعليقات أنواع** على جميع المعاملات وقيم الإرجاع.
+- إرجاع نتيجة **نصية** (أو شيء يمكن تحويله لنص).
+
+## هيكل الحزمة
+
+```
+crewai-geolocate/
+├── pyproject.toml
+├── LICENSE
+├── README.md
+└── src/
+    └── crewai_geolocate/
+        ├── __init__.py
+        └── tools.py
+```
+
+## النشر على PyPI
+
+```bash
+# Build the package
+uv build
+
+# Publish to PyPI
+uv publish
+```
+
+بعد النشر، يمكن للمستخدمين تثبيت أداتك بـ:
+
+```bash
+uv add crewai-geolocate
+```

docs/edge/ar/index.mdx

@@ -0,0 +1,105 @@
+---
+title: "توثيق CrewAI"
+description: "ابنِ Agents ذكاء اصطناعي تعاونية وCrews وFlows — جاهزة للإنتاج من اليوم الأول."
+icon: "house"
+mode: "wide"
+---
+
+<div
+  style={{
+    display: 'flex',
+    flexDirection: 'column',
+    alignItems: 'center',
+    gap: 20,
+    textAlign: 'center',
+    padding: '48px 24px',
+    borderRadius: 16,
+    background: 'linear-gradient(180deg, rgba(235,102,88,0.12) 0%, rgba(201,76,60,0.08) 100%)',
+    border: '1px solid rgba(235,102,88,0.18)'
+  }}
+>
+  <img src="/images/crew_only_logo.png" alt="CrewAI" width="250" height="100" />
+  <div style={{ maxWidth: 720 }}>
+    <h1 style={{ marginBottom: 12 }}>أطلق أنظمة متعددة الـ Agents بثقة</h1>
+    <p style={{ color: 'var(--mint-text-2)' }}>
+      صمم Agents، ونسّق Crews، وأتمت Flows مع حواجز حماية وذاكرة ومعرفة ومراقبة مدمجة.
+    </p>
+  </div>
+
+  <div style={{ display: 'flex', flexWrap: 'wrap', gap: 12, justifyContent: 'center' }}>
+    <a className="button button-primary" href="/ar/quickstart">ابدأ الآن</a>
+    <a className="button" href="/ar/changelog">سجل التغييرات</a>
+    <a className="button" href="/ar/api-reference/introduction">مرجع API</a>
+  </div>
+
+</div>
+
+<div style={{ marginTop: 32 }} />
+
+## ابدأ
+
+<CardGroup cols={3}>
+  <Card title="مقدمة" href="/ar/introduction" icon="sparkles">
+    نظرة عامة على مفاهيم CrewAI وبنيته المعمارية وما يمكنك بناؤه باستخدام Agents وCrews وFlows.
+  </Card>
+  <Card title="التثبيت" href="/ar/installation" icon="wrench">
+    التثبيت عبر `uv`، وإعداد مفاتيح API، وتهيئة CLI للتطوير المحلي.
+  </Card>
+  <Card title="البداية السريعة" href="/ar/quickstart" icon="rocket">
+    أنشئ أول Crew لك في دقائق. تعلم بيئة التشغيل الأساسية وهيكل المشروع ودورة التطوير.
+  </Card>
+</CardGroup>
+
+## ابنِ الأساسيات
+
+<CardGroup cols={3}>
+  <Card title="Agents" href="/ar/concepts/agents" icon="users">
+    أنشئ Agents بأدوات وذاكرة ومعرفة ومخرجات منظمة باستخدام Pydantic. يتضمن قوالب وأفضل الممارسات.
+  </Card>
+  <Card title="Flows" href="/ar/concepts/flows" icon="arrow-progress">
+    نسّق خطوات start/listen/router، وأدر الحالة، واحفظ التنفيذ، واستأنف سير العمل الطويل.
+  </Card>
+  <Card title="المهام والعمليات" href="/ar/concepts/tasks" icon="check">
+    حدد عمليات متسلسلة أو هرمية أو مختلطة مع حواجز حماية واستدعاءات راجعة ومحفزات تدخل بشري.
+  </Card>
+</CardGroup>
+
+## رحلة المؤسسات
+
+<CardGroup cols={3}>
+  <Card title="نشر الأتمتة" href="https://docs-platform.crewai.com/platform/ar/features/automations" icon="server">
+    إدارة البيئات وإعادة النشر بأمان ومراقبة التشغيل المباشر من لوحة تحكم المؤسسات.
+  </Card>
+  <Card title="المحفزات والـ Flows" href="https://docs-platform.crewai.com/platform/ar/guides/automation-triggers" icon="bolt">
+    ربط Gmail وSlack وSalesforce والمزيد. تمرير بيانات المحفزات إلى Crews وFlows تلقائيًا.
+  </Card>
+  <Card title="إدارة الفريق" href="https://docs-platform.crewai.com/platform/ar/guides/team-management" icon="users-gear">
+    دعوة أعضاء الفريق وتهيئة التحكم في الوصول المبني على الأدوار وإدارة الوصول إلى أتمتة الإنتاج.
+  </Card>
+</CardGroup>
+
+## ما الجديد
+
+<CardGroup cols={2}>
+  <Card title="نظرة عامة على المحفزات" href="https://docs-platform.crewai.com/platform/ar/guides/automation-triggers" icon="sparkles">
+    نظرة شاملة موحدة على Gmail وDrive وOutlook وTeams وOneDrive وHubSpot والمزيد — الآن مع نماذج بيانات وCrews.
+  </Card>
+  <Card title="أدوات التكامل" href="/ar/tools/integration/overview" icon="plug">
+    استدعاء أتمتة CrewAI الحالية أو Amazon Bedrock Agents مباشرة من Crews باستخدام مجموعة أدوات التكامل المحدّثة.
+  </Card>
+</CardGroup>
+
+<Callout title="استكشف الأنماط الواقعية" icon="github">
+  تصفح <a href="/ar/examples/cookbooks">الأمثلة وكتب الوصفات</a> للحصول على تطبيقات مرجعية شاملة عبر Agents وFlows وأتمتة المؤسسات.
+</Callout>
+
+## ابقَ على تواصل
+
+<CardGroup cols={2}>
+  <Card title="امنحنا نجمة على GitHub" href="https://github.com/crewAIInc/crewAI" icon="star">
+    إذا ساعدك CrewAI في الإطلاق بشكل أسرع، امنحنا نجمة وشارك مشاريعك مع المجتمع.
+  </Card>
+  <Card title="انضم إلى المجتمع" href="https://community.crewai.com" icon="comments">
+    اطرح أسئلة واعرض سير العمل واطلب ميزات جديدة جنبًا إلى جنب مع المطورين الآخرين.
+  </Card>
+</CardGroup>

docs/edge/ar/installation.mdx

@@ -0,0 +1,216 @@
+---
+title: التثبيت
+description: ابدأ مع CrewAI - التثبيت والتهيئة وبناء أول فريق AI
+icon: wrench
+mode: "wide"
+---
+
+### شاهد: بناء Agents و Flows في CrewAI باستخدام Coding Agent Skills
+
+قم بتثبيت مهارات وكيل البرمجة الخاصة بنا (Claude Code، Codex، ...) لتشغيل وكلاء البرمجة بسرعة مع CrewAI.
+
+يمكنك تثبيتها باستخدام `npx skills add crewaiinc/skills`
+
+<iframe src="https://www.loom.com/embed/befb9f68b81f42ad8112bfdd95a780af" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen style={{width: "100%", height: "400px"}}></iframe>
+
+## فيديو تعليمي
+
+شاهد هذا الفيديو التعليمي لعرض تفصيلي لعملية التثبيت:
+
+<iframe
+  className="w-full aspect-video rounded-xl"
+  src="https://www.youtube.com/embed/-kSOTtYzgEw"
+  title="CrewAI Installation Guide"
+  frameBorder="0"
+  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+  allowFullScreen
+></iframe>
+
+## دليل نصي
+
+<Note>
+  **متطلبات إصدار Python**
+
+يتطلب CrewAI إصدار `Python >=3.10 and <3.14`. إليك كيفية التحقق من إصدارك:
+
+```bash
+python3 --version
+```
+
+إذا كنت بحاجة لتحديث Python، قم بزيارة [python.org/downloads](https://python.org/downloads)
+
+</Note>
+
+<Note>
+  **متطلبات OpenAI SDK**
+
+يتطلب CrewAI 0.175.0 إصدار `openai >= 1.13.3`. إذا كنت تدير التبعيات بنفسك، تأكد من أن بيئتك تستوفي هذا الشرط لتجنب مشاكل الاستيراد/التشغيل.
+
+</Note>
+
+يستخدم CrewAI أداة `uv` لإدارة التبعيات والحزم. وهي تبسّط إعداد المشروع وتنفيذه وتوفر تجربة سلسة.
+
+إذا لم تكن قد ثبّتت `uv` بعد، اتبع **الخطوة 1** لإعدادها بسرعة على نظامك، وإلا يمكنك الانتقال إلى **الخطوة 2**.
+
+<Steps>
+    <Step title="تثبيت uv">
+      - **على macOS/Linux:**
+
+        استخدم `curl` لتحميل السكريبت وتنفيذه عبر `sh`:
+
+        ```shell
+        curl -LsSf https://astral.sh/uv/install.sh | sh
+        ```
+        إذا لم يكن `curl` متاحًا على نظامك، يمكنك استخدام `wget`:
+
+        ```shell
+        wget -qO- https://astral.sh/uv/install.sh | sh
+        ```
+
+      - **على Windows:**
+
+        استخدم `irm` لتحميل السكريبت و`iex` لتنفيذه:
+
+        ```shell
+        powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
+        ```
+        إذا واجهت أي مشاكل، راجع [دليل تثبيت UV](https://docs.astral.sh/uv/getting-started/installation/) لمزيد من المعلومات.
+    </Step>
+
+    <Step title="تثبيت CrewAI">
+      - شغّل الأمر التالي لتثبيت واجهة سطر أوامر `crewai`:
+        ```shell
+        uv tool install crewai
+        ```
+          <Warning>
+            إذا ظهر تحذير بشأن `PATH`، شغّل هذا الأمر لتحديث الصدفة:
+            ```shell
+            uv tool update-shell
+            ```
+          </Warning>
+
+          <Warning>
+            إذا واجهت خطأ بناء `chroma-hnswlib==0.7.6` (`fatal error C1083: Cannot open include file: 'float.h'`) على Windows، ثبّت [Visual Studio Build Tools](https://visualstudio.microsoft.com/downloads/) مع خيار *Desktop development with C++*.
+          </Warning>
+
+      - للتحقق من تثبيت `crewai`، شغّل:
+        ```shell
+        uv tool list
+        ```
+      - يجب أن ترى شيئًا مثل:
+        ```shell
+        crewai v0.102.0
+        - crewai
+        ```
+      - إذا كنت بحاجة لتحديث `crewai`، شغّل:
+        ```shell
+        uv tool install crewai --upgrade
+        ```
+      <Check>تم التثبيت بنجاح! أنت جاهز لإنشاء أول Crew!</Check>
+    </Step>
+
+</Steps>
+
+# إنشاء مشروع CrewAI
+
+يقوم `crewai create crew` الآن بإنشاء مشروع crew بأسلوب JSON-first. توضع الـ Agents في `agents/*.jsonc`، وتوضع المهام وإعدادات الـ crew في `crew.jsonc`، ويحمّل `crewai run` هذا التعريف مباشرة.
+
+<Steps>
+  <Step title="إنشاء هيكل المشروع">
+    - شغّل أمر `crewai` عبر CLI:
+      ```shell
+      crewai create crew <your_project_name>
+      ```
+
+    - سينشئ هذا مشروعًا جديدًا بالهيكل التالي:
+      ```
+      my_project/
+      ├── .gitignore
+      ├── .env
+      ├── agents/
+      │   └── researcher.jsonc
+      ├── crew.jsonc
+      ├── knowledge/
+      ├── pyproject.toml
+      ├── README.md
+      ├── skills/
+      └── tools/
+      ```
+
+    - إذا احتجت إلى البنية القديمة Python/YAML التي تحتوي على `crew.py` و `config/agents.yaml` و `config/tasks.yaml`، شغّل:
+      ```shell
+      crewai create crew <your_project_name> --classic
+      ```
+
+  </Step>
+
+  <Step title="تخصيص مشروعك">
+    - سيحتوي مشروعك على هذه الملفات الأساسية:
+      | الملف | الغرض |
+      | --- | --- |
+      | `crew.jsonc` | إعداد الـ crew وترتيب المهام والعملية وقيم الإدخال الافتراضية |
+      | `agents/*.jsonc` | تعريف دور كل Agent وهدفه و backstory والـ LLM والأدوات والسلوك |
+      | `.env` | تخزين مفاتيح API ومتغيرات البيئة |
+      | `tools/` | ملفات Python اختيارية لأدوات `custom:<name>` |
+      | `knowledge/` | ملفات معرفة اختيارية للـ Agents |
+      | `skills/` | ملفات skills اختيارية تطبق على الـ crew |
+
+    - ابدأ بتحرير `crew.jsonc` والملفات داخل `agents/` لتعريف سلوك الـ crew.
+    - استخدم قيم `{placeholder}` في نصوص الـ Agents والمهام، ثم ضع القيم الافتراضية في `inputs` داخل `crew.jsonc`. عند تشغيل `crewai run` ستطلب CLI أي قيم ناقصة.
+    - احتفظ بالمعلومات الحساسة مثل مفاتيح API في `.env`.
+
+  </Step>
+
+  <Step title="تشغيل الـ Crew">
+    - قبل تشغيل الـ Crew، تأكد من تنفيذ:
+      ```bash
+      crewai install
+      ```
+    - إذا كنت بحاجة لتثبيت حزم إضافية، استخدم:
+      ```shell
+      uv add <package-name>
+      ```
+    - لتشغيل الـ Crew، نفّذ الأمر التالي في جذر مشروعك:
+      ```bash
+      crewai run
+      ```
+  </Step>
+</Steps>
+
+## خيارات التثبيت للمؤسسات
+
+<Note type="info">
+للفرق والمؤسسات، يوفر CrewAI خيارات نشر مؤسسية تزيل تعقيد الإعداد:
+
+### CrewAI AMP (SaaS)
+
+- لا يتطلب أي تثبيت - فقط سجّل مجانًا على [app.crewai.com](https://app.crewai.com)
+- تحديثات وصيانة تلقائية
+- بنية تحتية مُدارة وقابلة للتوسع
+- بناء Crews بدون كتابة كود
+
+### CrewAI Factory (استضافة ذاتية)
+
+- نشر بالحاويات على بنيتك التحتية
+- يدعم أي مزود سحابي بما في ذلك النشر المحلي
+- تكامل مع أنظمة الأمان الحالية
+
+<Card title="استكشف خيارات المؤسسات" icon="building" href="https://share.hsforms.com/1Ooo2UViKQ22UOzdr7i77iwr87kg">
+  تعرّف على عروض CrewAI للمؤسسات وجدول عرضًا توضيحيًا
+</Card>
+</Note>
+
+## الخطوات التالية
+
+<CardGroup cols={2}>
+  <Card title="بدء سريع: Flow + وكيل" icon="code" href="/ar/quickstart">
+    اتبع البداية السريعة لإنشاء Flow وتشغيل طاقم بوكيل واحد وإنتاج تقرير.
+  </Card>
+  <Card
+    title="انضم إلى المجتمع"
+    icon="comments"
+    href="https://community.crewai.com"
+  >
+    تواصل مع مطورين آخرين واحصل على المساعدة وشارك تجاربك مع CrewAI.
+  </Card>
+</CardGroup>

docs/edge/ar/introduction.mdx

@@ -0,0 +1,152 @@
+---
+title: مقدمة
+description: ابنِ فرق Agents ذكاء اصطناعي تعمل معًا لمعالجة المهام المعقدة
+icon: handshake
+mode: "wide"
+---
+
+# ما هو CrewAI؟
+
+**CrewAI هو إطار العمل مفتوح المصدر الرائد لتنسيق Agents الذكاء الاصطناعي المستقلة وبناء سير العمل المعقدة.**
+
+يمكّن المطورين من بناء أنظمة متعددة الـ Agents جاهزة للإنتاج من خلال الجمع بين الذكاء التعاوني لـ **Crews** والتحكم الدقيق لـ **Flows**.
+
+- **[CrewAI Flows](/ar/guides/flows/first-flow)**: العمود الفقري لتطبيق الذكاء الاصطناعي. تتيح لك Flows إنشاء سير عمل منظمة قائمة على الأحداث تدير الحالة وتتحكم في التنفيذ. وهي توفر البنية الأساسية التي تعمل ضمنها Agents الذكاء الاصطناعي.
+- **[CrewAI Crews](/ar/guides/crews/first-crew)**: وحدات العمل ضمن Flow. الـ Crews هي فرق من Agents مستقلة تتعاون لحل مهام محددة يفوضها إليها Flow.
+
+مع أكثر من 100,000 مطور معتمد عبر دوراتنا المجتمعية، يُعد CrewAI المعيار لأتمتة الذكاء الاصطناعي الجاهزة للمؤسسات.
+
+### شاهد: بناء Agents و Flows في CrewAI باستخدام Coding Agent Skills
+
+قم بتثبيت مهارات وكيل البرمجة الخاصة بنا (Claude Code، Codex، ...) لتشغيل وكلاء البرمجة بسرعة مع CrewAI.
+
+يمكنك تثبيتها باستخدام `npx skills add crewaiinc/skills`
+
+<iframe src="https://www.loom.com/embed/befb9f68b81f42ad8112bfdd95a780af" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen style={{width: "100%", height: "400px"}}></iframe>
+
+## بنية CrewAI المعمارية
+
+صُممت بنية CrewAI لتحقيق التوازن بين الاستقلالية والتحكم.
+
+### 1. Flows: العمود الفقري
+
+<Note>
+  فكّر في Flow كـ "المدير" أو "تعريف العملية" لتطبيقك. يحدد الخطوات والمنطق وكيفية تدفق البيانات عبر نظامك.
+</Note>
+
+<Frame caption="نظرة عامة على إطار عمل CrewAI">
+  <img src="/images/flows.png" alt="نظرة عامة على إطار عمل CrewAI" />
+</Frame>
+
+توفر Flows:
+- **إدارة الحالة**: حفظ البيانات عبر الخطوات والتنفيذات.
+- **تنفيذ قائم على الأحداث**: تشغيل إجراءات بناءً على أحداث أو مدخلات خارجية.
+- **التحكم في التدفق**: استخدام المنطق الشرطي والحلقات والتفرع.
+
+### 2. Crews: الذكاء
+
+<Note>
+  الـ Crews هي "الفرق" التي تقوم بالعمل الثقيل. ضمن Flow، يمكنك تشغيل Crew لمعالجة مشكلة معقدة تتطلب إبداعًا وتعاونًا.
+</Note>
+
+<Frame caption="نظرة عامة على إطار عمل CrewAI">
+  <img src="/images/crews.png" alt="نظرة عامة على إطار عمل CrewAI" />
+</Frame>
+
+توفر Crews:
+- **Agents بأدوار محددة**: Agents متخصصة بأهداف وأدوات محددة.
+- **تعاون مستقل**: تعمل الـ Agents معًا لحل المهام.
+- **تفويض المهام**: يتم تعيين المهام وتنفيذها بناءً على قدرات الـ Agent.
+
+## كيف يعمل الكل معًا
+
+1.  يبدأ **Flow** حدثًا أو يشغّل عملية.
+2.  يدير **Flow** الحالة ويقرر ما يجب فعله بعد ذلك.
+3.  يفوّض **Flow** مهمة معقدة إلى **Crew**.
+4.  تتعاون Agents الـ **Crew** لإكمال المهمة.
+5.  يعيد **Crew** النتيجة إلى **Flow**.
+6.  يستمر **Flow** في التنفيذ بناءً على النتيجة.
+
+## الميزات الرئيسية
+
+<CardGroup cols={2}>
+  <Card title="Flows بمستوى الإنتاج" icon="arrow-progress">
+    ابنِ سير عمل موثوقة وذات حالة يمكنها التعامل مع العمليات طويلة التشغيل والمنطق المعقد.
+  </Card>
+  <Card title="Crews مستقلة" icon="users">
+    انشر فرقًا من الـ Agents يمكنها التخطيط والتنفيذ والتعاون لتحقيق أهداف عالية المستوى.
+  </Card>
+  <Card title="أدوات مرنة" icon="screwdriver-wrench">
+    اربط Agents بأي API أو قاعدة بيانات أو أداة محلية.
+  </Card>
+  <Card title="أمان المؤسسات" icon="lock">
+    مصمم مع مراعاة الأمان والامتثال لعمليات نشر المؤسسات.
+  </Card>
+</CardGroup>
+
+## متى تستخدم Crews مقابل Flows
+
+**الإجابة المختصرة: استخدم كليهما.**
+
+لأي تطبيق جاهز للإنتاج، **ابدأ بـ Flow**.
+
+- **استخدم Flow** لتعريف الهيكل العام والحالة والمنطق لتطبيقك.
+- **استخدم Crew** ضمن خطوة Flow عندما تحتاج فريقًا من الـ Agents لأداء مهمة معقدة محددة تتطلب استقلالية.
+
+| حالة الاستخدام | البنية المعمارية |
+| :--- | :--- |
+| **أتمتة بسيطة** | Flow واحد مع مهام Python |
+| **بحث معقد** | Flow يدير الحالة -> Crew يجري البحث |
+| **واجهة تطبيق خلفية** | Flow يعالج طلبات API -> Crew ينشئ المحتوى -> Flow يحفظ في قاعدة البيانات |
+
+## لماذا تختار CrewAI؟
+
+- **تشغيل مستقل**: تتخذ الـ Agents قرارات ذكية بناءً على أدوارها وأدواتها المتاحة
+- **تفاعل طبيعي**: تتواصل الـ Agents وتتعاون كأعضاء فريق بشري
+- **تصميم قابل للتوسيع**: سهولة إضافة أدوات وأدوار وقدرات جديدة
+- **جاهز للإنتاج**: مبني للموثوقية والتوسع في التطبيقات الواقعية
+- **موجّه نحو الأمان**: مصمم مع مراعاة متطلبات أمان المؤسسات
+- **كفاءة التكلفة**: محسّن لتقليل استخدام الرموز المميزة واستدعاءات API
+
+## هل أنت مستعد للبدء في البناء؟
+
+<CardGroup cols={2}>
+  <Card
+    title="ابنِ أول Flow لك"
+    icon="diagram-project"
+    href="/ar/guides/flows/first-flow"
+  >
+    تعلم كيفية إنشاء سير عمل منظمة قائمة على الأحداث مع تحكم دقيق في التنفيذ.
+  </Card>
+  <Card
+    title="ابنِ أول Crew لك"
+    icon="users-gear"
+    href="/ar/guides/crews/first-crew"
+  >
+    دليل تفصيلي لإنشاء فريق AI تعاوني يعمل معًا لحل المشكلات المعقدة.
+  </Card>
+</CardGroup>
+
+<CardGroup cols={3}>
+  <Card
+    title="تثبيت CrewAI"
+    icon="wrench"
+    href="/ar/installation"
+  >
+    ابدأ مع CrewAI في بيئة التطوير الخاصة بك.
+  </Card>
+  <Card
+    title="البداية السريعة"
+    icon="bolt"
+    href="/ar/quickstart"
+  >
+    أنشئ Flow وشغّل طاقمًا بوكيل واحد وأنشئ تقريرًا من البداية للنهاية.
+  </Card>
+  <Card
+    title="انضم إلى المجتمع"
+    icon="comments"
+    href="https://community.crewai.com"
+  >
+    تواصل مع مطورين آخرين واحصل على المساعدة وشارك تجاربك مع CrewAI.
+  </Card>
+</CardGroup>

docs/edge/ar/learn/a2a-agent-delegation.mdx

@@ -0,0 +1,87 @@
+---
+title: بروتوكول Agent-to-Agent (A2A)
+description: الـ Agents تفوّض المهام إلى Agents A2A بعيدة و/أو تعمل كـ Agents خادم متوافقة مع A2A.
+icon: network-wired
+mode: "wide"
+---
+
+## تفويض Agent A2A
+
+يعامل CrewAI [بروتوكول A2A](https://a2a-protocol.org/latest/) كبنية تفويض أساسية، مما يمكّن الـ Agents من تفويض المهام وطلب المعلومات والتعاون مع Agents بعيدة، وكذلك العمل كـ Agents خادم متوافقة مع A2A. في وضع العميل، تختار الـ Agents تلقائيًا بين التنفيذ المحلي والتفويض البعيد بناءً على متطلبات المهمة.
+
+## كيف يعمل
+
+عندما يُهيَّأ Agent بقدرات A2A:
+
+1. يحلل الـ Agent كل مهمة
+2. يقرر إما:
+   - معالجة المهمة مباشرة باستخدام قدراته الخاصة
+   - التفويض إلى Agent A2A بعيد للمعالجة المتخصصة
+3. إذا فوّض، يتواصل الـ Agent مع Agent A2A البعيد عبر البروتوكول
+4. تُعاد النتائج إلى سير عمل CrewAI
+
+<Note>
+  تفويض A2A يتطلب حزمة `a2a-sdk`. ثبّتها بـ: `uv add 'crewai[a2a]'` أو `pip install 'crewai[a2a]'`
+</Note>
+
+## التهيئة الأساسية
+
+<Warning>
+  `crewai.a2a.config.A2AConfig` مهمل وسيُزال في v2.0.0. استخدم `A2AClientConfig` للاتصال بـ Agents بعيدة و/أو `A2AServerConfig` لعرض الـ Agents كخوادم.
+</Warning>
+
+```python Code
+from crewai import Agent, Crew, Task
+from crewai.a2a import A2AClientConfig
+
+agent = Agent(
+    role="Research Coordinator",
+    goal="Coordinate research tasks efficiently",
+    backstory="Expert at delegating to specialized research agents",
+    llm="gpt-4o",
+    a2a=A2AClientConfig(
+        endpoint="https://example.com/.well-known/agent-card.json",
+        timeout=120,
+        max_turns=10
+    )
+)
+
+task = Task(
+    description="Research the latest developments in quantum computing",
+    expected_output="A comprehensive research report",
+    agent=agent
+)
+
+crew = Crew(agents=[agent], tasks=[task], verbose=True)
+result = crew.kickoff()
+```
+
+## خيارات تهيئة العميل
+
+راجع الملف الإنجليزي الأصلي للحصول على القائمة الكاملة لمعاملات `A2AClientConfig` وخيارات المصادقة وآليات التحديث وتهيئة الخادم.
+
+## أفضل الممارسات
+
+<CardGroup cols={2}>
+  <Card title="عيّن مهلات مناسبة" icon="clock">
+    هيّئ المهلات بناءً على أوقات استجابة Agent A2A المتوقعة.
+  </Card>
+
+  <Card title="حدّ جولات المحادثة" icon="comments">
+    استخدم `max_turns` لمنع التبادل المفرط.
+  </Card>
+
+  <Card title="استخدم معالجة أخطاء مرنة" icon="shield-check">
+    عيّن `fail_fast=False` لبيئات الإنتاج مع عدة Agents.
+  </Card>
+
+  <Card title="أمّن بيانات الاعتماد" icon="lock">
+    خزّن رموز المصادقة وبيانات الاعتماد كمتغيرات بيئة، ليس في الكود.
+  </Card>
+</CardGroup>
+
+## تعلم المزيد
+
+- [توثيق بروتوكول A2A](https://a2a-protocol.org)
+- [تطبيقات A2A النموذجية](https://github.com/a2aproject/a2a-samples)
+- [A2A Python SDK](https://github.com/a2aproject/a2a-python)

docs/edge/ar/learn/before-and-after-kickoff-hooks.mdx

@@ -0,0 +1,47 @@
+---
+title: خطافات قبل وبعد الانطلاق
+description: تعلم كيفية استخدام خطافات قبل وبعد الانطلاق في CrewAI
+mode: "wide"
+---
+
+يوفر CrewAI خطافات تتيح لك تنفيذ كود قبل وبعد انطلاق Crew. هذه الخطافات مفيدة لمعالجة المدخلات مسبقًا أو معالجة النتائج لاحقًا.
+
+## خطاف قبل الانطلاق
+
+يُنفَّذ خطاف قبل الانطلاق قبل أن يبدأ Crew مهامه. يتلقى قاموس المدخلات ويمكنه تعديله قبل تمريره إلى Crew. يمكنك استخدام هذا الخطاف لإعداد بيئتك أو تحميل البيانات اللازمة أو معالجة المدخلات مسبقًا.
+
+```python
+from crewai import CrewBase
+from crewai.project import before_kickoff
+
+@CrewBase
+class MyCrew:
+    @before_kickoff
+    def prepare_data(self, inputs):
+        inputs['processed'] = True
+        return inputs
+```
+
+## خطاف بعد الانطلاق
+
+يُنفَّذ خطاف بعد الانطلاق بعد إتمام Crew مهامه. يتلقى كائن النتيجة الذي يحتوي على مخرجات تنفيذ Crew. هذا الخطاف مثالي لمعالجة النتائج لاحقًا مثل التسجيل أو تحويل البيانات أو التحليل الإضافي.
+
+```python
+from crewai import CrewBase
+from crewai.project import after_kickoff
+
+@CrewBase
+class MyCrew:
+    @after_kickoff
+    def log_results(self, result):
+        print("Crew execution completed with result:", result)
+        return result
+```
+
+## استخدام كلا الخطافين
+
+يمكن استخدام كلا الخطافين معًا لتوفير عملية إعداد وتفكيك شاملة لتنفيذ Crew. وهما مفيدان بشكل خاص في الحفاظ على بنية كود نظيفة من خلال فصل المسؤوليات وتعزيز نمطية تنفيذات CrewAI.
+
+## الخلاصة
+
+توفر خطافات قبل وبعد الانطلاق في CrewAI طرقًا قوية للتفاعل مع دورة حياة تنفيذ Crew. من خلال فهم واستخدام هذه الخطافات، يمكنك تعزيز متانة ومرونة Agents الذكاء الاصطناعي بشكل كبير.

docs/edge/ar/learn/bring-your-own-agent.mdx

@@ -0,0 +1,41 @@
+---
+title: أحضر Agent الخاص بك
+description: تعلم كيفية إحضار Agents خاصة بك تعمل ضمن Crew.
+icon: robots
+mode: "wide"
+---
+
+قابلية التشغيل البيني مفهوم أساسي في CrewAI. يوضح هذا الدليل كيفية إحضار Agents خاصة بك تعمل ضمن Crew.
+
+## دليل المحوّلات لإحضار Agents الخاصة (Agents من LangGraph وOpenAI وغيرها...)
+
+نتطلب 3 محوّلات لتحويل أي Agent من أطر عمل مختلفة للعمل ضمن Crew.
+
+1. BaseAgentAdapter
+2. BaseToolAdapter
+3. BaseConverter
+
+## BaseAgentAdapter
+
+تعرّف هذه الفئة المجردة الواجهة المشتركة والوظائف التي يجب أن تنفذها جميع محوّلات الـ Agent. تمتد BaseAgent للحفاظ على التوافق مع إطار عمل CrewAI مع إضافة متطلبات خاصة بالمحوّل.
+
+الطرق المطلوبة:
+
+1. `def configure_tools`
+2. `def configure_structured_output`
+
+## إنشاء محوّل خاص بك
+
+لدمج Agent من إطار عمل مختلف في CrewAI، تحتاج لإنشاء محوّل مخصص بوراثة `BaseAgentAdapter`. يعمل هذا المحوّل كطبقة توافق تترجم بين واجهات CrewAI والمتطلبات المحددة للـ Agent الخارجي.
+
+راجع الملف الإنجليزي الأصلي لأمثلة الكود التفصيلية لتنفيذ BaseAgentAdapter وBaseToolAdapter وBaseConverter.
+
+## محوّلات جاهزة للاستخدام
+
+نوفر محوّلات جاهزة للأطر التالية:
+1. LangGraph
+2. OpenAI Agents
+
+## تشغيل Crew مع Agents محوّلة:
+
+راجع الملف الإنجليزي الأصلي للحصول على مثال الكود الكامل الذي يوضح استخدام CrewAI Agent وOpenAI Agent Adapter وLangGraph Agent Adapter معًا في Crew واحد.

docs/edge/ar/learn/coding-agents.mdx

@@ -0,0 +1,80 @@
+---
+title: Agents البرمجة
+description: تعلم كيفية تمكين Agents CrewAI من كتابة وتنفيذ الكود، واستكشف الميزات المتقدمة لوظائف محسّنة.
+icon: rectangle-code
+mode: "wide"
+---
+
+## مقدمة
+
+أصبح لدى CrewAI Agents القدرة القوية على كتابة وتنفيذ الكود، مما يعزز قدراتها في حل المشكلات بشكل كبير. هذه الميزة مفيدة بشكل خاص للمهام التي تتطلب حلولاً حسابية أو برمجية.
+
+## تمكين تنفيذ الكود
+
+لتمكين تنفيذ الكود لـ Agent، عيّن معامل `allow_code_execution` إلى `True` عند إنشاء الـ Agent.
+
+```python Code
+from crewai import Agent
+
+coding_agent = Agent(
+    role="Senior Python Developer",
+    goal="Craft well-designed and thought-out code",
+    backstory="You are a senior Python developer with extensive experience in software architecture and best practices.",
+    allow_code_execution=True
+)
+```
+
+<Note>
+لاحظ أن معامل `allow_code_execution` يكون `False` افتراضيًا.
+</Note>
+
+## اعتبارات مهمة
+
+1. **اختيار النموذج**: يُوصى بشدة باستخدام نماذج أكثر قدرة مثل Claude 3.5 Sonnet وGPT-4 عند تمكين تنفيذ الكود.
+
+2. **معالجة الأخطاء**: تتضمن ميزة تنفيذ الكود معالجة أخطاء. إذا أثار الكود المُنفَّذ استثناءً، سيتلقى الـ Agent رسالة الخطأ ويمكنه محاولة تصحيح الكود. يتحكم معامل `max_retry_limit` (الافتراضي 2) في الحد الأقصى لعدد المحاولات.
+
+3. **التبعيات**: لاستخدام ميزة تنفيذ الكود، تحتاج لتثبيت حزمة `crewai_tools`.
+
+## عملية تنفيذ الكود
+
+<Steps>
+    <Step title="تحليل المهمة">
+    يحلل الـ Agent المهمة ويحدد أن تنفيذ الكود ضروري.
+    </Step>
+    <Step title="صياغة الكود">
+    يصيغ كود Python اللازم لحل المشكلة.
+    </Step>
+    <Step title="تنفيذ الكود">
+    يُرسَل الكود إلى أداة تنفيذ الكود الداخلية (`CodeInterpreterTool`).
+    </Step>
+    <Step title="تفسير النتيجة">
+    يفسر الـ Agent النتيجة ويدمجها في استجابته أو يستخدمها لمزيد من حل المشكلات.
+    </Step>
+</Steps>
+
+## مثال استخدام
+
+```python Code
+from crewai import Agent, Task, Crew
+
+coding_agent = Agent(
+    role="Python Data Analyst",
+    goal="Analyze data and provide insights using Python",
+    backstory="You are an experienced data analyst with strong Python skills.",
+    allow_code_execution=True
+)
+
+data_analysis_task = Task(
+    description="Analyze the given dataset and calculate the average age of participants.",
+    agent=coding_agent
+)
+
+analysis_crew = Crew(
+    agents=[coding_agent],
+    tasks=[data_analysis_task]
+)
+
+result = analysis_crew.kickoff()
+print(result)
+```

docs/edge/ar/learn/conditional-tasks.mdx

@@ -0,0 +1,14 @@
+---
+title: المهام الشرطية
+description: تعلم كيفية استخدام المهام الشرطية في انطلاق crewAI
+icon: diagram-subtask
+mode: "wide"
+---
+
+## مقدمة
+
+تتيح المهام الشرطية في crewAI التكيف الديناميكي لسير العمل بناءً على نتائج المهام السابقة. تمكّن هذه الميزة القوية الـ Crews من اتخاذ قرارات وتنفيذ المهام بشكل انتقائي، مما يعزز مرونة وكفاءة عملياتك المدفوعة بالذكاء الاصطناعي.
+
+## مثال استخدام
+
+راجع الملف الإنجليزي الأصلي للحصول على مثال الكود الكامل الذي يوضح استخدام `ConditionalTask` مع دالة شرط `is_data_missing` للتحكم في تنفيذ المهام بناءً على مخرجات المهام السابقة.

docs/edge/ar/learn/create-custom-tools.mdx

@@ -0,0 +1,77 @@
+---
+title: إنشاء أدوات مخصصة
+description: دليل شامل لصياغة واستخدام وإدارة الأدوات المخصصة ضمن إطار عمل CrewAI، بما في ذلك الوظائف الجديدة ومعالجة الأخطاء.
+icon: hammer
+mode: "wide"
+---
+
+## إنشاء واستخدام الأدوات في CrewAI
+
+يقدم هذا الدليل تعليمات مفصلة لإنشاء أدوات مخصصة لإطار عمل CrewAI وكيفية إدارة واستخدام هذه الأدوات بكفاءة، مع دمج أحدث الوظائف مثل تفويض الأدوات ومعالجة الأخطاء واستدعاء الأدوات الديناميكي.
+
+<Tip>
+  **هل تريد نشر أداتك للمجتمع؟** إذا كنت تبني أداة يمكن أن تفيد الآخرين، اطلع على دليل [نشر أدوات مخصصة](/ar/guides/tools/publish-custom-tools) لتعلم كيفية تعبئة وتوزيع أداتك على PyPI.
+</Tip>
+
+### وراثة `BaseTool`
+
+لإنشاء أداة مخصصة، ورث من `BaseTool` وعرّف السمات الضرورية بما في ذلك `args_schema` للتحقق من المدخلات وطريقة `_run`.
+
+```python Code
+from typing import Type
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
+
+class MyToolInput(BaseModel):
+    """Input schema for MyCustomTool."""
+    argument: str = Field(..., description="Description of the argument.")
+
+class MyCustomTool(BaseTool):
+    name: str = "Name of my tool"
+    description: str = "What this tool does. It's vital for effective utilization."
+    args_schema: Type[BaseModel] = MyToolInput
+
+    def _run(self, argument: str) -> str:
+        return "Tool's result"
+```
+
+### استخدام مزخرف `tool`
+
+```python Code
+from crewai.tools import tool
+
+@tool("Tool Name")
+def my_simple_tool(question: str) -> str:
+    """Tool description for clarity."""
+    return "Tool output"
+```
+
+### تعريف دالة تخزين مؤقت للأداة
+
+```python Code
+@tool("Tool with Caching")
+def cached_tool(argument: str) -> str:
+    """Tool functionality description."""
+    return "Cacheable result"
+
+def my_cache_strategy(arguments: dict, result: str) -> bool:
+    return True if some_condition else False
+
+cached_tool.cache_function = my_cache_strategy
+```
+
+### إنشاء أدوات غير متزامنة
+
+يدعم CrewAI الأدوات غير المتزامنة لعمليات I/O غير المحجوبة.
+
+```python Code
+import aiohttp
+from crewai.tools import tool
+
+@tool("Async Web Fetcher")
+async def fetch_webpage(url: str) -> str:
+    """Fetch content from a webpage asynchronously."""
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as response:
+            return await response.text()
+```

docs/edge/ar/learn/custom-llm.mdx

@@ -0,0 +1,55 @@
+---
+title: تنفيذ LLM مخصص
+description: تعلم كيفية إنشاء تنفيذات LLM مخصصة في CrewAI.
+icon: code
+mode: "wide"
+---
+
+## نظرة عامة
+
+يدعم CrewAI تنفيذات LLM المخصصة من خلال فئة `BaseLLM` المجردة. يتيح لك ذلك دمج أي مزود LLM لا يحظى بدعم مدمج في LiteLLM، أو تنفيذ آليات مصادقة مخصصة.
+
+## بداية سريعة
+
+راجع الملف الإنجليزي الأصلي للحصول على تنفيذ LLM مخصص كامل يوضح طريقة `call()` المطلوبة والطرق الاختيارية مثل `supports_function_calling()` و`get_context_window_size()`.
+
+## استخدام LLM المخصص
+
+```python
+from crewai import Agent, Task, Crew
+
+custom_llm = CustomLLM(
+    model="my-custom-model",
+    api_key="your-api-key",
+    endpoint="https://api.example.com/v1/chat/completions",
+    temperature=0.7
+)
+
+agent = Agent(
+    role="Research Assistant",
+    goal="Find and analyze information",
+    backstory="You are a research assistant.",
+    llm=custom_llm
+)
+
+task = Task(
+    description="Research the latest developments in AI",
+    expected_output="A comprehensive summary",
+    agent=agent
+)
+
+crew = Crew(agents=[agent], tasks=[task])
+result = crew.kickoff()
+```
+
+## الطرق المطلوبة
+
+### البنّاء: `__init__()`
+
+**مهم**: يجب استدعاء `super().__init__(model, temperature)` مع المعاملات المطلوبة.
+
+### الطريقة المجردة: `call()`
+
+طريقة `call()` هي قلب تنفيذ LLM. يجب أن تقبل الرسائل وتعيد استجابة نصية وتعالج الأدوات واستدعاء الدوال إذا كانت مدعومة.
+
+يغطي هذا الدليل أساسيات تنفيذ LLM مخصصة في CrewAI.

docs/edge/ar/learn/custom-manager-agent.mdx

@@ -0,0 +1,81 @@
+---
+title: Agent مدير مخصص
+description: تعلم كيفية تعيين Agent مخصص كمدير في CrewAI، مما يوفر مزيدًا من التحكم في إدارة المهام والتنسيق.
+icon: user-shield
+mode: "wide"
+---
+
+# تعيين Agent محدد كمدير في CrewAI
+
+يتيح CrewAI للمستخدمين تعيين Agent محدد كمدير للـ Crew، مما يوفر مزيدًا من التحكم في إدارة المهام وتنسيقها.
+
+## استخدام سمة `manager_agent`
+
+تتيح لك سمة `manager_agent` تعريف Agent مخصص لإدارة الـ Crew. سيشرف هذا الـ Agent على العملية بأكملها لضمان إتمام المهام بكفاءة وبأعلى المعايير.
+
+```python Code
+import os
+from crewai import Agent, Task, Crew, Process
+
+researcher = Agent(
+    role="Researcher",
+    goal="Conduct thorough research and analysis on AI and AI agents",
+    backstory="You're an expert researcher...",
+    allow_delegation=False,
+)
+
+writer = Agent(
+    role="Senior Writer",
+    goal="Create compelling content about AI and AI agents",
+    backstory="You're a senior writer...",
+    allow_delegation=False,
+)
+
+task = Task(
+    description="Generate a list of 5 interesting ideas for an article...",
+    expected_output="5 bullet points, each with a paragraph and accompanying notes.",
+)
+
+manager = Agent(
+    role="Project Manager",
+    goal="Efficiently manage the crew and ensure high-quality task completion",
+    backstory="You're an experienced project manager...",
+    allow_delegation=True,
+)
+
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[task],
+    manager_agent=manager,
+    process=Process.hierarchical,
+)
+
+result = crew.kickoff()
+```
+
+## فوائد Agent المدير المخصص
+
+- **تحكم محسّن**: تخصيص نهج الإدارة ليناسب الاحتياجات المحددة لمشروعك.
+- **تنسيق محسّن**: ضمان تنسيق المهام وإدارتها بكفاءة من قبل Agent ذي خبرة.
+- **إدارة قابلة للتخصيص**: تعريف أدوار ومسؤوليات إدارية تتماشى مع أهداف مشروعك.
+
+## تعيين LLM للمدير
+
+إذا كنت تستخدم العملية الهرمية ولا تريد تعيين Agent مدير مخصص، يمكنك تحديد نموذج اللغة للمدير:
+
+```python Code
+from crewai import LLM
+
+manager_llm = LLM(model="gpt-4o")
+
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[task],
+    process=Process.hierarchical,
+    manager_llm=manager_llm
+)
+```
+
+<Note>
+يجب تعيين إما `manager_agent` أو `manager_llm` عند استخدام العملية الهرمية.
+</Note>

docs/edge/ar/learn/customizing-agents.mdx

@@ -0,0 +1,67 @@
+---
+title: تخصيص الـ Agents
+description: دليل شامل لتخصيص الـ Agents لأدوار ومهام محددة وتخصيصات متقدمة ضمن إطار عمل CrewAI.
+icon: user-pen
+mode: "wide"
+---
+
+## السمات القابلة للتخصيص
+
+يعتمد بناء فريق CrewAI فعّال على القدرة على تخصيص Agents الذكاء الاصطناعي ديناميكيًا لتلبية المتطلبات الفريدة لأي مشروع. يغطي هذا القسم السمات الأساسية التي يمكنك تخصيصها.
+
+### السمات الرئيسية للتخصيص
+
+| السمة              | الوصف                                                                                                                                               |
+|:-----------------------|:----------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Role**              | يحدد وظيفة الـ Agent ضمن Crew، مثل 'محلل' أو 'ممثل خدمة عملاء'.                                                                   |
+| **Goal**              | يعرّف أهداف الـ Agent، متوافقة مع دوره ومهمة Crew الشاملة.                                                                  |
+| **Backstory**         | يوفر عمقًا لشخصية الـ Agent، معززًا الدوافع والتفاعلات ضمن Crew.                                                              |
+| **Tools** *(اختياري)*        | يمثل القدرات أو الطرق التي يستخدمها الـ Agent للمهام.                                              |
+| **Cache** *(اختياري)*        | يحدد ما إذا كان الـ Agent يجب أن يستخدم ذاكرة مؤقتة لاستخدام الأدوات.                                                                                          |
+| **Max RPM**           | يعيّن الحد الأقصى للطلبات في الدقيقة (`max_rpm`).                                        |
+| **Verbose** *(اختياري)*      | يمكّن التسجيل التفصيلي للتصحيح والتحسين.                                                 |
+| **Allow Delegation** *(اختياري)* | يتحكم في تفويض المهام لـ Agents أخرى، الافتراضي `False`.                                                                                    |
+| **Max Iter** *(اختياري)*      | يحد الحد الأقصى لعدد التكرارات (`max_iter`) لمهمة، الافتراضي 25.                                    |
+
+## خيارات تخصيص متقدمة
+
+### تخصيص نموذج اللغة
+
+يمكن تخصيص الـ Agents بنماذج لغة محددة (`llm`) ونماذج لغة لاستدعاء الدوال (`function_calling_llm`)، مما يوفر تحكمًا متقدمًا في قدرات المعالجة وصنع القرار.
+
+## إعدادات الأداء والتصحيح
+
+- **وضع التفصيل**: يمكّن التسجيل التفصيلي لإجراءات الـ Agent.
+- **حد RPM**: يعيّن الحد الأقصى للطلبات في الدقيقة.
+
+### مثال: تعيين أدوات لـ Agent
+
+```python Code
+import os
+from crewai import Agent
+from crewai_tools import SerperDevTool
+
+os.environ["OPENAI_API_KEY"] = "Your Key"
+os.environ["SERPER_API_KEY"] = "Your Key"
+
+search_tool = SerperDevTool()
+
+agent = Agent(
+  role='Research Analyst',
+  goal='Provide up-to-date market analysis',
+  backstory='An expert analyst with a keen eye for market trends.',
+  tools=[search_tool],
+  memory=True,
+  verbose=True,
+  max_rpm=None,
+  max_iter=25,
+)
+```
+
+## التفويض والاستقلالية
+
+التحكم في قدرة الـ Agent على تفويض المهام أو طرح الأسئلة أمر حيوي لتخصيص استقلاليته وديناميكيات التعاون. افتراضيًا، سمة `allow_delegation` معيّنة على `False`.
+
+## الخلاصة
+
+تخصيص الـ Agents في CrewAI من خلال تعيين أدوارهم وأهدافهم وخلفياتهم وأدواتهم، إلى جانب خيارات متقدمة مثل تخصيص نموذج اللغة والذاكرة وإعدادات الأداء وتفضيلات التفويض، يجهّز فريق AI دقيق وقادر جاهز للتحديات المعقدة.

docs/edge/ar/learn/dalle-image-generation.mdx

@@ -0,0 +1,52 @@
+---
+title: "إنشاء الصور باستخدام DALL-E"
+description: "تعلم كيفية استخدام DALL-E لإنشاء صور مدعومة بالذكاء الاصطناعي في مشاريع CrewAI"
+icon: "image"
+mode: "wide"
+---
+
+يدعم CrewAI التكامل مع DALL-E من OpenAI، مما يتيح لـ Agents الذكاء الاصطناعي إنشاء صور كجزء من مهامهم. سيرشدك هذا الدليل عبر كيفية إعداد واستخدام أداة DALL-E في مشاريع CrewAI.
+
+## المتطلبات المسبقة
+
+- crewAI مثبّت (أحدث إصدار)
+- مفتاح OpenAI API مع وصول إلى DALL-E
+
+## إعداد أداة DALL-E
+
+<Steps>
+    <Step title="استيراد أداة DALL-E">
+        ```python
+        from crewai_tools import DallETool
+        ```
+    </Step>
+
+    <Step title="إضافة أداة DALL-E إلى تهيئة Agent">
+        ```python
+        @agent
+        def researcher(self) -> Agent:
+            return Agent(
+                config=self.agents_config['researcher'],
+                tools=[SerperDevTool(), DallETool()],
+                allow_delegation=False,
+                verbose=True
+            )
+        ```
+    </Step>
+</Steps>
+
+## استخدام أداة DALL-E
+
+بمجرد إضافة أداة DALL-E إلى Agent، يمكنه إنشاء صور بناءً على مطالبات نصية. ستعيد الأداة رابط URL للصورة المُنشأة.
+
+## أفضل الممارسات
+
+1. **كن محددًا في مطالبات إنشاء الصور** للحصول على أفضل النتائج.
+2. **ضع في اعتبارك وقت الإنشاء** - قد يستغرق إنشاء الصور بعض الوقت.
+3. **اتبع سياسات الاستخدام** - التزم دائمًا بسياسات استخدام OpenAI عند إنشاء الصور.
+
+## استكشاف الأخطاء
+
+1. **تحقق من وصول API** - تأكد من أن مفتاح OpenAI API لديه وصول إلى DALL-E.
+2. **توافق الإصدارات** - تأكد من استخدام أحدث إصدار من crewAI وcrewai-tools.
+3. **تهيئة الأداة** - تحقق من إضافة أداة DALL-E بشكل صحيح لقائمة أدوات الـ Agent.

docs/edge/ar/learn/execution-hooks.mdx

@@ -0,0 +1,86 @@
+---
+title: نظرة عامة على خطافات التنفيذ
+description: فهم واستخدام خطافات التنفيذ في CrewAI للتحكم الدقيق في عمليات الـ Agent
+mode: "wide"
+---
+
+توفر خطافات التنفيذ تحكمًا دقيقًا في سلوك وقت تشغيل Agents CrewAI. على عكس خطافات الانطلاق التي تعمل قبل وبعد تنفيذ Crew، تعترض خطافات التنفيذ عمليات محددة أثناء تنفيذ الـ Agent، مما يتيح لك تعديل السلوك وتنفيذ فحوصات أمان وإضافة مراقبة شاملة.
+
+## أنواع خطافات التنفيذ
+
+### 1. [خطافات استدعاء LLM](/learn/llm-hooks)
+
+التحكم ومراقبة تفاعلات نموذج اللغة:
+- **قبل استدعاء LLM**: تعديل المطالبات، التحقق من المدخلات، بوابات الموافقة
+- **بعد استدعاء LLM**: تحويل الاستجابات، تنقية المخرجات، تحديث سجل المحادثة
+
+### 2. [خطافات استدعاء الأدوات](/learn/tool-hooks)
+
+التحكم ومراقبة تنفيذ الأدوات:
+- **قبل استدعاء الأداة**: تعديل المدخلات، التحقق من المعاملات، حظر العمليات الخطرة
+- **بعد استدعاء الأداة**: تحويل النتائج، تنقية المخرجات، تسجيل تفاصيل التنفيذ
+
+## طرق تسجيل الخطافات
+
+### 1. خطافات بالمزخرفات (مُوصى بها)
+
+```python
+from crewai.hooks import before_llm_call, after_llm_call, before_tool_call, after_tool_call
+
+@before_llm_call
+def limit_iterations(context):
+    if context.iterations > 10:
+        return False
+    return None
+
+@after_llm_call
+def sanitize_response(context):
+    if "API_KEY" in context.response:
+        return context.response.replace("API_KEY", "[REDACTED]")
+    return None
+
+@before_tool_call
+def block_dangerous_tools(context):
+    if context.tool_name == "delete_database":
+        return False
+    return None
+```
+
+### 2. خطافات نطاق Crew
+
+```python
+from crewai import CrewBase
+from crewai.project import crew
+from crewai.hooks import before_llm_call_crew, after_tool_call_crew
+
+@CrewBase
+class MyProjCrew:
+    @before_llm_call_crew
+    def validate_inputs(self, context):
+        print(f"LLM call in {self.__class__.__name__}")
+        return None
+
+    @after_tool_call_crew
+    def log_results(self, context):
+        print(f"Tool result: {context.tool_result[:50]}...")
+        return None
+```
+
+## أفضل الممارسات
+
+1. **اجعل الخطافات مركّزة** - كل خطاف يجب أن يكون له مسؤولية واحدة واضحة
+2. **عالج الأخطاء بلطف**
+3. **عدّل السياق في مكانه**
+4. **استخدم تلميحات الأنواع**
+5. **نظّف في الاختبارات**
+
+## التوثيق ذو الصلة
+
+- [خطافات استدعاء LLM](/learn/llm-hooks)
+- [خطافات استدعاء الأدوات](/learn/tool-hooks)
+- [خطافات قبل وبعد الانطلاق](/learn/before-and-after-kickoff-hooks)
+- [التدخل البشري](/learn/human-in-the-loop)
+
+## الخلاصة
+
+توفر خطافات التنفيذ تحكمًا قويًا في سلوك وقت تشغيل الـ Agent. استخدمها لتنفيذ حواجز أمان وسير عمل موافقة ومراقبة شاملة ومنطق أعمال مخصص.

docs/edge/ar/learn/force-tool-output-as-result.mdx

@@ -0,0 +1,45 @@
+---
+title: فرض مخرجات الأداة كنتيجة
+description: تعلم كيفية فرض مخرجات الأداة كنتيجة لمهمة Agent في CrewAI.
+icon: wrench-simple
+mode: "wide"
+---
+
+## مقدمة
+
+في CrewAI، يمكنك فرض مخرجات أداة كنتيجة لمهمة Agent. هذه الميزة مفيدة عندما تريد التأكد من التقاط مخرجات الأداة وإعادتها كنتيجة للمهمة، متجنبًا أي تعديل من قبل الـ Agent أثناء تنفيذ المهمة.
+
+## فرض مخرجات الأداة كنتيجة
+
+لفرض مخرجات الأداة كنتيجة لمهمة Agent، تحتاج لتعيين معامل `result_as_answer` إلى `True` عند إضافة أداة إلى الـ Agent.
+
+```python Code
+from crewai.agent import Agent
+from my_tool import MyCustomTool
+
+coding_agent = Agent(
+        role="Data Scientist",
+        goal="Produce amazing reports on AI",
+        backstory="You work with data and AI",
+        tools=[MyCustomTool(result_as_answer=True)],
+    )
+
+task_result = coding_agent.execute_task(task)
+```
+
+## سير العمل أثناء التنفيذ
+
+<Steps>
+   <Step title="تنفيذ المهمة">
+      ينفذ الـ Agent المهمة باستخدام الأداة المقدمة.
+   </Step>
+   <Step title="مخرجات الأداة">
+      تولّد الأداة المخرجات التي تُلتقط كنتيجة للمهمة.
+   </Step>
+   <Step title="تفاعل الـ Agent">
+      قد يتأمل الـ Agent ويستخلص دروسًا من الأداة لكن لا يعدّل المخرجات.
+   </Step>
+   <Step title="إعادة النتيجة">
+      تُعاد مخرجات الأداة كنتيجة للمهمة دون أي تعديلات.
+   </Step>
+</Steps>

docs/edge/ar/learn/hierarchical-process.mdx

@@ -0,0 +1,76 @@
+---
+title: العملية الهرمية
+description: دليل شامل لفهم وتطبيق العملية الهرمية ضمن مشاريع CrewAI.
+icon: sitemap
+mode: "wide"
+---
+
+## مقدمة
+
+تقدم العملية الهرمية في CrewAI نهجًا منظمًا لإدارة المهام، محاكاةً للتسلسلات الهرمية التنظيمية التقليدية للتفويض والتنفيذ الفعّال للمهام.
+
+<Tip>
+    صُممت العملية الهرمية للاستفادة من نماذج متقدمة مثل GPT-4، مما يحسّن استخدام الرموز المميزة مع التعامل مع المهام المعقدة بكفاءة أكبر.
+</Tip>
+
+## نظرة عامة على العملية الهرمية
+
+افتراضيًا، تُدار المهام في CrewAI من خلال عملية متسلسلة. لكن اعتماد نهج هرمي يتيح تسلسلاً واضحًا في إدارة المهام، حيث يقوم Agent 'مدير' بتنسيق سير العمل وتفويض المهام والتحقق من النتائج.
+
+### الميزات الرئيسية
+
+- **تفويض المهام**: Agent مدير يوزّع المهام بين أعضاء Crew بناءً على أدوارهم وقدراتهم.
+- **التحقق من النتائج**: يقيّم المدير النتائج لضمان استيفائها للمعايير المطلوبة.
+- **سير عمل فعّال**: يحاكي الهياكل المؤسسية مقدمًا نهجًا منظمًا لإدارة المهام.
+
+## تنفيذ العملية الهرمية
+
+```python Code
+from crewai import Crew, Process, Agent
+
+researcher = Agent(
+    role='Researcher',
+    goal='Conduct in-depth analysis',
+    backstory='Experienced data analyst with a knack for uncovering hidden trends.',
+)
+writer = Agent(
+    role='Writer',
+    goal='Create engaging content',
+    backstory='Creative writer passionate about storytelling in technical domains.',
+)
+
+project_crew = Crew(
+    tasks=[...],
+    agents=[researcher, writer],
+    manager_llm="gpt-4o",
+    process=Process.hierarchical,
+    planning=True,
+)
+```
+
+### استخدام Agent مدير مخصص
+
+```python
+manager = Agent(
+    role="Project Manager",
+    goal="Efficiently manage the crew and ensure high-quality task completion",
+    backstory="You're an experienced project manager...",
+    allow_delegation=True,
+)
+
+project_crew = Crew(
+    tasks=[...],
+    agents=[researcher, writer],
+    manager_agent=manager,
+    process=Process.hierarchical,
+    planning=True,
+)
+```
+
+<Tip>
+    لمزيد من التفاصيل حول إنشاء وتخصيص Agent مدير، اطلع على [توثيق Agent المدير المخصص](/ar/learn/custom-manager-agent).
+</Tip>
+
+## الخلاصة
+
+اعتماد العملية الهرمية في CrewAI مع التهيئات الصحيحة وفهم قدرات النظام يسهّل نهجًا منظمًا وفعّالاً لإدارة المشاريع. استفد من الميزات المتقدمة والتخصيصات لتكييف سير العمل لاحتياجاتك المحددة.

docs/edge/ar/learn/human-feedback-in-flows.mdx

@@ -0,0 +1,98 @@
+---
+title: التغذية الراجعة البشرية في Flows
+description: تعلم كيفية دمج التغذية الراجعة البشرية مباشرة في CrewAI Flows باستخدام مزخرف @human_feedback
+icon: user-check
+mode: "wide"
+---
+
+## نظرة عامة
+
+<Note>
+يتطلب مزخرف `@human_feedback` إصدار **CrewAI 1.8.0 أو أحدث**. تأكد من تحديث تثبيتك قبل استخدام هذه الميزة.
+</Note>
+
+يمكّن مزخرف `@human_feedback` سير العمل البشري في الحلقة (HITL) مباشرة ضمن CrewAI Flows. يتيح لك إيقاف تنفيذ Flow مؤقتًا وعرض المخرجات لإنسان للمراجعة وجمع تعليقاته واختياريًا التوجيه إلى مستمعين مختلفين بناءً على نتيجة التعليقات.
+
+هذا مفيد بشكل خاص لـ:
+
+- **ضمان الجودة**: مراجعة المحتوى المُنشأ بالذكاء الاصطناعي قبل استخدامه
+- **بوابات القرار**: السماح للبشر باتخاذ قرارات حرجة في سير العمل الآلي
+- **سير عمل الموافقة**: تنفيذ أنماط الموافقة/الرفض/المراجعة
+- **التحسين التفاعلي**: جمع التعليقات لتحسين المخرجات تكراريًا
+
+## بداية سريعة
+
+```python Code
+from crewai.flow.flow import Flow, start, listen
+from crewai.flow.human_feedback import human_feedback
+
+class SimpleReviewFlow(Flow):
+    @start()
+    @human_feedback(message="Please review this content:")
+    def generate_content(self):
+        return "This is AI-generated content that needs review."
+
+    @listen(generate_content)
+    def process_feedback(self, result):
+        print(f"Content: {result.output}")
+        print(f"Human said: {result.feedback}")
+
+flow = SimpleReviewFlow()
+flow.kickoff()
+```
+
+## التوجيه مع emit
+
+عند تحديد `emit`، يصبح المزخرف موجّهًا. يُفسَّر التعليق البشري الحر بواسطة LLM ويُختزل إلى إحدى النتائج المحددة:
+
+```python Code
+from crewai.flow.flow import Flow, start, listen, or_
+from crewai.flow.human_feedback import human_feedback
+
+class ReviewFlow(Flow):
+    @start()
+    def generate_content(self):
+        return "Draft blog post content here..."
+
+    @human_feedback(
+        message="Do you approve this content for publication?",
+        emit=["approved", "rejected", "needs_revision"],
+        llm="gpt-4o-mini",
+        default_outcome="needs_revision",
+    )
+    @listen(or_("generate_content", "needs_revision"))
+    def review_content(self):
+        return "Draft blog post content here..."
+
+    @listen("approved")
+    def publish(self, result):
+        print(f"Publishing! User said: {result.feedback}")
+
+    @listen("rejected")
+    def discard(self, result):
+        print(f"Discarding. Reason: {result.feedback}")
+```
+
+## التعلم من التغذية الراجعة
+
+معامل `learn=True` يمكّن حلقة تغذية راجعة بين المراجعين البشريين ونظام الذاكرة. عند تمكينه، يحسّن النظام مخرجاته تدريجيًا بالتعلم من التصحيحات البشرية السابقة.
+
+## أفضل الممارسات
+
+1. **اكتب رسائل طلب واضحة**
+2. **اختر نتائج ذات معنى**
+3. **وفّر دائمًا نتيجة افتراضية**
+4. **استخدم سجل التعليقات لمسارات التدقيق**
+
+## التغذية الراجعة البشرية غير المتزامنة (غير محجوبة)
+
+استخدم معامل `provider` لتحديد استراتيجية جمع تعليقات مخصصة تتكامل مع أنظمة خارجية مثل Slack والبريد الإلكتروني وWebhooks وواجهات API.
+
+## التوثيق ذو الصلة
+
+- [نظرة عامة على Flows](/ar/concepts/flows)
+- [إدارة حالة Flow](/ar/guides/flows/mastering-flow-state)
+- [حفظ Flow](/ar/concepts/flows#persistence)
+- [التوجيه مع @router](/ar/concepts/flows#router)
+- [إدخال بشري عند التنفيذ](/ar/learn/human-input-on-execution)
+- [الذاكرة](/ar/concepts/memory)

docs/edge/ar/learn/human-in-the-loop.mdx

@@ -0,0 +1,80 @@
+---
+title: "سير عمل التدخل البشري (HITL)"
+description: "تعلم كيفية تنفيذ سير عمل التدخل البشري في CrewAI لتعزيز صنع القرار"
+icon: "user-check"
+mode: "wide"
+---
+
+التدخل البشري (HITL) هو نهج قوي يجمع بين الذكاء الاصطناعي والخبرة البشرية لتعزيز صنع القرار وتحسين نتائج المهام. يوفر CrewAI طرقًا متعددة لتنفيذ HITL حسب احتياجاتك.
+
+## اختيار نهج HITL
+
+يوفر CrewAI نهجين رئيسيين لتنفيذ سير عمل التدخل البشري:
+
+| النهج | الأنسب لـ | التكامل | الإصدار |
+|----------|----------|-------------|---------|
+| **قائم على Flow** (مزخرف `@human_feedback`) | التطوير المحلي، المراجعة عبر وحدة التحكم، سير العمل المتزامن | [التغذية الراجعة البشرية في Flows](/ar/learn/human-feedback-in-flows) | **1.8.0+** |
+| **قائم على Webhook** (المؤسسات) | نشر الإنتاج، سير العمل غير المتزامن، التكاملات الخارجية (Slack، Teams، إلخ) | هذا الدليل | - |
+
+<Tip>
+إذا كنت تبني Flows وتريد إضافة خطوات مراجعة بشرية مع توجيه بناءً على التعليقات، اطلع على دليل [التغذية الراجعة البشرية في Flows](/ar/learn/human-feedback-in-flows) لمزخرف `@human_feedback`.
+</Tip>
+
+## إعداد سير عمل HITL القائم على Webhook
+
+<Steps>
+    <Step title="تهيئة المهمة">
+        أعدّ مهمتك مع تمكين إدخال بشري.
+    </Step>
+
+    <Step title="توفير عنوان Webhook URL">
+        عند تشغيل Crew، أدرج عنوان Webhook URL لإدخال بشري.
+    </Step>
+
+    <Step title="تلقي إشعار Webhook">
+        بمجرد إتمام Crew المهمة التي تتطلب إدخالاً بشريًا، ستتلقى إشعار Webhook.
+    </Step>
+
+    <Step title="مراجعة مخرجات المهمة">
+        سيتوقف النظام في حالة `Pending Human Input`. راجع مخرجات المهمة بعناية.
+    </Step>
+
+    <Step title="إرسال التغذية الراجعة البشرية">
+        استدعِ نقطة نهاية الاستئناف لـ Crew.
+
+        <Warning>
+            **مهم: يجب توفير عناوين Webhook URL مرة أخرى**:
+            يجب توفير نفس عناوين Webhook URL في استدعاء الاستئناف التي استخدمتها في استدعاء الانطلاق.
+        </Warning>
+    </Step>
+
+    <Step title="معالجة التعليقات السلبية">
+        إذا قدمت تعليقات سلبية، سيعيد Crew محاولة المهمة مع سياق إضافي من تعليقاتك.
+    </Step>
+
+    <Step title="استمرار التنفيذ">
+        عند إرسال تعليقات إيجابية، سيستمر التنفيذ إلى الخطوات التالية.
+    </Step>
+</Steps>
+
+## أفضل الممارسات
+
+- **كن محددًا**: قدم تعليقات واضحة وقابلة للتنفيذ
+- **ابقَ ذا صلة**: أدرج فقط معلومات تساعد في تحسين تنفيذ المهمة
+- **كن في الوقت المناسب**: استجب لمطالبات HITL بسرعة لتجنب تأخير سير العمل
+- **راجع بعناية**: تحقق من تعليقاتك قبل الإرسال لضمان الدقة
+
+## حالات الاستخدام الشائعة
+
+سير عمل HITL مفيدة بشكل خاص لـ:
+- ضمان الجودة والتحقق
+- سيناريوهات صنع القرار المعقدة
+- العمليات الحساسة أو عالية المخاطر
+- المهام الإبداعية التي تتطلب حكمًا بشريًا
+- مراجعات الامتثال والتنظيم
+
+## ميزات المؤسسات
+
+<Card title="منصة إدارة HITL للـ Flow" icon="users-gear" href="https://docs-platform.crewai.com/platform/ar/features/flow-hitl-management">
+  يوفر CrewAI Enterprise نظام إدارة HITL شامل لـ Flows مع مراجعة داخل المنصة وتعيين المستجيبين والأذونات وسياسات التصعيد وإدارة SLA والتوجيه الديناميكي والتحليلات الكاملة. [تعلم المزيد](https://docs-platform.crewai.com/platform/ar/features/flow-hitl-management)
+</Card>

docs/edge/ar/learn/human-input-on-execution.mdx

@@ -0,0 +1,99 @@
+---
+title: الإدخال البشري أثناء التنفيذ
+description: دمج CrewAI مع الإدخال البشري أثناء التنفيذ في عمليات اتخاذ القرارات المعقدة والاستفادة الكاملة من إمكانيات خصائص وأدوات الوكيل.
+icon: user-plus
+mode: "wide"
+---
+
+## الإدخال البشري في تنفيذ الوكيل
+
+يُعد الإدخال البشري أمراً بالغ الأهمية في العديد من سيناريوهات تنفيذ الوكلاء، حيث يسمح للوكلاء بطلب معلومات إضافية أو توضيحات عند الضرورة.
+هذه الميزة مفيدة بشكل خاص في عمليات اتخاذ القرارات المعقدة أو عندما يحتاج الوكلاء إلى مزيد من التفاصيل لإكمال مهمة بفعالية.
+
+## استخدام الإدخال البشري مع CrewAI
+
+لدمج الإدخال البشري في تنفيذ الوكيل، قم بتعيين علامة `human_input` في تعريف المهمة. عند تفعيلها، يطلب الوكيل من المستخدم إدخالاً قبل تقديم إجابته النهائية.
+يمكن أن يوفر هذا الإدخال سياقاً إضافياً، أو يوضح الغموض، أو يتحقق من مخرجات الوكيل.
+
+### مثال:
+
+```shell
+pip install crewai
+```
+
+```python Code
+import os
+from crewai import Agent, Task, Crew
+from crewai_tools import SerperDevTool
+
+os.environ["SERPER_API_KEY"] = "Your Key"  # serper.dev API key
+os.environ["OPENAI_API_KEY"] = "Your Key"
+
+# Loading Tools
+search_tool = SerperDevTool()
+
+# Define your agents with roles, goals, tools, and additional attributes
+researcher = Agent(
+    role='Senior Research Analyst',
+    goal='Uncover cutting-edge developments in AI and data science',
+    backstory=(
+        "You are a Senior Research Analyst at a leading tech think tank. "
+        "Your expertise lies in identifying emerging trends and technologies in AI and data science. "
+        "You have a knack for dissecting complex data and presenting actionable insights."
+    ),
+    verbose=True,
+    allow_delegation=False,
+    tools=[search_tool]
+)
+writer = Agent(
+    role='Tech Content Strategist',
+    goal='Craft compelling content on tech advancements',
+    backstory=(
+        "You are a renowned Tech Content Strategist, known for your insightful and engaging articles on technology and innovation. "
+        "With a deep understanding of the tech industry, you transform complex concepts into compelling narratives."
+    ),
+    verbose=True,
+    allow_delegation=True,
+    tools=[search_tool],
+    cache=False,  # Disable cache for this agent
+)
+
+# Create tasks for your agents
+task1 = Task(
+    description=(
+        "Conduct a comprehensive analysis of the latest advancements in AI in 2025. "
+        "Identify key trends, breakthrough technologies, and potential industry impacts. "
+        "Compile your findings in a detailed report. "
+        "Make sure to check with a human if the draft is good before finalizing your answer."
+    ),
+    expected_output='A comprehensive full report on the latest AI advancements in 2025, leave nothing out',
+    agent=researcher,
+    human_input=True
+)
+
+task2 = Task(
+    description=(
+        "Using the insights from the researcher\'s report, develop an engaging blog post that highlights the most significant AI advancements. "
+        "Your post should be informative yet accessible, catering to a tech-savvy audience. "
+        "Aim for a narrative that captures the essence of these breakthroughs and their implications for the future."
+    ),
+    expected_output='A compelling 3 paragraphs blog post formatted as markdown about the latest AI advancements in 2025',
+    agent=writer,
+    human_input=True
+)
+
+# Instantiate your crew with a sequential process
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[task1, task2],
+    verbose=True,
+    memory=True,
+    planning=True  # Enable planning feature for the crew
+)
+
+# Get your crew to work!
+result = crew.kickoff()
+
+print("######################")
+print(result)
+```

docs/edge/ar/learn/kickoff-async.mdx

@@ -0,0 +1,306 @@
+---
+title: تشغيل الطاقم بشكل غير متزامن
+description: تشغيل الطاقم بشكل غير متزامن
+icon: rocket-launch
+mode: "wide"
+---
+
+## مقدمة
+
+يوفر CrewAI القدرة على تشغيل طاقم بشكل غير متزامن، مما يتيح لك بدء تنفيذ الطاقم بطريقة غير حاجبة.
+هذه الميزة مفيدة بشكل خاص عندما تريد تشغيل عدة أطقم بشكل متزامن أو عندما تحتاج إلى أداء مهام أخرى أثناء تنفيذ الطاقم.
+
+يقدم CrewAI نهجين للتنفيذ غير المتزامن:
+
+| الطريقة | النوع | الوصف |
+|--------|------|-------------|
+| `akickoff()` | غير متزامن أصلي | async/await أصلي عبر سلسلة التنفيذ بالكامل |
+| `kickoff_async()` | قائم على الخيوط | يغلف التنفيذ المتزامن في `asyncio.to_thread` |
+
+<Note>
+لأحمال العمل عالية التزامن، يُوصى باستخدام `akickoff()` لأنه يستخدم async أصلي لتنفيذ المهام وعمليات الذاكرة واسترجاع المعرفة.
+</Note>
+
+## التنفيذ غير المتزامن الأصلي مع `akickoff()`
+
+توفر طريقة `akickoff()` تنفيذاً غير متزامن أصلياً حقيقياً، باستخدام async/await عبر سلسلة التنفيذ بالكامل بما في ذلك تنفيذ المهام وعمليات الذاكرة واستعلامات المعرفة.
+
+### توقيع الطريقة
+
+```python Code
+async def akickoff(self, inputs: dict) -> CrewOutput:
+```
+
+### المعاملات
+
+- `inputs` (dict): قاموس يحتوي على بيانات الإدخال المطلوبة للمهام.
+
+### القيمة المُرجعة
+
+- `CrewOutput`: كائن يمثل نتيجة تنفيذ الطاقم.
+
+### مثال: تنفيذ طاقم غير متزامن أصلي
+
+```python Code
+import asyncio
+from crewai import Crew, Agent, Task
+
+# Create an agent
+coding_agent = Agent(
+    role="Python Data Analyst",
+    goal="Analyze data and provide insights using Python",
+    backstory="You are an experienced data analyst with strong Python skills.",
+    allow_code_execution=True
+)
+
+# Create a task
+data_analysis_task = Task(
+    description="Analyze the given dataset and calculate the average age of participants. Ages: {ages}",
+    agent=coding_agent,
+    expected_output="The average age of the participants."
+)
+
+# Create a crew
+analysis_crew = Crew(
+    agents=[coding_agent],
+    tasks=[data_analysis_task]
+)
+
+# Native async execution
+async def main():
+    result = await analysis_crew.akickoff(inputs={"ages": [25, 30, 35, 40, 45]})
+    print("Crew Result:", result)
+
+asyncio.run(main())
+```
+
+### مثال: عدة أطقم غير متزامنة أصلية
+
+تشغيل عدة أطقم بشكل متزامن باستخدام `asyncio.gather()` مع async أصلي:
+
+```python Code
+import asyncio
+from crewai import Crew, Agent, Task
+
+coding_agent = Agent(
+    role="Python Data Analyst",
+    goal="Analyze data and provide insights using Python",
+    backstory="You are an experienced data analyst with strong Python skills.",
+    allow_code_execution=True
+)
+
+task_1 = Task(
+    description="Analyze the first dataset and calculate the average age. Ages: {ages}",
+    agent=coding_agent,
+    expected_output="The average age of the participants."
+)
+
+task_2 = Task(
+    description="Analyze the second dataset and calculate the average age. Ages: {ages}",
+    agent=coding_agent,
+    expected_output="The average age of the participants."
+)
+
+crew_1 = Crew(agents=[coding_agent], tasks=[task_1])
+crew_2 = Crew(agents=[coding_agent], tasks=[task_2])
+
+async def main():
+    results = await asyncio.gather(
+        crew_1.akickoff(inputs={"ages": [25, 30, 35, 40, 45]}),
+        crew_2.akickoff(inputs={"ages": [20, 22, 24, 28, 30]})
+    )
+
+    for i, result in enumerate(results, 1):
+        print(f"Crew {i} Result:", result)
+
+asyncio.run(main())
+```
+
+### مثال: async أصلي لمدخلات متعددة
+
+استخدم `akickoff_for_each()` لتنفيذ طاقمك على مدخلات متعددة بشكل متزامن مع async أصلي:
+
+```python Code
+import asyncio
+from crewai import Crew, Agent, Task
+
+coding_agent = Agent(
+    role="Python Data Analyst",
+    goal="Analyze data and provide insights using Python",
+    backstory="You are an experienced data analyst with strong Python skills.",
+    allow_code_execution=True
+)
+
+data_analysis_task = Task(
+    description="Analyze the dataset and calculate the average age. Ages: {ages}",
+    agent=coding_agent,
+    expected_output="The average age of the participants."
+)
+
+analysis_crew = Crew(
+    agents=[coding_agent],
+    tasks=[data_analysis_task]
+)
+
+async def main():
+    datasets = [
+        {"ages": [25, 30, 35, 40, 45]},
+        {"ages": [20, 22, 24, 28, 30]},
+        {"ages": [30, 35, 40, 45, 50]}
+    ]
+
+    results = await analysis_crew.akickoff_for_each(datasets)
+
+    for i, result in enumerate(results, 1):
+        print(f"Dataset {i} Result:", result)
+
+asyncio.run(main())
+```
+
+## التنفيذ غير المتزامن القائم على الخيوط مع `kickoff_async()`
+
+توفر طريقة `kickoff_async()` تنفيذاً غير متزامن عن طريق تغليف `kickoff()` المتزامن في خيط. هذا مفيد للتكامل البسيط مع async أو للتوافق مع الإصدارات السابقة.
+
+### توقيع الطريقة
+
+```python Code
+async def kickoff_async(self, inputs: dict) -> CrewOutput:
+```
+
+### المعاملات
+
+- `inputs` (dict): قاموس يحتوي على بيانات الإدخال المطلوبة للمهام.
+
+### القيمة المُرجعة
+
+- `CrewOutput`: كائن يمثل نتيجة تنفيذ الطاقم.
+
+### مثال: تنفيذ غير متزامن قائم على الخيوط
+
+```python Code
+import asyncio
+from crewai import Crew, Agent, Task
+
+coding_agent = Agent(
+    role="Python Data Analyst",
+    goal="Analyze data and provide insights using Python",
+    backstory="You are an experienced data analyst with strong Python skills.",
+    allow_code_execution=True
+)
+
+data_analysis_task = Task(
+    description="Analyze the given dataset and calculate the average age of participants. Ages: {ages}",
+    agent=coding_agent,
+    expected_output="The average age of the participants."
+)
+
+analysis_crew = Crew(
+    agents=[coding_agent],
+    tasks=[data_analysis_task]
+)
+
+async def async_crew_execution():
+    result = await analysis_crew.kickoff_async(inputs={"ages": [25, 30, 35, 40, 45]})
+    print("Crew Result:", result)
+
+asyncio.run(async_crew_execution())
+```
+
+### مثال: عدة أطقم غير متزامنة قائمة على الخيوط
+
+```python Code
+import asyncio
+from crewai import Crew, Agent, Task
+
+coding_agent = Agent(
+    role="Python Data Analyst",
+    goal="Analyze data and provide insights using Python",
+    backstory="You are an experienced data analyst with strong Python skills.",
+    allow_code_execution=True
+)
+
+task_1 = Task(
+    description="Analyze the first dataset and calculate the average age of participants. Ages: {ages}",
+    agent=coding_agent,
+    expected_output="The average age of the participants."
+)
+
+task_2 = Task(
+    description="Analyze the second dataset and calculate the average age of participants. Ages: {ages}",
+    agent=coding_agent,
+    expected_output="The average age of the participants."
+)
+
+crew_1 = Crew(agents=[coding_agent], tasks=[task_1])
+crew_2 = Crew(agents=[coding_agent], tasks=[task_2])
+
+async def async_multiple_crews():
+    result_1 = crew_1.kickoff_async(inputs={"ages": [25, 30, 35, 40, 45]})
+    result_2 = crew_2.kickoff_async(inputs={"ages": [20, 22, 24, 28, 30]})
+
+    results = await asyncio.gather(result_1, result_2)
+
+    for i, result in enumerate(results, 1):
+        print(f"Crew {i} Result:", result)
+
+asyncio.run(async_multiple_crews())
+```
+
+## البث غير المتزامن
+
+تدعم كلتا الطريقتين غير المتزامنتين البث عند تعيين `stream=True` على الطاقم:
+
+```python Code
+import asyncio
+from crewai import Crew, Agent, Task
+
+agent = Agent(
+    role="Researcher",
+    goal="Research and summarize topics",
+    backstory="You are an expert researcher."
+)
+
+task = Task(
+    description="Research the topic: {topic}",
+    agent=agent,
+    expected_output="A comprehensive summary of the topic."
+)
+
+crew = Crew(
+    agents=[agent],
+    tasks=[task],
+    stream=True  # Enable streaming
+)
+
+async def main():
+    streaming_output = await crew.akickoff(inputs={"topic": "AI trends in 2024"})
+
+    # Async iteration over streaming chunks
+    async for chunk in streaming_output:
+        print(f"Chunk: {chunk.content}")
+
+    # Access final result after streaming completes
+    result = streaming_output.result
+    print(f"Final result: {result.raw}")
+
+asyncio.run(main())
+```
+
+## حالات الاستخدام المحتملة
+
+- **توليد المحتوى بالتوازي**: تشغيل عدة أطقم مستقلة بشكل غير متزامن، كل منها مسؤول عن توليد محتوى حول مواضيع مختلفة. على سبيل المثال، قد يبحث طاقم ويصوغ مقالاً عن اتجاهات الذكاء الاصطناعي، بينما يولد طاقم آخر منشورات وسائل التواصل الاجتماعي حول إطلاق منتج جديد.
+
+- **مهام أبحاث السوق المتزامنة**: إطلاق عدة أطقم بشكل غير متزامن لإجراء أبحاث السوق بالتوازي. قد يحلل طاقم اتجاهات الصناعة، بينما يفحص آخر استراتيجيات المنافسين، ويقيّم ثالث مشاعر المستهلكين.
+
+- **وحدات تخطيط السفر المستقلة**: تنفيذ أطقم منفصلة للتخطيط المستقل لجوانب مختلفة من رحلة. قد يتعامل طاقم مع خيارات الرحلات الجوية، وآخر مع الإقامة، وثالث يخطط للأنشطة.
+
+## الاختيار بين `akickoff()` و `kickoff_async()`
+
+| الميزة | `akickoff()` | `kickoff_async()` |
+|---------|--------------|-------------------|
+| نموذج التنفيذ | async/await أصلي | غلاف قائم على الخيوط |
+| تنفيذ المهام | غير متزامن مع `aexecute_sync()` | متزامن في مجمع الخيوط |
+| عمليات الذاكرة | غير متزامنة | متزامنة في مجمع الخيوط |
+| استرجاع المعرفة | غير متزامن | متزامن في مجمع الخيوط |
+| الأفضل لـ | أحمال العمل عالية التزامن والمرتبطة بالإدخال/الإخراج | التكامل البسيط مع async |
+| دعم البث | نعم | نعم |

docs/edge/ar/learn/kickoff-for-each.mdx

@@ -0,0 +1,54 @@
+---
+title: تشغيل الطاقم لكل عنصر
+description: تشغيل الطاقم لكل عنصر في قائمة
+icon: at
+mode: "wide"
+---
+
+## مقدمة
+
+يوفر CrewAI القدرة على تشغيل طاقم لكل عنصر في قائمة، مما يتيح لك تنفيذ الطاقم لكل عنصر في القائمة.
+هذه الميزة مفيدة بشكل خاص عندما تحتاج إلى تنفيذ نفس مجموعة المهام لعناصر متعددة.
+
+## تشغيل طاقم لكل عنصر
+
+لتشغيل طاقم لكل عنصر في قائمة، استخدم طريقة `kickoff_for_each()`.
+تنفذ هذه الطريقة الطاقم لكل عنصر في القائمة، مما يتيح لك معالجة عناصر متعددة بكفاءة.
+
+إليك مثالاً على كيفية تشغيل طاقم لكل عنصر في قائمة:
+
+```python Code
+from crewai import Crew, Agent, Task
+
+# Create an agent with code execution enabled
+coding_agent = Agent(
+    role="Python Data Analyst",
+    goal="Analyze data and provide insights using Python",
+    backstory="You are an experienced data analyst with strong Python skills.",
+    allow_code_execution=True
+)
+
+# Create a task that requires code execution
+data_analysis_task = Task(
+    description="Analyze the given dataset and calculate the average age of participants. Ages: {ages}",
+    agent=coding_agent,
+    expected_output="The average age calculated from the dataset"
+)
+
+# Create a crew and add the task
+analysis_crew = Crew(
+    agents=[coding_agent],
+    tasks=[data_analysis_task],
+    verbose=True,
+    memory=False
+)
+
+datasets = [
+  { "ages": [25, 30, 35, 40, 45] },
+  { "ages": [20, 25, 30, 35, 40] },
+  { "ages": [30, 35, 40, 45, 50] }
+]
+
+# Execute the crew
+result = analysis_crew.kickoff_for_each(inputs=datasets)
+```

docs/edge/ar/learn/litellm-removal-guide.mdx

@@ -0,0 +1,358 @@
+---
+title: استخدام CrewAI بدون LiteLLM
+description: كيفية استخدام CrewAI مع التكاملات الأصلية للمزودين وإزالة اعتمادية LiteLLM من مشروعك.
+icon: shield-check
+mode: "wide"
+---
+
+## نظرة عامة
+
+يدعم CrewAI مسارين للاتصال بمزودي LLM:
+
+1. **التكاملات الأصلية** — اتصالات SDK مباشرة مع OpenAI وAnthropic وGoogle Gemini وAzure OpenAI وAWS Bedrock
+2. **LiteLLM كاحتياط** — طبقة ترجمة تدعم أكثر من 100 مزود إضافي
+
+يشرح هذا الدليل كيفية استخدام CrewAI حصرياً مع التكاملات الأصلية للمزودين، مع إزالة أي اعتمادية على LiteLLM.
+
+<Warning>
+  تم عزل حزمة `litellm` على PyPI بسبب حادث أمني/موثوقية. إذا كنت تعتمد على مزودين يحتاجون LiteLLM، يجب عليك الانتقال إلى التكاملات الأصلية. توفر لك تكاملات CrewAI الأصلية الوظائف الكاملة بدون LiteLLM.
+</Warning>
+
+## لماذا إزالة LiteLLM؟
+
+- **تقليل سطح الاعتماديات** — حزم أقل تعني مخاطر أقل محتملة في سلسلة التوريد
+- **أداء أفضل** — تتواصل حزم SDK الأصلية مباشرة مع واجهات برمجة تطبيقات المزودين، مما يلغي طبقة الترجمة
+- **تصحيح أخطاء أبسط** — طبقة تجريد واحدة أقل بين كودك والمزود
+- **حجم تثبيت أصغر** — يجلب LiteLLM العديد من الاعتماديات العابرة
+
+## المزودون الأصليون (لا يحتاجون LiteLLM)
+
+هؤلاء المزودون يستخدمون حزم SDK الخاصة بهم ويعملون بدون تثبيت LiteLLM:
+
+<CardGroup cols={2}>
+  <Card title="OpenAI" icon="bolt">
+    GPT-4o، GPT-4o-mini، o1، o3-mini، والمزيد.
+    ```bash
+    uv add "crewai[openai]"
+    ```
+  </Card>
+  <Card title="Anthropic" icon="a">
+    Claude Sonnet، Claude Haiku، والمزيد.
+    ```bash
+    uv add "crewai[anthropic]"
+    ```
+  </Card>
+  <Card title="Google Gemini" icon="google">
+    Gemini 2.0 Flash، Gemini 2.0 Pro، والمزيد.
+    ```bash
+    uv add "crewai[gemini]"
+    ```
+  </Card>
+  <Card title="Azure OpenAI" icon="microsoft">
+    نماذج OpenAI المستضافة على Azure.
+    ```bash
+    uv add "crewai[azure]"
+    ```
+  </Card>
+  <Card title="AWS Bedrock" icon="aws">
+    Claude، Llama، Titan، والمزيد عبر AWS.
+    ```bash
+    uv add "crewai[bedrock]"
+    ```
+  </Card>
+</CardGroup>
+
+<Info>
+  إذا كنت تستخدم المزودين الأصليين فقط، فلن تحتاج **أبداً** لتثبيت `crewai[litellm]`. حزمة `crewai` الأساسية بالإضافة إلى الإضافة الخاصة بالمزود الذي اخترته هي كل ما تحتاجه.
+</Info>
+
+## كيفية التحقق مما إذا كنت تستخدم LiteLLM
+
+### تحقق من سلاسل النماذج الخاصة بك
+
+إذا كان كودك يستخدم بادئات النماذج هذه، فأنت تمرر عبر LiteLLM:
+
+| البادئة | المزود | يستخدم LiteLLM؟ |
+|--------|----------|---------------|
+| `ollama/` | Ollama | ✅ نعم |
+| `groq/` | Groq | ✅ نعم |
+| `together_ai/` | Together AI | ✅ نعم |
+| `mistral/` | Mistral | ✅ نعم |
+| `cohere/` | Cohere | ✅ نعم |
+| `huggingface/` | Hugging Face | ✅ نعم |
+| `openai/` | OpenAI | ❌ أصلي |
+| `anthropic/` | Anthropic | ❌ أصلي |
+| `gemini/` | Google Gemini | ❌ أصلي |
+| `azure/` | Azure OpenAI | ❌ أصلي |
+| `bedrock/` | AWS Bedrock | ❌ أصلي |
+
+### تحقق مما إذا كان LiteLLM مثبتاً
+
+```bash
+# Using pip
+pip show litellm
+
+# Using uv
+uv pip show litellm
+```
+
+إذا أرجع الأمر معلومات الحزمة، فإن LiteLLM مثبت في بيئتك.
+
+### تحقق من اعتمادياتك
+
+انظر إلى ملف `pyproject.toml` الخاص بك بحثاً عن `crewai[litellm]`:
+
+```toml
+# If you see this, you have LiteLLM as a dependency
+dependencies = [
+    "crewai[litellm]>=0.100.0",  # ← Uses LiteLLM
+]
+
+# Change to a native provider extra instead
+dependencies = [
+    "crewai[openai]>=0.100.0",   # ← Native, no LiteLLM
+]
+```
+
+## دليل الانتقال
+
+### الخطوة 1: حدد مزودك الحالي
+
+ابحث عن جميع استدعاءات `LLM()` وسلاسل النماذج في كودك:
+
+```bash
+# Search your codebase for LLM model strings
+grep -r "LLM(" --include="*.py" .
+grep -r "llm=" --include="*.yaml" .
+grep -r "llm:" --include="*.yaml" .
+```
+
+### الخطوة 2: انتقل إلى مزود أصلي
+
+<Tabs>
+  <Tab title="الانتقال إلى OpenAI">
+    ```python
+    from crewai import LLM
+
+    # Before (LiteLLM):
+    # llm = LLM(model="groq/llama-3.1-70b")
+
+    # After (Native):
+    llm = LLM(model="openai/gpt-4o")
+    ```
+
+    ```bash
+    # Install
+    uv add "crewai[openai]"
+
+    # Set your API key
+    export OPENAI_API_KEY="sk-..."
+    ```
+  </Tab>
+  <Tab title="الانتقال إلى Anthropic">
+    ```python
+    from crewai import LLM
+
+    # Before (LiteLLM):
+    # llm = LLM(model="together_ai/meta-llama/Meta-Llama-3.1-70B")
+
+    # After (Native):
+    llm = LLM(model="anthropic/claude-sonnet-4-20250514")
+    ```
+
+    ```bash
+    # Install
+    uv add "crewai[anthropic]"
+
+    # Set your API key
+    export ANTHROPIC_API_KEY="sk-ant-..."
+    ```
+  </Tab>
+  <Tab title="الانتقال إلى Gemini">
+    ```python
+    from crewai import LLM
+
+    # Before (LiteLLM):
+    # llm = LLM(model="mistral/mistral-large-latest")
+
+    # After (Native):
+    llm = LLM(model="gemini/gemini-2.0-flash")
+    ```
+
+    ```bash
+    # Install
+    uv add "crewai[gemini]"
+
+    # Set your API key
+    export GEMINI_API_KEY="..."
+    ```
+  </Tab>
+  <Tab title="الانتقال إلى Azure OpenAI">
+    ```python
+    from crewai import LLM
+
+    # After (Native):
+    llm = LLM(
+        model="azure/your-deployment-name",
+        api_key="your-azure-api-key",
+        base_url="https://your-resource.openai.azure.com",
+        api_version="2024-06-01"
+    )
+    ```
+
+    ```bash
+    # Install
+    uv add "crewai[azure]"
+    ```
+  </Tab>
+  <Tab title="الانتقال إلى AWS Bedrock">
+    ```python
+    from crewai import LLM
+
+    # After (Native):
+    llm = LLM(
+        model="bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0",
+        aws_region_name="us-east-1"
+    )
+    ```
+
+    ```bash
+    # Install
+    uv add "crewai[bedrock]"
+
+    # Configure AWS credentials
+    export AWS_ACCESS_KEY_ID="..."
+    export AWS_SECRET_ACCESS_KEY="..."
+    export AWS_DEFAULT_REGION="us-east-1"
+    ```
+  </Tab>
+</Tabs>
+
+### الخطوة 3: الاحتفاظ بـ Ollama بدون LiteLLM
+
+إذا كنت تستخدم Ollama وتريد الاستمرار في استخدامه، يمكنك الاتصال عبر واجهة برمجة تطبيقات Ollama المتوافقة مع OpenAI:
+
+```python
+from crewai import LLM
+
+# Before (LiteLLM):
+# llm = LLM(model="ollama/llama3")
+
+# After (OpenAI-compatible mode, no LiteLLM needed):
+llm = LLM(
+    model="openai/llama3",
+    base_url="http://localhost:11434/v1",
+    api_key="ollama"  # Ollama doesn't require a real API key
+)
+```
+
+<Tip>
+  العديد من خوادم الاستدلال المحلية (Ollama، vLLM، LM Studio، llama.cpp) توفر واجهة برمجة تطبيقات متوافقة مع OpenAI. يمكنك استخدام بادئة `openai/` مع `base_url` مخصص للاتصال بأي منها بشكل أصلي.
+</Tip>
+
+### الخطوة 4: تحديث إعدادات YAML
+
+```yaml
+# Before (LiteLLM providers):
+researcher:
+  role: Research Specialist
+  goal: Conduct research
+  backstory: A dedicated researcher
+  llm: groq/llama-3.1-70b          # ← LiteLLM
+
+# After (Native provider):
+researcher:
+  role: Research Specialist
+  goal: Conduct research
+  backstory: A dedicated researcher
+  llm: openai/gpt-4o               # ← Native
+```
+
+### الخطوة 5: إزالة LiteLLM
+
+بمجرد انتقال جميع مراجع النماذج الخاصة بك:
+
+```bash
+# Remove litellm from your project
+uv remove litellm
+
+# Or if using pip
+pip uninstall litellm
+
+# Update your pyproject.toml: change crewai[litellm] to your provider extra
+# e.g., crewai[openai], crewai[anthropic], crewai[gemini]
+```
+
+### الخطوة 6: التحقق
+
+شغّل مشروعك وتأكد من أن كل شيء يعمل:
+
+```bash
+# Run your crew
+crewai run
+
+# Or run your tests
+uv run pytest
+```
+
+## مرجع سريع: خريطة سلاسل النماذج
+
+فيما يلي مسارات الانتقال الشائعة من المزودين المعتمدين على LiteLLM إلى المزودين الأصليين:
+
+```python
+from crewai import LLM
+
+# ─── LiteLLM providers → Native alternatives ────────────────────
+
+# Groq → OpenAI or Anthropic
+# llm = LLM(model="groq/llama-3.1-70b")
+llm = LLM(model="openai/gpt-4o-mini")           # Fast & affordable
+llm = LLM(model="anthropic/claude-haiku-3-5")    # Fast & affordable
+
+# Together AI → OpenAI or Gemini
+# llm = LLM(model="together_ai/meta-llama/Meta-Llama-3.1-70B")
+llm = LLM(model="openai/gpt-4o")                 # High quality
+llm = LLM(model="gemini/gemini-2.0-flash")       # Fast & capable
+
+# Mistral → Anthropic or OpenAI
+# llm = LLM(model="mistral/mistral-large-latest")
+llm = LLM(model="anthropic/claude-sonnet-4-20250514")  # High quality
+
+# Ollama → OpenAI-compatible (keep using local models)
+# llm = LLM(model="ollama/llama3")
+llm = LLM(
+    model="openai/llama3",
+    base_url="http://localhost:11434/v1",
+    api_key="ollama"
+)
+```
+
+## الأسئلة الشائعة
+
+<AccordionGroup>
+  <Accordion title="هل أفقد أي وظائف بإزالة LiteLLM؟">
+    لا، إذا كنت تستخدم أحد المزودين الخمسة المدعومين أصلياً (OpenAI، Anthropic، Gemini، Azure، Bedrock). تدعم هذه التكاملات الأصلية جميع ميزات CrewAI بما في ذلك البث واستدعاء الأدوات والمخرجات المنظمة والمزيد. ستفقد فقط الوصول إلى المزودين المتاحين حصرياً عبر LiteLLM (مثل Groq وTogether AI وMistral كمزودين من الدرجة الأولى).
+  </Accordion>
+  <Accordion title="هل يمكنني استخدام عدة مزودين أصليين في نفس الوقت؟">
+    نعم. ثبّت إضافات متعددة واستخدم مزودين مختلفين لوكلاء مختلفين:
+    ```bash
+    uv add "crewai[openai,anthropic,gemini]"
+    ```
+    ```python
+    researcher = Agent(llm="openai/gpt-4o", ...)
+    writer = Agent(llm="anthropic/claude-sonnet-4-20250514", ...)
+    ```
+  </Accordion>
+  <Accordion title="هل LiteLLM آمن للاستخدام الآن؟">
+    بغض النظر عن حالة العزل، فإن تقليل سطح اعتمادياتك يُعد ممارسة أمنية جيدة. إذا كنت تحتاج فقط مزودين يدعمهم CrewAI أصلياً، فلا يوجد سبب لإبقاء LiteLLM مثبتاً.
+  </Accordion>
+  <Accordion title="ماذا عن متغيرات البيئة مثل OPENAI_API_KEY؟">
+    يستخدم المزودون الأصليون نفس متغيرات البيئة التي اعتدت عليها. لا حاجة لتغييرات على `OPENAI_API_KEY` أو `ANTHROPIC_API_KEY` أو `GEMINI_API_KEY` وغيرها.
+  </Accordion>
+</AccordionGroup>
+
+## موارد ذات صلة
+
+- [اتصالات LLM](/ar/learn/llm-connections) — الدليل الكامل لربط CrewAI مع أي LLM
+- [مفاهيم LLM](/ar/concepts/llms) — فهم نماذج اللغة الكبيرة في CrewAI
+- [دليل اختيار LLM](/ar/learn/llm-selection-guide) — اختيار النموذج المناسب لحالة استخدامك

docs/edge/ar/learn/llm-connections.mdx

@@ -0,0 +1,214 @@
+---
+title: الاتصال بأي LLM
+description: دليل شامل لدمج CrewAI مع نماذج اللغة الكبيرة المختلفة (LLMs) باستخدام LiteLLM، بما في ذلك المزودون المدعومون وخيارات الإعداد.
+icon: brain-circuit
+mode: "wide"
+---
+
+## ربط CrewAI بنماذج اللغة الكبيرة
+
+يتصل CrewAI بنماذج اللغة الكبيرة من خلال تكاملات SDK الأصلية لأكثر المزودين شيوعاً (OpenAI وAnthropic وGoogle Gemini وAzure وAWS Bedrock)، ويستخدم LiteLLM كاحتياط مرن لجميع المزودين الآخرين.
+
+<Note>
+    افتراضياً، يستخدم CrewAI نموذج `gpt-4o-mini`. يتم تحديد ذلك بواسطة متغير البيئة `OPENAI_MODEL_NAME`، الذي يكون قيمته الافتراضية "gpt-4o-mini" إذا لم يتم تعيينه.
+    يمكنك بسهولة إعداد وكلائك لاستخدام نموذج أو مزود مختلف كما هو موضح في هذا الدليل.
+</Note>
+
+## المزودون المدعومون
+
+يدعم LiteLLM مجموعة واسعة من المزودين، بما في ذلك على سبيل المثال لا الحصر:
+
+- OpenAI
+- Anthropic
+- Google (Vertex AI, Gemini)
+- Azure OpenAI
+- AWS (Bedrock, SageMaker)
+- Cohere
+- VoyageAI
+- Hugging Face
+- Ollama
+- Mistral AI
+- Replicate
+- Together AI
+- AI21
+- Cloudflare Workers AI
+- DeepInfra
+- Groq
+- SambaNova
+- Nebius AI Studio
+- [NVIDIA NIMs](https://docs.api.nvidia.com/nim/reference/models-1)
+- والمزيد!
+
+للحصول على قائمة كاملة ومحدثة بالمزودين المدعومين، يرجى الرجوع إلى [وثائق مزودي LiteLLM](https://docs.litellm.ai/docs/providers).
+
+<Info>
+  لاستخدام أي مزود غير مغطى بتكامل أصلي، أضف LiteLLM كاعتمادية لمشروعك:
+  ```bash
+  uv add 'crewai[litellm]'
+  ```
+  يستخدم المزودون الأصليون (OpenAI، Anthropic، Google Gemini، Azure، AWS Bedrock) إضافات SDK الخاصة بهم — راجع [أمثلة إعداد المزودين](/ar/concepts/llms#provider-configuration-examples).
+</Info>
+
+## تغيير نموذج اللغة الكبير
+
+لاستخدام LLM مختلف مع وكلاء CrewAI، لديك عدة خيارات:
+
+<Tabs>
+    <Tab title="باستخدام معرف نصي">
+    مرر اسم النموذج كسلسلة نصية عند تهيئة الوكيل:
+        <CodeGroup>
+            ```python Code
+            from crewai import Agent
+
+            # Using OpenAI's GPT-4
+            openai_agent = Agent(
+                role='OpenAI Expert',
+                goal='Provide insights using GPT-4',
+                backstory="An AI assistant powered by OpenAI's latest model.",
+                llm='gpt-4'
+            )
+
+            # Using Anthropic's Claude
+            claude_agent = Agent(
+                role='Anthropic Expert',
+                goal='Analyze data using Claude',
+                backstory="An AI assistant leveraging Anthropic's language model.",
+                llm='claude-2'
+            )
+            ```
+        </CodeGroup>
+    </Tab>
+    <Tab title="باستخدام فئة LLM">
+    لمزيد من الإعداد التفصيلي، استخدم فئة LLM:
+        <CodeGroup>
+            ```python Code
+            from crewai import Agent, LLM
+
+            llm = LLM(
+                model="gpt-4",
+                temperature=0.7,
+                base_url="https://api.openai.com/v1",
+                api_key="your-api-key-here"
+            )
+
+            agent = Agent(
+                role='Customized LLM Expert',
+                goal='Provide tailored responses',
+                backstory="An AI assistant with custom LLM settings.",
+                llm=llm
+            )
+            ```
+        </CodeGroup>
+    </Tab>
+</Tabs>
+
+## خيارات الإعداد
+
+عند إعداد LLM لوكيلك، يمكنك الوصول إلى مجموعة واسعة من المعاملات:
+
+| المعامل | النوع | الوصف |
+|:----------|:-----:|:-------------|
+| **model** | `str` | اسم النموذج المراد استخدامه (مثل "gpt-4"، "claude-2") |
+| **temperature** | `float` | يتحكم في العشوائية في المخرجات (0.0 إلى 1.0) |
+| **max_tokens** | `int` | الحد الأقصى لعدد الرموز المولدة |
+| **top_p** | `float` | يتحكم في تنوع المخرجات (0.0 إلى 1.0) |
+| **frequency_penalty** | `float` | يعاقب الرموز الجديدة بناءً على تكرارها في النص حتى الآن |
+| **presence_penalty** | `float` | يعاقب الرموز الجديدة بناءً على وجودها في النص حتى الآن |
+| **stop** | `str`, `List[str]` | تسلسل(ات) لإيقاف التوليد |
+| **base_url** | `str` | عنوان URL الأساسي لنقطة نهاية API |
+| **api_key** | `str` | مفتاح API الخاص بك للمصادقة |
+
+للحصول على قائمة كاملة بالمعاملات وأوصافها، راجع وثائق فئة LLM.
+
+## الاتصال بنماذج LLM المتوافقة مع OpenAI
+
+يمكنك الاتصال بنماذج LLM المتوافقة مع OpenAI باستخدام متغيرات البيئة أو عن طريق تعيين خصائص محددة في فئة LLM:
+
+<Tabs>
+    <Tab title="باستخدام متغيرات البيئة">
+        <CodeGroup>
+        ```python Generic
+        import os
+
+        os.environ["OPENAI_API_KEY"] = "your-api-key"
+        os.environ["OPENAI_API_BASE"] = "https://api.your-provider.com/v1"
+        os.environ["OPENAI_MODEL_NAME"] = "your-model-name"
+        ```
+
+        ```python Google
+        import os
+
+        # Example using Gemini's OpenAI-compatible API.
+        os.environ["OPENAI_API_KEY"] = "your-gemini-key"  # Should start with AIza...
+        os.environ["OPENAI_API_BASE"] = "https://generativelanguage.googleapis.com/v1beta/openai/"
+        os.environ["OPENAI_MODEL_NAME"] = "openai/gemini-2.0-flash"  # Add your Gemini model here, under openai/
+        ```
+        </CodeGroup>
+    </Tab>
+    <Tab title="باستخدام خصائص فئة LLM">
+        <CodeGroup>
+            ```python Generic
+            llm = LLM(
+                model="custom-model-name",
+                api_key="your-api-key",
+                base_url="https://api.your-provider.com/v1"
+            )
+            agent = Agent(llm=llm, ...)
+            ```
+
+            ```python Google
+            # Example using Gemini's OpenAI-compatible API
+            llm = LLM(
+                model="openai/gemini-2.0-flash",
+                base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
+                api_key="your-gemini-key",  # Should start with AIza...
+            )
+            agent = Agent(llm=llm, ...)
+            ```
+        </CodeGroup>
+    </Tab>
+</Tabs>
+
+## استخدام النماذج المحلية مع Ollama
+
+للنماذج المحلية مثل تلك التي يوفرها Ollama:
+
+<Steps>
+    <Step title="تحميل وتثبيت Ollama">
+    [انقر هنا لتحميل وتثبيت Ollama](https://ollama.com/download)
+    </Step>
+    <Step title="سحب النموذج المطلوب">
+    على سبيل المثال، شغّل `ollama pull llama3.2` لتحميل النموذج.
+    </Step>
+    <Step title="إعداد وكيلك">
+        <CodeGroup>
+        ```python Code
+            agent = Agent(
+                role='Local AI Expert',
+                goal='Process information using a local model',
+                backstory="An AI assistant running on local hardware.",
+                llm=LLM(model="ollama/llama3.2", base_url="http://localhost:11434")
+            )
+            ```
+        </CodeGroup>
+    </Step>
+</Steps>
+
+## تغيير عنوان URL الأساسي لـ API
+
+يمكنك تغيير عنوان URL الأساسي لـ API لأي مزود LLM عن طريق تعيين معامل `base_url`:
+
+```python Code
+llm = LLM(
+    model="custom-model-name",
+    base_url="https://api.your-provider.com/v1",
+    api_key="your-api-key"
+)
+agent = Agent(llm=llm, ...)
+```
+
+هذا مفيد بشكل خاص عند العمل مع واجهات برمجة تطبيقات متوافقة مع OpenAI أو عندما تحتاج إلى تحديد نقطة نهاية مختلفة للمزود الذي اخترته.
+
+## الخاتمة
+
+من خلال الاستفادة من LiteLLM، يوفر CrewAI تكاملاً سلساً مع مجموعة واسعة من نماذج اللغة الكبيرة. تتيح لك هذه المرونة اختيار النموذج الأنسب لاحتياجاتك المحددة، سواء كنت تعطي الأولوية للأداء أو كفاءة التكلفة أو النشر المحلي. تذكر الرجوع إلى [وثائق LiteLLM](https://docs.litellm.ai/docs/) للحصول على أحدث المعلومات حول النماذج المدعومة وخيارات الإعداد.

docs/edge/ar/learn/llm-hooks.mdx

@@ -0,0 +1,427 @@
+---
+title: خطافات استدعاء LLM
+description: تعلم كيفية استخدام خطافات استدعاء LLM لاعتراض وتعديل والتحكم في تفاعلات نماذج اللغة في CrewAI
+mode: "wide"
+---
+
+توفر خطافات استدعاء LLM تحكماً دقيقاً في تفاعلات نماذج اللغة أثناء تنفيذ الوكيل. تتيح لك هذه الخطافات اعتراض استدعاءات LLM وتعديل المطالبات وتحويل الاستجابات وتنفيذ بوابات الموافقة وإضافة تسجيل أو مراقبة مخصصة.
+
+## نظرة عامة
+
+تُنفذ خطافات LLM في نقطتين حرجتين:
+- **قبل استدعاء LLM**: تعديل الرسائل، التحقق من المدخلات، أو حظر التنفيذ
+- **بعد استدعاء LLM**: تحويل الاستجابات، تنقية المخرجات، أو تعديل سجل المحادثة
+
+## أنواع الخطافات
+
+### خطافات ما قبل استدعاء LLM
+
+تُنفذ قبل كل استدعاء LLM، ويمكن لهذه الخطافات:
+- فحص وتعديل الرسائل المرسلة إلى LLM
+- حظر تنفيذ LLM بناءً على شروط
+- تنفيذ تحديد معدل أو بوابات موافقة
+- إضافة سياق أو رسائل نظام
+- تسجيل تفاصيل الطلب
+
+**التوقيع:**
+```python
+def before_hook(context: LLMCallHookContext) -> bool | None:
+    # Return False to block execution
+    # Return True or None to allow execution
+    ...
+```
+
+### خطافات ما بعد استدعاء LLM
+
+تُنفذ بعد كل استدعاء LLM، ويمكن لهذه الخطافات:
+- تعديل أو تنقية استجابات LLM
+- إضافة بيانات وصفية أو تنسيق
+- تسجيل تفاصيل الاستجابة
+- تحديث سجل المحادثة
+- تنفيذ تصفية المحتوى
+
+**التوقيع:**
+```python
+def after_hook(context: LLMCallHookContext) -> str | None:
+    # Return modified response string
+    # Return None to keep original response
+    ...
+```
+
+## سياق خطاف LLM
+
+يوفر كائن `LLMCallHookContext` وصولاً شاملاً لحالة التنفيذ:
+
+```python
+class LLMCallHookContext:
+    executor: CrewAgentExecutor  # Full executor reference
+    messages: list               # Mutable message list
+    agent: Agent                 # Current agent
+    task: Task                   # Current task
+    crew: Crew                   # Crew instance
+    llm: BaseLLM                 # LLM instance
+    iterations: int              # Current iteration count
+    response: str | None         # LLM response (after hooks only)
+```
+
+### تعديل الرسائل
+
+**مهم:** قم دائماً بتعديل الرسائل في مكانها:
+
+```python
+# ✅ Correct - modify in-place
+def add_context(context: LLMCallHookContext) -> None:
+    context.messages.append({"role": "system", "content": "Be concise"})
+
+# ❌ Wrong - replaces list reference
+def wrong_approach(context: LLMCallHookContext) -> None:
+    context.messages = [{"role": "system", "content": "Be concise"}]
+```
+
+## طرق التسجيل
+
+### 1. تسجيل الخطافات العامة
+
+تسجيل خطافات تنطبق على جميع استدعاءات LLM عبر جميع الأطقم:
+
+```python
+from crewai.hooks import register_before_llm_call_hook, register_after_llm_call_hook
+
+def log_llm_call(context):
+    print(f"LLM call by {context.agent.role} at iteration {context.iterations}")
+    return None  # Allow execution
+
+register_before_llm_call_hook(log_llm_call)
+```
+
+### 2. التسجيل باستخدام المزخرفات
+
+استخدم المزخرفات لصياغة أنظف:
+
+```python
+from crewai.hooks import before_llm_call, after_llm_call
+
+@before_llm_call
+def validate_iteration_count(context):
+    if context.iterations > 10:
+        print("⚠️ Exceeded maximum iterations")
+        return False  # Block execution
+    return None
+
+@after_llm_call
+def sanitize_response(context):
+    if context.response and "API_KEY" in context.response:
+        return context.response.replace("API_KEY", "[REDACTED]")
+    return None
+```
+
+### 3. خطافات نطاق الطاقم
+
+تسجيل خطافات لمثيل طاقم محدد:
+
+```python
+@CrewBase
+class MyProjCrew:
+    @before_llm_call_crew
+    def validate_inputs(self, context):
+        # Only applies to this crew
+        if context.iterations == 0:
+            print(f"Starting task: {context.task.description}")
+        return None
+
+    @after_llm_call_crew
+    def log_responses(self, context):
+        # Crew-specific response logging
+        print(f"Response length: {len(context.response)}")
+        return None
+
+    @crew
+    def crew(self) -> Crew:
+        return Crew(
+            agents=self.agents,
+            tasks=self.tasks,
+            process=Process.sequential,
+            verbose=True
+        )
+```
+
+## حالات الاستخدام الشائعة
+
+### 1. تحديد التكرارات
+
+```python
+@before_llm_call
+def limit_iterations(context: LLMCallHookContext) -> bool | None:
+    max_iterations = 15
+    if context.iterations > max_iterations:
+        print(f"⛔ Blocked: Exceeded {max_iterations} iterations")
+        return False  # Block execution
+    return None
+```
+
+### 2. بوابة الموافقة البشرية
+
+```python
+@before_llm_call
+def require_approval(context: LLMCallHookContext) -> bool | None:
+    if context.iterations > 5:
+        response = context.request_human_input(
+            prompt=f"Iteration {context.iterations}: Approve LLM call?",
+            default_message="Press Enter to approve, or type 'no' to block:"
+        )
+        if response.lower() == "no":
+            print("🚫 LLM call blocked by user")
+            return False
+    return None
+```
+
+### 3. إضافة سياق النظام
+
+```python
+@before_llm_call
+def add_guardrails(context: LLMCallHookContext) -> None:
+    # Add safety guidelines to every LLM call
+    context.messages.append({
+        "role": "system",
+        "content": "Ensure responses are factual and cite sources when possible."
+    })
+    return None
+```
+
+### 4. تنقية الاستجابات
+
+```python
+@after_llm_call
+def sanitize_sensitive_data(context: LLMCallHookContext) -> str | None:
+    if not context.response:
+        return None
+
+    # Remove sensitive patterns
+    import re
+    sanitized = context.response
+    sanitized = re.sub(r'\b\d{3}-\d{2}-\d{4}\b', '[SSN-REDACTED]', sanitized)
+    sanitized = re.sub(r'\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b', '[CARD-REDACTED]', sanitized)
+
+    return sanitized
+```
+
+### 5. تتبع التكاليف
+
+```python
+import tiktoken
+
+@before_llm_call
+def track_token_usage(context: LLMCallHookContext) -> None:
+    encoding = tiktoken.get_encoding("cl100k_base")
+    total_tokens = sum(
+        len(encoding.encode(msg.get("content", "")))
+        for msg in context.messages
+    )
+    print(f"📊 Input tokens: ~{total_tokens}")
+    return None
+
+@after_llm_call
+def track_response_tokens(context: LLMCallHookContext) -> None:
+    if context.response:
+        encoding = tiktoken.get_encoding("cl100k_base")
+        tokens = len(encoding.encode(context.response))
+        print(f"📊 Response tokens: ~{tokens}")
+    return None
+```
+
+### 6. تسجيل التصحيح
+
+```python
+@before_llm_call
+def debug_request(context: LLMCallHookContext) -> None:
+    print(f"""
+    🔍 LLM Call Debug:
+    - Agent: {context.agent.role}
+    - Task: {context.task.description[:50]}...
+    - Iteration: {context.iterations}
+    - Message Count: {len(context.messages)}
+    - Last Message: {context.messages[-1] if context.messages else 'None'}
+    """)
+    return None
+
+@after_llm_call
+def debug_response(context: LLMCallHookContext) -> None:
+    if context.response:
+        print(f"✅ Response Preview: {context.response[:100]}...")
+    return None
+```
+
+## إدارة الخطافات
+
+### إلغاء تسجيل الخطافات
+
+```python
+from crewai.hooks import (
+    unregister_before_llm_call_hook,
+    unregister_after_llm_call_hook
+)
+
+# Unregister specific hook
+def my_hook(context):
+    ...
+
+register_before_llm_call_hook(my_hook)
+# Later...
+unregister_before_llm_call_hook(my_hook)  # Returns True if found
+```
+
+### مسح الخطافات
+
+```python
+from crewai.hooks import (
+    clear_before_llm_call_hooks,
+    clear_after_llm_call_hooks,
+    clear_all_llm_call_hooks
+)
+
+# Clear specific hook type
+count = clear_before_llm_call_hooks()
+print(f"Cleared {count} before hooks")
+
+# Clear all LLM hooks
+before_count, after_count = clear_all_llm_call_hooks()
+print(f"Cleared {before_count} before and {after_count} after hooks")
+```
+
+### عرض الخطافات المسجلة
+
+```python
+from crewai.hooks import (
+    get_before_llm_call_hooks,
+    get_after_llm_call_hooks
+)
+
+# Get current hooks
+before_hooks = get_before_llm_call_hooks()
+after_hooks = get_after_llm_call_hooks()
+
+print(f"Registered: {len(before_hooks)} before, {len(after_hooks)} after")
+```
+
+## أنماط متقدمة
+
+### تنفيذ خطاف مشروط
+
+```python
+@before_llm_call
+def conditional_blocking(context: LLMCallHookContext) -> bool | None:
+    # Only block for specific agents
+    if context.agent.role == "researcher" and context.iterations > 10:
+        return False
+
+    # Only block for specific tasks
+    if "sensitive" in context.task.description.lower() and context.iterations > 5:
+        return False
+
+    return None
+```
+
+### تعديلات واعية بالسياق
+
+```python
+@before_llm_call
+def adaptive_prompting(context: LLMCallHookContext) -> None:
+    # Add different context based on iteration
+    if context.iterations == 0:
+        context.messages.append({
+            "role": "system",
+            "content": "Start with a high-level overview."
+        })
+    elif context.iterations > 3:
+        context.messages.append({
+            "role": "system",
+            "content": "Focus on specific details and provide examples."
+        })
+    return None
+```
+
+### ربط الخطافات
+
+```python
+# Multiple hooks execute in registration order
+
+@before_llm_call
+def first_hook(context):
+    print("1. First hook executed")
+    return None
+
+@before_llm_call
+def second_hook(context):
+    print("2. Second hook executed")
+    return None
+
+@before_llm_call
+def blocking_hook(context):
+    if context.iterations > 10:
+        print("3. Blocking hook - execution stopped")
+        return False  # Subsequent hooks won't execute
+    print("3. Blocking hook - execution allowed")
+    return None
+```
+
+## أفضل الممارسات
+
+1. **اجعل الخطافات مركزة**: يجب أن يكون لكل خطاف مسؤولية واحدة
+2. **تجنب الحسابات الثقيلة**: تُنفذ الخطافات في كل استدعاء LLM
+3. **تعامل مع الأخطاء بأناقة**: استخدم try-except لمنع فشل الخطافات من كسر التنفيذ
+4. **استخدم تلميحات الأنواع**: استفد من `LLMCallHookContext` لدعم أفضل في بيئة التطوير
+5. **وثّق سلوك الخطاف**: خاصة لشروط الحظر
+6. **اختبر الخطافات بشكل مستقل**: اختبر الخطافات وحدوياً قبل الاستخدام في الإنتاج
+7. **امسح الخطافات في الاختبارات**: استخدم `clear_all_llm_call_hooks()` بين تشغيلات الاختبار
+8. **عدّل في المكان**: قم دائماً بتعديل `context.messages` في مكانها، ولا تستبدلها
+
+## معالجة الأخطاء
+
+```python
+@before_llm_call
+def safe_hook(context: LLMCallHookContext) -> bool | None:
+    try:
+        # Your hook logic
+        if some_condition:
+            return False
+    except Exception as e:
+        print(f"⚠️ Hook error: {e}")
+        # Decide: allow or block on error
+        return None  # Allow execution despite error
+```
+
+## أمان الأنواع
+
+```python
+from crewai.hooks import LLMCallHookContext, BeforeLLMCallHookType, AfterLLMCallHookType
+
+# Explicit type annotations
+def my_before_hook(context: LLMCallHookContext) -> bool | None:
+    return None
+
+def my_after_hook(context: LLMCallHookContext) -> str | None:
+    return None
+
+# Type-safe registration
+register_before_llm_call_hook(my_before_hook)
+register_after_llm_call_hook(my_after_hook)
+```
+
+## استكشاف الأخطاء وإصلاحها
+
+### الخطاف لا يُنفذ
+- تحقق من أن الخطاف مسجل قبل تنفيذ الطاقم
+- تحقق مما إذا كان خطاف سابق أرجع `False` (يحظر الخطافات اللاحقة)
+- تأكد من أن توقيع الخطاف يطابق النوع المتوقع
+
+### تعديلات الرسائل لا تستمر
+- استخدم التعديلات في المكان: `context.messages.append()`
+- لا تستبدل القائمة: `context.messages = []`
+
+### تعديلات الاستجابة لا تعمل
+- أرجع السلسلة النصية المعدلة من خطافات ما بعد
+- إرجاع `None` يحتفظ بالاستجابة الأصلية
+
+## الخاتمة
+
+توفر خطافات استدعاء LLM إمكانيات قوية للتحكم في تفاعلات نماذج اللغة ومراقبتها في CrewAI. استخدمها لتنفيذ حواجز الأمان وبوابات الموافقة والتسجيل وتتبع التكاليف وتنقية الاستجابات. مع معالجة الأخطاء المناسبة وأمان الأنواع، تُمكّن الخطافات أنظمة وكلاء قوية وجاهزة للإنتاج.

docs/edge/ar/learn/llm-selection-guide.mdx

@@ -0,0 +1,821 @@
+---
+title: "دليل اختيار LLM الاستراتيجي"
+description: "إطار عمل استراتيجي لاختيار نموذج اللغة الكبير المناسب لوكلاء الذكاء الاصطناعي في CrewAI وكتابة تعريفات فعالة للمهام والوكلاء"
+icon: "brain-circuit"
+mode: "wide"
+---
+
+## نهج CrewAI في اختيار LLM
+
+بدلاً من توصيات نماذج محددة، ندعو إلى **إطار تفكير** يساعدك على اتخاذ قرارات مستنيرة بناءً على حالة استخدامك المحددة وقيودك ومتطلباتك. يتطور مشهد LLM بسرعة، مع ظهور نماذج جديدة بانتظام وتحديث النماذج الحالية بشكل متكرر. الأهم هو تطوير نهج منظم للتقييم يبقى ذا صلة بغض النظر عن النماذج المتاحة تحديداً.
+
+<Note>
+  يركز هذا الدليل على التفكير الاستراتيجي بدلاً من توصيات نماذج محددة،
+  حيث يتطور مشهد LLM بسرعة.
+</Note>
+
+## إطار القرار السريع
+
+<Steps>
+  <Step title="حلل مهامك">
+    ابدأ بفهم عميق لما تتطلبه مهامك فعلاً. ضع في الاعتبار التعقيد المعرفي
+    المطلوب وعمق الاستدلال اللازم وتنسيق المخرجات المتوقعة وحجم السياق الذي
+    سيحتاج النموذج لمعالجته. سيوجه هذا التحليل الأساسي كل قرار لاحق.
+  </Step>
+  <Step title="خريطة قدرات النماذج">
+    بمجرد فهم متطلباتك، اربطها بنقاط قوة النماذج. تتفوق عائلات النماذج
+    المختلفة في أنواع مختلفة من العمل؛ بعضها محسّن للاستدلال والتحليل وبعضها
+    للإبداع وتوليد المحتوى وبعضها للسرعة والكفاءة.
+  </Step>
+  <Step title="ضع في الاعتبار القيود">
+    ضع في حسبانك قيودك التشغيلية الواقعية بما في ذلك قيود الميزانية ومتطلبات
+    زمن الاستجابة واحتياجات خصوصية البيانات وقدرات البنية التحتية. قد لا يكون
+    النموذج الأفضل نظرياً هو الخيار الأفضل عملياً لوضعك.
+  </Step>
+  <Step title="اختبر وكرر">
+    ابدأ بنماذج موثوقة ومفهومة جيداً وحسّن بناءً على الأداء الفعلي في حالة
+    استخدامك المحددة. غالباً ما تختلف النتائج الواقعية عن المعايير النظرية، لذا
+    فإن الاختبار التجريبي ضروري.
+  </Step>
+</Steps>
+
+## Core Selection Framework
+
+### a. Task-First Thinking
+
+The most critical step in LLM selection is understanding what your task actually demands. Too often, teams select models based on general reputation or benchmark scores without carefully analyzing their specific requirements. This approach leads to either over-engineering simple tasks with expensive, complex models, or under-powering sophisticated work with models that lack the necessary capabilities.
+
+<Tabs>
+  <Tab title="Reasoning Complexity">
+    - **Simple Tasks** represent the majority of everyday AI work and include basic instruction following, straightforward data processing, and simple formatting operations. These tasks typically have clear inputs and outputs with minimal ambiguity. The cognitive load is low, and the model primarily needs to follow explicit instructions rather than engage in complex reasoning.
+
+    - **Complex Tasks** require multi-step reasoning, strategic thinking, and the ability to handle ambiguous or incomplete information. These might involve analyzing multiple data sources, developing comprehensive strategies, or solving problems that require breaking down into smaller components. The model needs to maintain context across multiple reasoning steps and often must make inferences that aren't explicitly stated.
+
+    - **Creative Tasks** demand a different type of cognitive capability focused on generating novel, engaging, and contextually appropriate content. This includes storytelling, marketing copy creation, and creative problem-solving. The model needs to understand nuance, tone, and audience while producing content that feels authentic and engaging rather than formulaic.
+
+  </Tab>
+
+  <Tab title="Output Requirements">
+    - **Structured Data** tasks require precision and consistency in format adherence. When working with JSON, XML, or database formats, the model must reliably produce syntactically correct output that can be programmatically processed. These tasks often have strict validation requirements and little tolerance for format errors, making reliability more important than creativity.
+
+    - **Creative Content** outputs demand a balance of technical competence and creative flair. The model needs to understand audience, tone, and brand voice while producing content that engages readers and achieves specific communication goals. Quality here is often subjective and requires models that can adapt their writing style to different contexts and purposes.
+
+    - **Technical Content** sits between structured data and creative content, requiring both precision and clarity. Documentation, code generation, and technical analysis need to be accurate and comprehensive while remaining accessible to the intended audience. The model must understand complex technical concepts and communicate them effectively.
+
+  </Tab>
+
+  <Tab title="Context Needs">
+    - **Short Context** scenarios involve focused, immediate tasks where the model needs to process limited information quickly. These are often transactional interactions where speed and efficiency matter more than deep understanding. The model doesn't need to maintain extensive conversation history or process large documents.
+
+    - **Long Context** requirements emerge when working with substantial documents, extended conversations, or complex multi-part tasks. The model needs to maintain coherence across thousands of tokens while referencing earlier information accurately. This capability becomes crucial for document analysis, comprehensive research, and sophisticated dialogue systems.
+
+    - **Very Long Context** scenarios push the boundaries of what's currently possible, involving massive document processing, extensive research synthesis, or complex multi-session interactions. These use cases require models specifically designed for extended context handling and often involve trade-offs between context length and processing speed.
+
+  </Tab>
+</Tabs>
+
+### b. Model Capability Mapping
+
+Understanding model capabilities requires looking beyond marketing claims and benchmark scores to understand the fundamental strengths and limitations of different model architectures and training approaches.
+
+<AccordionGroup>
+  <Accordion title="Reasoning Models" icon="brain">
+    Reasoning models represent a specialized category designed specifically for complex, multi-step thinking tasks. These models excel when problems require careful analysis, strategic planning, or systematic problem decomposition. They typically employ techniques like chain-of-thought reasoning or tree-of-thought processing to work through complex problems step by step.
+
+    The strength of reasoning models lies in their ability to maintain logical consistency across extended reasoning chains and to break down complex problems into manageable components. They're particularly valuable for strategic planning, complex analysis, and situations where the quality of reasoning matters more than speed of response.
+
+    However, reasoning models often come with trade-offs in terms of speed and cost. They may also be less suitable for creative tasks or simple operations where their sophisticated reasoning capabilities aren't needed. Consider these models when your tasks involve genuine complexity that benefits from systematic, step-by-step analysis.
+
+  </Accordion>
+
+  <Accordion title="General Purpose Models" icon="microchip">
+    General purpose models offer the most balanced approach to LLM selection, providing solid performance across a wide range of tasks without extreme specialization in any particular area. These models are trained on diverse datasets and optimized for versatility rather than peak performance in specific domains.
+
+    The primary advantage of general purpose models is their reliability and predictability across different types of work. They handle most standard business tasks competently, from research and analysis to content creation and data processing. This makes them excellent choices for teams that need consistent performance across varied workflows.
+
+    While general purpose models may not achieve the peak performance of specialized alternatives in specific domains, they offer operational simplicity and reduced complexity in model management. They're often the best starting point for new projects, allowing teams to understand their specific needs before potentially optimizing with more specialized models.
+
+  </Accordion>
+
+  <Accordion title="Fast & Efficient Models" icon="bolt">
+    Fast and efficient models prioritize speed, cost-effectiveness, and resource efficiency over sophisticated reasoning capabilities. These models are optimized for high-throughput scenarios where quick responses and low operational costs are more important than nuanced understanding or complex reasoning.
+
+    These models excel in scenarios involving routine operations, simple data processing, function calling, and high-volume tasks where the cognitive requirements are relatively straightforward. They're particularly valuable for applications that need to process many requests quickly or operate within tight budget constraints.
+
+    The key consideration with efficient models is ensuring that their capabilities align with your task requirements. While they can handle many routine operations effectively, they may struggle with tasks requiring nuanced understanding, complex reasoning, or sophisticated content generation. They're best used for well-defined, routine operations where speed and cost matter more than sophistication.
+
+  </Accordion>
+
+  <Accordion title="Creative Models" icon="pen">
+    Creative models are specifically optimized for content generation, writing quality, and creative thinking tasks. These models typically excel at understanding nuance, tone, and style while producing engaging, contextually appropriate content that feels natural and authentic.
+
+    The strength of creative models lies in their ability to adapt writing style to different audiences, maintain consistent voice and tone, and generate content that engages readers effectively. They often perform better on tasks involving storytelling, marketing copy, brand communications, and other content where creativity and engagement are primary goals.
+
+    When selecting creative models, consider not just their ability to generate text, but their understanding of audience, context, and purpose. The best creative models can adapt their output to match specific brand voices, target different audience segments, and maintain consistency across extended content pieces.
+
+  </Accordion>
+
+  <Accordion title="Open Source Models" icon="code">
+    Open source models offer unique advantages in terms of cost control, customization potential, data privacy, and deployment flexibility. These models can be run locally or on private infrastructure, providing complete control over data handling and model behavior.
+
+    The primary benefits of open source models include elimination of per-token costs, ability to fine-tune for specific use cases, complete data privacy, and independence from external API providers. They're particularly valuable for organizations with strict data privacy requirements, budget constraints, or specific customization needs.
+
+    However, open source models require more technical expertise to deploy and maintain effectively. Teams need to consider infrastructure costs, model management complexity, and the ongoing effort required to keep models updated and optimized. The total cost of ownership may be higher than cloud-based alternatives when factoring in technical overhead.
+
+  </Accordion>
+</AccordionGroup>
+
+## Strategic Configuration Patterns
+
+### a. Multi-Model Approach
+
+<Tip>
+  Use different models for different purposes within the same crew to optimize
+  both performance and cost.
+</Tip>
+
+The most sophisticated CrewAI implementations often employ multiple models strategically, assigning different models to different agents based on their specific roles and requirements. This approach allows teams to optimize for both performance and cost by using the most appropriate model for each type of work.
+
+Planning agents benefit from reasoning models that can handle complex strategic thinking and multi-step analysis. These agents often serve as the "brain" of the operation, developing strategies and coordinating other agents' work. Content agents, on the other hand, perform best with creative models that excel at writing quality and audience engagement. Processing agents handling routine operations can use efficient models that prioritize speed and cost-effectiveness.
+
+**Example: Research and Analysis Crew**
+
+```python
+from crewai import Agent, Task, Crew, LLM
+
+# High-capability reasoning model for strategic planning
+manager_llm = LLM(model="gemini-2.5-flash-preview-05-20", temperature=0.1)
+
+# Creative model for content generation
+content_llm = LLM(model="claude-3-5-sonnet-20241022", temperature=0.7)
+
+# Efficient model for data processing
+processing_llm = LLM(model="gpt-4o-mini", temperature=0)
+
+research_manager = Agent(
+    role="Research Strategy Manager",
+    goal="Develop comprehensive research strategies and coordinate team efforts",
+    backstory="Expert research strategist with deep analytical capabilities",
+    llm=manager_llm,  # High-capability model for complex reasoning
+    verbose=True
+)
+
+content_writer = Agent(
+    role="Research Content Writer",
+    goal="Transform research findings into compelling, well-structured reports",
+    backstory="Skilled writer who excels at making complex topics accessible",
+    llm=content_llm,  # Creative model for engaging content
+    verbose=True
+)
+
+data_processor = Agent(
+    role="Data Analysis Specialist",
+    goal="Extract and organize key data points from research sources",
+    backstory="Detail-oriented analyst focused on accuracy and efficiency",
+    llm=processing_llm,  # Fast, cost-effective model for routine tasks
+    verbose=True
+)
+
+crew = Crew(
+    agents=[research_manager, content_writer, data_processor],
+    tasks=[...],  # Your specific tasks
+    manager_llm=manager_llm,  # Manager uses the reasoning model
+    verbose=True
+)
+```
+
+The key to successful multi-model implementation is understanding how different agents interact and ensuring that model capabilities align with agent responsibilities. This requires careful planning but can result in significant improvements in both output quality and operational efficiency.
+
+### b. Component-Specific Selection
+
+<Tabs>
+  <Tab title="Manager LLM">
+    The manager LLM plays a crucial role in hierarchical CrewAI processes, serving as the coordination point for multiple agents and tasks. This model needs to excel at delegation, task prioritization, and maintaining context across multiple concurrent operations.
+
+    Effective manager LLMs require strong reasoning capabilities to make good delegation decisions, consistent performance to ensure predictable coordination, and excellent context management to track the state of multiple agents simultaneously. The model needs to understand the capabilities and limitations of different agents while optimizing task allocation for efficiency and quality.
+
+    Cost considerations are particularly important for manager LLMs since they're involved in every operation. The model needs to provide sufficient capability for effective coordination while remaining cost-effective for frequent use. This often means finding models that offer good reasoning capabilities without the premium pricing of the most sophisticated options.
+
+  </Tab>
+
+  <Tab title="Function Calling LLM">
+    Function calling LLMs handle tool usage across all agents, making them critical for crews that rely heavily on external tools and APIs. These models need to excel at understanding tool capabilities, extracting parameters accurately, and handling tool responses effectively.
+
+    The most important characteristics for function calling LLMs are precision and reliability rather than creativity or sophisticated reasoning. The model needs to consistently extract the correct parameters from natural language requests and handle tool responses appropriately. Speed is also important since tool usage often involves multiple round trips that can impact overall performance.
+
+    Many teams find that specialized function calling models or general purpose models with strong tool support work better than creative or reasoning-focused models for this role. The key is ensuring that the model can reliably bridge the gap between natural language instructions and structured tool calls.
+
+  </Tab>
+
+  <Tab title="Agent-Specific Overrides">
+    Individual agents can override crew-level LLM settings when their specific needs differ significantly from the general crew requirements. This capability allows for fine-tuned optimization while maintaining operational simplicity for most agents.
+
+    Consider agent-specific overrides when an agent's role requires capabilities that differ substantially from other crew members. For example, a creative writing agent might benefit from a model optimized for content generation, while a data analysis agent might perform better with a reasoning-focused model.
+
+    The challenge with agent-specific overrides is balancing optimization with operational complexity. Each additional model adds complexity to deployment, monitoring, and cost management. Teams should focus overrides on agents where the performance improvement justifies the additional complexity.
+
+  </Tab>
+</Tabs>
+
+## Task Definition Framework
+
+### a. Focus on Clarity Over Complexity
+
+Effective task definition is often more important than model selection in determining the quality of CrewAI outputs. Well-defined tasks provide clear direction and context that enable even modest models to perform well, while poorly defined tasks can cause even sophisticated models to produce unsatisfactory results.
+
+<AccordionGroup>
+  <Accordion title="Effective Task Descriptions" icon="list-check">
+    The best task descriptions strike a balance between providing sufficient detail and maintaining clarity. They should define the specific objective clearly enough that there's no ambiguity about what success looks like, while explaining the approach or methodology in enough detail that the agent understands how to proceed.
+
+    Effective task descriptions include relevant context and constraints that help the agent understand the broader purpose and any limitations they need to work within. They break complex work into focused steps that can be executed systematically, rather than presenting overwhelming, multi-faceted objectives that are difficult to approach systematically.
+
+    Common mistakes include being too vague about objectives, failing to provide necessary context, setting unclear success criteria, or combining multiple unrelated tasks into a single description. The goal is to provide enough information for the agent to succeed while maintaining focus on a single, clear objective.
+
+  </Accordion>
+
+  <Accordion title="Expected Output Guidelines" icon="bullseye">
+    Expected output guidelines serve as a contract between the task definition and the agent, clearly specifying what the deliverable should look like and how it will be evaluated. These guidelines should describe both the format and structure needed, as well as the key elements that must be included for the output to be considered complete.
+
+    The best output guidelines provide concrete examples of quality indicators and define completion criteria clearly enough that both the agent and human reviewers can assess whether the task has been completed successfully. This reduces ambiguity and helps ensure consistent results across multiple task executions.
+
+    Avoid generic output descriptions that could apply to any task, missing format specifications that leave agents guessing about structure, unclear quality standards that make evaluation difficult, or failing to provide examples or templates that help agents understand expectations.
+
+  </Accordion>
+</AccordionGroup>
+
+### b. Task Sequencing Strategy
+
+<Tabs>
+  <Tab title="Sequential Dependencies">
+    Sequential task dependencies are essential when tasks build upon previous outputs, information flows from one task to another, or quality depends on the completion of prerequisite work. This approach ensures that each task has access to the information and context it needs to succeed.
+
+    Implementing sequential dependencies effectively requires using the context parameter to chain related tasks, building complexity gradually through task progression, and ensuring that each task produces outputs that serve as meaningful inputs for subsequent tasks. The goal is to maintain logical flow between dependent tasks while avoiding unnecessary bottlenecks.
+
+    Sequential dependencies work best when there's a clear logical progression from one task to another and when the output of one task genuinely improves the quality or feasibility of subsequent tasks. However, they can create bottlenecks if not managed carefully, so it's important to identify which dependencies are truly necessary versus those that are merely convenient.
+
+  </Tab>
+
+  <Tab title="Parallel Execution">
+    Parallel execution becomes valuable when tasks are independent of each other, time efficiency is important, or different expertise areas are involved that don't require coordination. This approach can significantly reduce overall execution time while allowing specialized agents to work on their areas of strength simultaneously.
+
+    Successful parallel execution requires identifying tasks that can truly run independently, grouping related but separate work streams effectively, and planning for result integration when parallel tasks need to be combined into a final deliverable. The key is ensuring that parallel tasks don't create conflicts or redundancies that reduce overall quality.
+
+    Consider parallel execution when you have multiple independent research streams, different types of analysis that don't depend on each other, or content creation tasks that can be developed simultaneously. However, be mindful of resource allocation and ensure that parallel execution doesn't overwhelm your available model capacity or budget.
+
+  </Tab>
+</Tabs>
+
+## Optimizing Agent Configuration for LLM Performance
+
+### a. Role-Driven LLM Selection
+
+<Warning>
+  Generic agent roles make it impossible to select the right LLM. Specific roles
+  enable targeted model optimization.
+</Warning>
+
+The specificity of your agent roles directly determines which LLM capabilities matter most for optimal performance. This creates a strategic opportunity to match precise model strengths with agent responsibilities.
+
+**Generic vs. Specific Role Impact on LLM Choice:**
+
+When defining roles, think about the specific domain knowledge, working style, and decision-making frameworks that would be most valuable for the tasks the agent will handle. The more specific and contextual the role definition, the better the model can embody that role effectively.
+
+```python
+# ✅ Specific role - clear LLM requirements
+specific_agent = Agent(
+    role="SaaS Revenue Operations Analyst",  # Clear domain expertise needed
+    goal="Analyze recurring revenue metrics and identify growth opportunities",
+    backstory="Specialist in SaaS business models with deep understanding of ARR, churn, and expansion revenue",
+    llm=LLM(model="gpt-4o")  # Reasoning model justified for complex analysis
+)
+```
+
+**Role-to-Model Mapping Strategy:**
+
+- **"Research Analyst"** → Reasoning model (GPT-4o, Claude Sonnet) for complex analysis
+- **"Content Editor"** → Creative model (Claude, GPT-4o) for writing quality
+- **"Data Processor"** → Efficient model (GPT-4o-mini, Gemini Flash) for structured tasks
+- **"API Coordinator"** → Function-calling optimized model (GPT-4o, Claude) for tool usage
+
+### b. Backstory as Model Context Amplifier
+
+<Info>
+  Strategic backstories multiply your chosen LLM's effectiveness by providing
+  domain-specific context that generic prompting cannot achieve.
+</Info>
+
+A well-crafted backstory transforms your LLM choice from generic capability to specialized expertise. This is especially crucial for cost optimization - a well-contextualized efficient model can outperform a premium model without proper context.
+
+**Context-Driven Performance Example:**
+
+```python
+# Context amplifies model effectiveness
+domain_expert = Agent(
+    role="B2B SaaS Marketing Strategist",
+    goal="Develop comprehensive go-to-market strategies for enterprise software",
+    backstory="""
+    You have 10+ years of experience scaling B2B SaaS companies from Series A to IPO.
+    You understand the nuances of enterprise sales cycles, the importance of product-market
+    fit in different verticals, and how to balance growth metrics with unit economics.
+    You've worked with companies like Salesforce, HubSpot, and emerging unicorns, giving
+    you perspective on both established and disruptive go-to-market strategies.
+    """,
+    llm=LLM(model="claude-3-5-sonnet", temperature=0.3)  # Balanced creativity with domain knowledge
+)
+
+# This context enables Claude to perform like a domain expert
+# Without it, even it would produce generic marketing advice
+```
+
+**Backstory Elements That Enhance LLM Performance:**
+
+- **Domain Experience**: "10+ years in enterprise SaaS sales"
+- **Specific Expertise**: "Specializes in technical due diligence for Series B+ rounds"
+- **Working Style**: "Prefers data-driven decisions with clear documentation"
+- **Quality Standards**: "Insists on citing sources and showing analytical work"
+
+### c. Holistic Agent-LLM Optimization
+
+The most effective agent configurations create synergy between role specificity, backstory depth, and LLM selection. Each element reinforces the others to maximize model performance.
+
+**Optimization Framework:**
+
+```python
+# Example: Technical Documentation Agent
+tech_writer = Agent(
+    role="API Documentation Specialist",  # Specific role for clear LLM requirements
+    goal="Create comprehensive, developer-friendly API documentation",
+    backstory="""
+    You're a technical writer with 8+ years documenting REST APIs, GraphQL endpoints,
+    and SDK integration guides. You've worked with developer tools companies and
+    understand what developers need: clear examples, comprehensive error handling,
+    and practical use cases. You prioritize accuracy and usability over marketing fluff.
+    """,
+    llm=LLM(
+        model="claude-3-5-sonnet",  # Excellent for technical writing
+        temperature=0.1  # Low temperature for accuracy
+    ),
+    tools=[code_analyzer_tool, api_scanner_tool],
+    verbose=True
+)
+```
+
+**Alignment Checklist:**
+
+- ✅ **Role Specificity**: Clear domain and responsibilities
+- ✅ **LLM Match**: Model strengths align with role requirements
+- ✅ **Backstory Depth**: Provides domain context the LLM can leverage
+- ✅ **Tool Integration**: Tools support the agent's specialized function
+- ✅ **Parameter Tuning**: Temperature and settings optimize for role needs
+
+The key is creating agents where every configuration choice reinforces your LLM selection strategy, maximizing performance while optimizing costs.
+
+## Practical Implementation Checklist
+
+Rather than repeating the strategic framework, here's a tactical checklist for implementing your LLM selection decisions in CrewAI:
+
+<Steps>
+  <Step title="Audit Your Current Setup" icon="clipboard-check">
+    **What to Review:**
+    - Are all agents using the same LLM by default?
+    - Which agents handle the most complex reasoning tasks?
+    - Which agents primarily do data processing or formatting?
+    - Are any agents heavily tool-dependent?
+
+    **Action**: Document current agent roles and identify optimization opportunities.
+
+  </Step>
+
+  <Step title="Implement Crew-Level Strategy" icon="users-gear">
+    **Set Your Baseline:**
+    ```python
+    # Start with a reliable default for the crew
+    default_crew_llm = LLM(model="gpt-4o-mini")  # Cost-effective baseline
+
+    crew = Crew(
+        agents=[...],
+        tasks=[...],
+        memory=True
+    )
+    ```
+
+    **Action**: Establish your crew's default LLM before optimizing individual agents.
+
+  </Step>
+
+  <Step title="Optimize High-Impact Agents" icon="star">
+    **Identify and Upgrade Key Agents:**
+    ```python
+    # Manager or coordination agents
+    manager_agent = Agent(
+        role="Project Manager",
+        llm=LLM(model="gemini-2.5-flash-preview-05-20"),  # Premium for coordination
+        # ... rest of config
+    )
+
+    # Creative or customer-facing agents
+    content_agent = Agent(
+        role="Content Creator",
+        llm=LLM(model="claude-3-5-sonnet"),  # Best for writing
+        # ... rest of config
+    )
+    ```
+
+    **Action**: Upgrade 20% of your agents that handle 80% of the complexity.
+
+  </Step>
+
+  <Step title="Validate with Enterprise Testing" icon="test-tube">
+    **Once you deploy your agents to production:**
+    - Use [CrewAI AMP platform](https://app.crewai.com) to A/B test your model selections
+    - Run multiple iterations with real inputs to measure consistency and performance
+    - Compare cost vs. performance across your optimized setup
+    - Share results with your team for collaborative decision-making
+
+    **Action**: Replace guesswork with data-driven validation using the testing platform.
+
+  </Step>
+</Steps>
+
+### When to Use Different Model Types
+
+<Tabs>
+  <Tab title="Reasoning Models">
+    Reasoning models become essential when tasks require genuine multi-step logical thinking, strategic planning, or high-level decision making that benefits from systematic analysis. These models excel when problems need to be broken down into components and analyzed systematically rather than handled through pattern matching or simple instruction following.
+
+    Consider reasoning models for business strategy development, complex data analysis that requires drawing insights from multiple sources, multi-step problem solving where each step depends on previous analysis, and strategic planning tasks that require considering multiple variables and their interactions.
+
+    However, reasoning models often come with higher costs and slower response times, so they're best reserved for tasks where their sophisticated capabilities provide genuine value rather than being used for simple operations that don't require complex reasoning.
+
+  </Tab>
+
+  <Tab title="Creative Models">
+    Creative models become valuable when content generation is the primary output and the quality, style, and engagement level of that content directly impact success. These models excel when writing quality and style matter significantly, creative ideation or brainstorming is needed, or brand voice and tone are important considerations.
+
+    Use creative models for blog post writing and article creation, marketing copy that needs to engage and persuade, creative storytelling and narrative development, and brand communications where voice and tone are crucial. These models often understand nuance and context better than general purpose alternatives.
+
+    Creative models may be less suitable for technical or analytical tasks where precision and factual accuracy are more important than engagement and style. They're best used when the creative and communicative aspects of the output are primary success factors.
+
+  </Tab>
+
+  <Tab title="Efficient Models">
+    Efficient models are ideal for high-frequency, routine operations where speed and cost optimization are priorities. These models work best when tasks have clear, well-defined parameters and don't require sophisticated reasoning or creative capabilities.
+
+    Consider efficient models for data processing and transformation tasks, simple formatting and organization operations, function calling and tool usage where precision matters more than sophistication, and high-volume operations where cost per operation is a significant factor.
+
+    The key with efficient models is ensuring that their capabilities align with task requirements. They can handle many routine operations effectively but may struggle with tasks requiring nuanced understanding, complex reasoning, or sophisticated content generation.
+
+  </Tab>
+
+  <Tab title="Open Source Models">
+    Open source models become attractive when budget constraints are significant, data privacy requirements exist, customization needs are important, or local deployment is required for operational or compliance reasons.
+
+    Consider open source models for internal company tools where data privacy is paramount, privacy-sensitive applications that can't use external APIs, cost-optimized deployments where per-token pricing is prohibitive, and situations requiring custom model modifications or fine-tuning.
+
+    However, open source models require more technical expertise to deploy and maintain effectively. Consider the total cost of ownership including infrastructure, technical overhead, and ongoing maintenance when evaluating open source options.
+
+  </Tab>
+</Tabs>
+
+## Common CrewAI Model Selection Pitfalls
+
+<AccordionGroup>
+  <Accordion title="The 'One Model Fits All' Trap" icon="triangle-exclamation">
+    **The Problem**: Using the same LLM for all agents in a crew, regardless of their specific roles and responsibilities. This is often the default approach but rarely optimal.
+
+    **Real Example**: Using GPT-4o for both a strategic planning manager and a data extraction agent. The manager needs reasoning capabilities worth the premium cost, but the data extractor could perform just as well with GPT-4o-mini at a fraction of the price.
+
+    **CrewAI Solution**: Leverage agent-specific LLM configuration to match model capabilities with agent roles:
+    ```python
+    # Strategic agent gets premium model
+    manager = Agent(role="Strategy Manager", llm=LLM(model="gpt-4o"))
+
+    # Processing agent gets efficient model
+    processor = Agent(role="Data Processor", llm=LLM(model="gpt-4o-mini"))
+    ```
+
+  </Accordion>
+
+  <Accordion title="Ignoring Crew-Level vs Agent-Level LLM Hierarchy" icon="shuffle">
+    **The Problem**: Not understanding how CrewAI's LLM hierarchy works - crew LLM, manager LLM, and agent LLM settings can conflict or be poorly coordinated.
+
+    **Real Example**: Setting a crew to use Claude, but having agents configured with GPT models, creating inconsistent behavior and unnecessary model switching overhead.
+
+    **CrewAI Solution**: Plan your LLM hierarchy strategically:
+    ```python
+    crew = Crew(
+        agents=[agent1, agent2],
+        tasks=[task1, task2],
+        manager_llm=LLM(model="gpt-4o"),  # For crew coordination
+        process=Process.hierarchical  # When using manager_llm
+    )
+
+    # Agents inherit crew LLM unless specifically overridden
+    agent1 = Agent(llm=LLM(model="claude-3-5-sonnet"))  # Override for specific needs
+    ```
+
+  </Accordion>
+
+  <Accordion title="Function Calling Model Mismatch" icon="screwdriver-wrench">
+    **The Problem**: Choosing models based on general capabilities while ignoring function calling performance for tool-heavy CrewAI workflows.
+
+    **Real Example**: Selecting a creative-focused model for an agent that primarily needs to call APIs, search tools, or process structured data. The agent struggles with tool parameter extraction and reliable function calls.
+
+    **CrewAI Solution**: Prioritize function calling capabilities for tool-heavy agents:
+    ```python
+    # For agents that use many tools
+    tool_agent = Agent(
+        role="API Integration Specialist",
+        tools=[search_tool, api_tool, data_tool],
+        llm=LLM(model="gpt-4o"),  # Excellent function calling
+        # OR
+        llm=LLM(model="claude-3-5-sonnet")  # Also strong with tools
+    )
+    ```
+
+  </Accordion>
+
+  <Accordion title="Premature Optimization Without Testing" icon="gear">
+    **The Problem**: Making complex model selection decisions based on theoretical performance without validating with actual CrewAI workflows and tasks.
+
+    **Real Example**: Implementing elaborate model switching logic based on task types without testing if the performance gains justify the operational complexity.
+
+    **CrewAI Solution**: Start simple, then optimize based on real performance data:
+    ```python
+    # Start with this
+    crew = Crew(agents=[...], tasks=[...], llm=LLM(model="gpt-4o-mini"))
+
+    # Test performance, then optimize specific agents as needed
+    # Use Enterprise platform testing to validate improvements
+    ```
+
+  </Accordion>
+
+  <Accordion title="Overlooking Context and Memory Limitations" icon="brain">
+    **The Problem**: Not considering how model context windows interact with CrewAI's memory and context sharing between agents.
+
+    **Real Example**: Using a short-context model for agents that need to maintain conversation history across multiple task iterations, or in crews with extensive agent-to-agent communication.
+
+    **CrewAI Solution**: Match context capabilities to crew communication patterns.
+
+  </Accordion>
+</AccordionGroup>
+
+## Testing and Iteration Strategy
+
+<Steps>
+  <Step title="Start Simple" icon="play">
+    Begin with reliable, general-purpose models that are well-understood and
+    widely supported. This provides a stable foundation for understanding your
+    specific requirements and performance expectations before optimizing for
+    specialized needs.
+  </Step>
+  <Step title="Measure What Matters" icon="chart-line">
+    Develop metrics that align with your specific use case and business
+    requirements rather than relying solely on general benchmarks. Focus on
+    measuring outcomes that directly impact your success rather than theoretical
+    performance indicators.
+  </Step>
+  <Step title="Iterate Based on Results" icon="arrows-rotate">
+    Make model changes based on observed performance in your specific context
+    rather than theoretical considerations or general recommendations.
+    Real-world performance often differs significantly from benchmark results or
+    general reputation.
+  </Step>
+  <Step title="Consider Total Cost" icon="calculator">
+    Evaluate the complete cost of ownership including model costs, development
+    time, maintenance overhead, and operational complexity. The cheapest model
+    per token may not be the most cost-effective choice when considering all
+    factors.
+  </Step>
+</Steps>
+
+<Tip>
+  Focus on understanding your requirements first, then select models that best
+  match those needs. The best LLM choice is the one that consistently delivers
+  the results you need within your operational constraints.
+</Tip>
+
+### Enterprise-Grade Model Validation
+
+For teams serious about optimizing their LLM selection, the **CrewAI AMP platform** provides sophisticated testing capabilities that go far beyond basic CLI testing. The platform enables comprehensive model evaluation that helps you make data-driven decisions about your LLM strategy.
+
+<Frame>
+  ![Enterprise Testing Interface](/images/enterprise/enterprise-testing.png)
+</Frame>
+
+**Advanced Testing Features:**
+
+- **Multi-Model Comparison**: Test multiple LLMs simultaneously across the same tasks and inputs. Compare performance between GPT-4o, Claude, Llama, Groq, Cerebras, and other leading models in parallel to identify the best fit for your specific use case.
+
+- **Statistical Rigor**: Configure multiple iterations with consistent inputs to measure reliability and performance variance. This helps identify models that not only perform well but do so consistently across runs.
+
+- **Real-World Validation**: Use your actual crew inputs and scenarios rather than synthetic benchmarks. The platform allows you to test with your specific industry context, company information, and real use cases for more accurate evaluation.
+
+- **Comprehensive Analytics**: Access detailed performance metrics, execution times, and cost analysis across all tested models. This enables data-driven decision making rather than relying on general model reputation or theoretical capabilities.
+
+- **Team Collaboration**: Share testing results and model performance data across your team, enabling collaborative decision-making and consistent model selection strategies across projects.
+
+Go to [app.crewai.com](https://app.crewai.com) to get started!
+
+<Info>
+  The Enterprise platform transforms model selection from guesswork into a
+  data-driven process, enabling you to validate the principles in this guide
+  with your actual use cases and requirements.
+</Info>
+
+## Key Principles Summary
+
+<CardGroup cols={2}>
+  <Card title="Task-Driven Selection" icon="bullseye">
+    Choose models based on what the task actually requires, not theoretical capabilities or general reputation.
+  </Card>
+
+{" "}
+<Card title="Capability Matching" icon="puzzle-piece">
+  Align model strengths with agent roles and responsibilities for optimal
+  performance.
+</Card>
+
+{" "}
+<Card title="Strategic Consistency" icon="link">
+  Maintain coherent model selection strategy across related components and
+  workflows.
+</Card>
+
+{" "}
+<Card title="Practical Testing" icon="flask">
+  Validate choices through real-world usage rather than benchmarks alone.
+</Card>
+
+{" "}
+<Card title="Iterative Improvement" icon="arrow-up">
+  Start simple and optimize based on actual performance and needs.
+</Card>
+
+  <Card title="Operational Balance" icon="scale-balanced">
+    Balance performance requirements with cost and complexity constraints.
+  </Card>
+</CardGroup>
+
+<Check>
+  Remember: The best LLM choice is the one that consistently delivers the
+  results you need within your operational constraints. Focus on understanding
+  your requirements first, then select models that best match those needs.
+</Check>
+
+## Current Model Landscape (June 2025)
+
+<Warning>
+  **Snapshot in Time**: The following model rankings represent current
+  leaderboard standings as of June 2025, compiled from [LMSys
+  Arena](https://arena.lmsys.org/), [Artificial
+  Analysis](https://artificialanalysis.ai/), and other leading benchmarks. LLM
+  performance, availability, and pricing change rapidly. Always conduct your own
+  evaluations with your specific use cases and data.
+</Warning>
+
+### Leading Models by Category
+
+The tables below show a representative sample of current top-performing models across different categories, with guidance on their suitability for CrewAI agents:
+
+<Note>
+  These tables/metrics showcase selected leading models in each category and are
+  not exhaustive. Many excellent models exist beyond those listed here. The goal
+  is to illustrate the types of capabilities to look for rather than provide a
+  complete catalog.
+</Note>
+
+<Tabs>
+  <Tab title="Reasoning & Planning">
+    **Best for Manager LLMs and Complex Analysis**
+
+    | Model | Intelligence Score | Cost ($/M tokens) | Speed | Best Use in CrewAI |
+    |:------|:------------------|:------------------|:------|:------------------|
+    | **o3** | 70 | $17.50 | Fast | Manager LLM for complex multi-agent coordination |
+    | **Gemini 2.5 Pro** | 69 | $3.44 | Fast | Strategic planning agents, research coordination |
+    | **DeepSeek R1** | 68 | $0.96 | Moderate | Cost-effective reasoning for budget-conscious crews |
+    | **Claude 4 Sonnet** | 53 | $6.00 | Fast | Analysis agents requiring nuanced understanding |
+    | **Qwen3 235B (Reasoning)** | 62 | $2.63 | Moderate | Open-source alternative for reasoning tasks |
+
+    These models excel at multi-step reasoning and are ideal for agents that need to develop strategies, coordinate other agents, or analyze complex information.
+
+  </Tab>
+
+  <Tab title="Coding & Technical">
+    **Best for Development and Tool-Heavy Workflows**
+
+    | Model | Coding Performance | Tool Use Score | Cost ($/M tokens) | Best Use in CrewAI |
+    |:------|:------------------|:---------------|:------------------|:------------------|
+    | **Claude 4 Sonnet** | Excellent | 72.7% | $6.00 | Primary coding agent, technical documentation |
+    | **Claude 4 Opus** | Excellent | 72.5% | $30.00 | Complex software architecture, code review |
+    | **DeepSeek V3** | Very Good | High | $0.48 | Cost-effective coding for routine development |
+    | **Qwen2.5 Coder 32B** | Very Good | Medium | $0.15 | Budget-friendly coding agent |
+    | **Llama 3.1 405B** | Good | 81.1% | $3.50 | Function calling LLM for tool-heavy workflows |
+
+    These models are optimized for code generation, debugging, and technical problem-solving, making them ideal for development-focused crews.
+
+  </Tab>
+
+  <Tab title="Speed & Efficiency">
+    **Best for High-Throughput and Real-Time Applications**
+
+    | Model | Speed (tokens/s) | Latency (TTFT) | Cost ($/M tokens) | Best Use in CrewAI |
+    |:------|:-----------------|:---------------|:------------------|:------------------|
+    | **Llama 4 Scout** | 2,600 | 0.33s | $0.27 | High-volume processing agents |
+    | **Gemini 2.5 Flash** | 376 | 0.30s | $0.26 | Real-time response agents |
+    | **DeepSeek R1 Distill** | 383 | Variable | $0.04 | Cost-optimized high-speed processing |
+    | **Llama 3.3 70B** | 2,500 | 0.52s | $0.60 | Balanced speed and capability |
+    | **Nova Micro** | High | 0.30s | $0.04 | Simple, fast task execution |
+
+    These models prioritize speed and efficiency, perfect for agents handling routine operations or requiring quick responses. **Pro tip**: Pairing these models with fast inference providers like Groq can achieve even better performance, especially for open-source models like Llama.
+
+  </Tab>
+
+  <Tab title="Balanced Performance">
+    **Best All-Around Models for General Crews**
+
+    | Model | Overall Score | Versatility | Cost ($/M tokens) | Best Use in CrewAI |
+    |:------|:--------------|:------------|:------------------|:------------------|
+    | **GPT-4.1** | 53 | Excellent | $3.50 | General-purpose crew LLM |
+    | **Claude 3.7 Sonnet** | 48 | Very Good | $6.00 | Balanced reasoning and creativity |
+    | **Gemini 2.0 Flash** | 48 | Good | $0.17 | Cost-effective general use |
+    | **Llama 4 Maverick** | 51 | Good | $0.37 | Open-source general purpose |
+    | **Qwen3 32B** | 44 | Good | $1.23 | Budget-friendly versatility |
+
+    These models offer good performance across multiple dimensions, suitable for crews with diverse task requirements.
+
+  </Tab>
+</Tabs>
+
+### Selection Framework for Current Models
+
+<AccordionGroup>
+  <Accordion title="High-Performance Crews" icon="rocket">
+    **When performance is the priority**: Use top-tier models like **o3**, **Gemini 2.5 Pro**, or **Claude 4 Sonnet** for manager LLMs and critical agents. These models excel at complex reasoning and coordination but come with higher costs.
+
+    **Strategy**: Implement a multi-model approach where premium models handle strategic thinking while efficient models handle routine operations.
+
+  </Accordion>
+
+  <Accordion title="Cost-Conscious Crews" icon="dollar-sign">
+    **When budget is a primary constraint**: Focus on models like **DeepSeek R1**, **Llama 4 Scout**, or **Gemini 2.0 Flash**. These provide strong performance at significantly lower costs.
+
+    **Strategy**: Use cost-effective models for most agents, reserving premium models only for the most critical decision-making roles.
+
+  </Accordion>
+
+  <Accordion title="Specialized Workflows" icon="screwdriver-wrench">
+    **For specific domain expertise**: Choose models optimized for your primary use case. **Claude 4** series for coding, **Gemini 2.5 Pro** for research, **Llama 405B** for function calling.
+
+    **Strategy**: Select models based on your crew's primary function, ensuring the core capability aligns with model strengths.
+
+  </Accordion>
+
+  <Accordion title="Enterprise & Privacy" icon="shield">
+    **For data-sensitive operations**: Consider open-source models like **Llama 4** series, **DeepSeek V3**, or **Qwen3** that can be deployed locally while maintaining competitive performance.
+
+    **Strategy**: Deploy open-source models on private infrastructure, accepting potential performance trade-offs for data control.
+
+  </Accordion>
+  </AccordionGroup>
+
+### Key Considerations for Model Selection
+
+- **Performance Trends**: The current landscape shows strong competition between reasoning-focused models (o3, Gemini 2.5 Pro) and balanced models (Claude 4, GPT-4.1). Specialized models like DeepSeek R1 offer excellent cost-performance ratios.
+
+- **Speed vs. Intelligence Trade-offs**: Models like Llama 4 Scout prioritize speed (2,600 tokens/s) while maintaining reasonable intelligence, whereas models like o3 maximize reasoning capability at the cost of speed and price.
+
+- **Open Source Viability**: The gap between open-source and proprietary models continues to narrow, with models like Llama 4 Maverick and DeepSeek V3 offering competitive performance at attractive price points. Fast inference providers particularly shine with open-source models, often delivering better speed-to-cost ratios than proprietary alternatives.
+
+<Info>
+  **Testing is Essential**: Leaderboard rankings provide general guidance, but
+  your specific use case, prompting style, and evaluation criteria may produce
+  different results. Always test candidate models with your actual tasks and
+  data before making final decisions.
+</Info>
+
+### Practical Implementation Strategy
+
+<Steps>
+  <Step title="Start with Proven Models">
+    Begin with well-established models like **GPT-4.1**, **Claude 3.7 Sonnet**, or **Gemini 2.0 Flash** that offer good performance across multiple dimensions and have extensive real-world validation.
+  </Step>
+
+<Step title="Identify Specialized Needs">
+  Determine if your crew has specific requirements (coding, reasoning, speed)
+  that would benefit from specialized models like **Claude 4 Sonnet** for
+  development or **o3** for complex analysis. For speed-critical applications,
+  consider fast inference providers like **Groq** alongside model selection.
+</Step>
+
+<Step title="Implement Multi-Model Strategy">
+  Use different models for different agents based on their roles.
+  High-capability models for managers and complex tasks, efficient models for
+  routine operations.
+</Step>
+
+  <Step title="Monitor and Optimize">
+    Track performance metrics relevant to your use case and be prepared to adjust model selections as new models are released or pricing changes.
+  </Step>
+</Steps>

docs/edge/ar/learn/multimodal-agents.mdx

@@ -0,0 +1,141 @@
+---
+title: استخدام الوكلاء متعددي الوسائط
+description: تعلم كيفية تفعيل واستخدام القدرات متعددة الوسائط في وكلائك لمعالجة الصور والمحتوى غير النصي ضمن إطار عمل CrewAI.
+icon: video
+mode: "wide"
+---
+
+## استخدام الوكلاء متعددي الوسائط
+
+يدعم CrewAI الوكلاء متعددي الوسائط القادرين على معالجة المحتوى النصي وغير النصي مثل الصور. سيوضح لك هذا الدليل كيفية تفعيل واستخدام القدرات متعددة الوسائط في وكلائك.
+
+### تفعيل القدرات متعددة الوسائط
+
+لإنشاء وكيل متعدد الوسائط، ما عليك سوى تعيين معامل `multimodal` إلى `True` عند تهيئة وكيلك:
+
+```python
+from crewai import Agent
+
+agent = Agent(
+    role="Image Analyst",
+    goal="Analyze and extract insights from images",
+    backstory="An expert in visual content interpretation with years of experience in image analysis",
+    multimodal=True  # This enables multimodal capabilities
+)
+```
+
+عند تعيين `multimodal=True`، يتم إعداد الوكيل تلقائياً بالأدوات اللازمة للتعامل مع المحتوى غير النصي، بما في ذلك `AddImageTool`.
+
+### العمل مع الصور
+
+يأتي الوكيل متعدد الوسائط مُعداً مسبقاً بأداة `AddImageTool`، التي تتيح له معالجة الصور. لا تحتاج إلى إضافة هذه الأداة يدوياً — فهي مضمنة تلقائياً عند تفعيل القدرات متعددة الوسائط.
+
+إليك مثالاً كاملاً يوضح كيفية استخدام وكيل متعدد الوسائط لتحليل صورة:
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create a multimodal agent
+image_analyst = Agent(
+    role="Product Analyst",
+    goal="Analyze product images and provide detailed descriptions",
+    backstory="Expert in visual product analysis with deep knowledge of design and features",
+    multimodal=True
+)
+
+# Create a task for image analysis
+task = Task(
+    description="Analyze the product image at https://example.com/product.jpg and provide a detailed description",
+    expected_output="A detailed description of the product image",
+    agent=image_analyst
+)
+
+# Create and run the crew
+crew = Crew(
+    agents=[image_analyst],
+    tasks=[task]
+)
+
+result = crew.kickoff()
+```
+
+### الاستخدام المتقدم مع السياق
+
+يمكنك تقديم سياق إضافي أو أسئلة محددة حول الصورة عند إنشاء مهام للوكلاء متعددي الوسائط. يمكن أن يتضمن وصف المهمة جوانب محددة تريد أن يركز عليها الوكيل:
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create a multimodal agent for detailed analysis
+expert_analyst = Agent(
+    role="Visual Quality Inspector",
+    goal="Perform detailed quality analysis of product images",
+    backstory="Senior quality control expert with expertise in visual inspection",
+    multimodal=True  # AddImageTool is automatically included
+)
+
+# Create a task with specific analysis requirements
+inspection_task = Task(
+    description="""
+    Analyze the product image at https://example.com/product.jpg with focus on:
+    1. Quality of materials
+    2. Manufacturing defects
+    3. Compliance with standards
+    Provide a detailed report highlighting any issues found.
+    """,
+    expected_output="A detailed report highlighting any issues found",
+    agent=expert_analyst
+)
+
+# Create and run the crew
+crew = Crew(
+    agents=[expert_analyst],
+    tasks=[inspection_task]
+)
+
+result = crew.kickoff()
+```
+
+### تفاصيل الأداة
+
+عند العمل مع الوكلاء متعددي الوسائط، يتم إعداد `AddImageTool` تلقائياً بالمخطط التالي:
+
+```python
+class AddImageToolSchema:
+    image_url: str  # Required: The URL or path of the image to process
+    action: Optional[str] = None  # Optional: Additional context or specific questions about the image
+```
+
+سيتعامل الوكيل متعدد الوسائط تلقائياً مع معالجة الصور من خلال أدواته المدمجة، مما يتيح له:
+- الوصول إلى الصور عبر عناوين URL أو مسارات الملفات المحلية
+- معالجة محتوى الصورة مع سياق اختياري أو أسئلة محددة
+- تقديم تحليلات ورؤى بناءً على المعلومات البصرية ومتطلبات المهمة
+
+### أفضل الممارسات
+
+عند العمل مع الوكلاء متعددي الوسائط، ضع هذه الممارسات في الاعتبار:
+
+1. **الوصول إلى الصور**
+   - تأكد من أن صورك قابلة للوصول عبر عناوين URL التي يمكن للوكيل الوصول إليها
+   - للصور المحلية، فكر في استضافتها مؤقتاً أو استخدام مسارات ملفات مطلقة
+   - تحقق من أن عناوين URL للصور صالحة وقابلة للوصول قبل تشغيل المهام
+
+2. **وصف المهمة**
+   - كن محدداً حول الجوانب التي تريد من الوكيل تحليلها في الصورة
+   - قم بتضمين أسئلة أو متطلبات واضحة في وصف المهمة
+   - فكر في استخدام معامل `action` الاختياري للتحليل المركز
+
+3. **إدارة الموارد**
+   - قد تتطلب معالجة الصور موارد حسابية أكثر من المهام النصية فقط
+   - قد تتطلب بعض نماذج اللغة ترميز base64 لبيانات الصورة
+   - فكر في المعالجة الدفعية لصور متعددة لتحسين الأداء
+
+4. **إعداد البيئة**
+   - تحقق من أن بيئتك تحتوي على الاعتماديات اللازمة لمعالجة الصور
+   - تأكد من أن نموذج اللغة الخاص بك يدعم القدرات متعددة الوسائط
+   - اختبر بصور صغيرة أولاً للتحقق من إعدادك
+
+5. **معالجة الأخطاء**
+   - نفّذ معالجة أخطاء مناسبة لحالات فشل تحميل الصور
+   - ضع استراتيجيات احتياطية لحالات فشل معالجة الصور
+   - راقب وسجل عمليات معالجة الصور لأغراض التصحيح

docs/edge/ar/learn/overview.mdx

@@ -0,0 +1,159 @@
+---
+title: "نظرة عامة"
+description: "تعلم كيفية بناء وتخصيص وتحسين تطبيقات CrewAI الخاصة بك مع أدلة وبرامج تعليمية شاملة"
+icon: "face-smile"
+mode: "wide"
+---
+
+## تعلم CrewAI
+
+يوفر هذا القسم أدلة وبرامج تعليمية شاملة لمساعدتك في إتقان CrewAI، من المفاهيم الأساسية إلى التقنيات المتقدمة. سواء كنت قد بدأت للتو أو تبحث عن تحسين تطبيقاتك الحالية، ستوجهك هذه الموارد عبر كل جانب من جوانب بناء سير عمل وكلاء الذكاء الاصطناعي القوية.
+
+## أدلة البدء
+
+### المفاهيم الأساسية
+<CardGroup cols={2}>
+  <Card title="العملية التسلسلية" icon="list-ol" href="/ar/learn/sequential-process">
+    تعلم كيفية تنفيذ المهام بترتيب تسلسلي لسير عمل منظم.
+  </Card>
+
+  <Card title="العملية الهرمية" icon="sitemap" href="/ar/learn/hierarchical-process">
+    تنفيذ تنفيذ المهام الهرمي مع وكلاء مديرين يشرفون على سير العمل.
+  </Card>
+
+  <Card title="المهام الشرطية" icon="code-branch" href="/ar/learn/conditional-tasks">
+    إنشاء سير عمل ديناميكي مع تنفيذ مهام شرطي بناءً على النتائج.
+  </Card>
+
+  <Card title="التشغيل غير المتزامن" icon="bolt" href="/ar/learn/kickoff-async">
+    تنفيذ الأطقم بشكل غير متزامن لأداء وتزامن محسّن.
+  </Card>
+</CardGroup>
+
+### تطوير الوكلاء
+<CardGroup cols={2}>
+  <Card title="تخصيص الوكلاء" icon="user-gear" href="/ar/learn/customizing-agents">
+    تعلم كيفية تخصيص سلوك الوكلاء وأدوارهم وقدراتهم.
+  </Card>
+
+  <Card title="وكلاء البرمجة" icon="code" href="/ar/learn/coding-agents">
+    بناء وكلاء يمكنهم كتابة وتنفيذ وتصحيح الكود تلقائياً.
+  </Card>
+
+  <Card title="الوكلاء متعددو الوسائط" icon="images" href="/ar/learn/multimodal-agents">
+    إنشاء وكلاء يمكنهم معالجة النصوص والصور وأنواع الوسائط الأخرى.
+  </Card>
+
+  <Card title="وكيل المدير المخصص" icon="user-tie" href="/ar/learn/custom-manager-agent">
+    تنفيذ وكلاء مديرين مخصصين لسير العمل الهرمي المعقد.
+  </Card>
+</CardGroup>
+
+## الميزات المتقدمة
+
+### التحكم في سير العمل
+<CardGroup cols={2}>
+  <Card title="الإنسان في الحلقة" icon="user-check" href="/ar/learn/human-in-the-loop">
+    دمج الإشراف البشري والتدخل في سير عمل الوكلاء.
+  </Card>
+
+  <Card title="الإدخال البشري أثناء التنفيذ" icon="hand-paper" href="/ar/learn/human-input-on-execution">
+    السماح بالإدخال البشري أثناء تنفيذ المهام لاتخاذ قرارات ديناميكية.
+  </Card>
+
+  <Card title="إعادة تشغيل المهام" icon="rotate-left" href="/ar/learn/replay-tasks-from-latest-crew-kickoff">
+    إعادة تشغيل واستئناف المهام من عمليات تنفيذ الطاقم السابقة.
+  </Card>
+
+  <Card title="التشغيل لكل عنصر" icon="repeat" href="/ar/learn/kickoff-for-each">
+    تنفيذ الأطقم عدة مرات بمدخلات مختلفة بكفاءة.
+  </Card>
+</CardGroup>
+
+### التخصيص والتكامل
+<CardGroup cols={2}>
+  <Card title="LLM مخصص" icon="brain" href="/ar/learn/custom-llm">
+    دمج نماذج لغة ومزودين مخصصين مع CrewAI.
+  </Card>
+
+  <Card title="اتصالات LLM" icon="link" href="/ar/learn/llm-connections">
+    إعداد وإدارة الاتصالات بمزودي LLM المختلفين.
+  </Card>
+
+  <Card title="إنشاء أدوات مخصصة" icon="wrench" href="/ar/learn/create-custom-tools">
+    بناء أدوات مخصصة لتوسيع قدرات الوكلاء.
+  </Card>
+
+  <Card title="استخدام التعليقات التوضيحية" icon="at" href="/ar/learn/using-annotations">
+    استخدام تعليقات Python التوضيحية لكود أنظف وأسهل في الصيانة.
+  </Card>
+</CardGroup>
+
+## التطبيقات المتخصصة
+
+### المحتوى والوسائط
+<CardGroup cols={2}>
+  <Card title="توليد صور DALL-E" icon="image" href="/ar/learn/dalle-image-generation">
+    توليد الصور باستخدام تكامل DALL-E مع وكلائك.
+  </Card>
+
+  <Card title="أحضر وكيلك الخاص" icon="user-plus" href="/ar/learn/bring-your-own-agent">
+    دمج الوكلاء والنماذج الموجودة في سير عمل CrewAI.
+  </Card>
+</CardGroup>
+
+### إدارة الأدوات
+<CardGroup cols={2}>
+  <Card title="فرض مخرجات الأداة كنتيجة" icon="hammer" href="/ar/learn/force-tool-output-as-result">
+    إعداد الأدوات لإرجاع مخرجاتها مباشرة كنتائج للمهام.
+  </Card>
+</CardGroup>
+
+## توصيات مسار التعلم
+
+### للمبتدئين
+1. ابدأ بـ **العملية التسلسلية** لفهم تنفيذ سير العمل الأساسي
+2. تعلم **تخصيص الوكلاء** لإنشاء إعدادات وكلاء فعالة
+3. استكشف **إنشاء أدوات مخصصة** لتوسيع الوظائف
+4. جرب **الإنسان في الحلقة** لسير العمل التفاعلي
+
+### للمستخدمين المتوسطين
+1. أتقن **العملية الهرمية** لأنظمة الوكلاء المتعددة المعقدة
+2. نفّذ **المهام الشرطية** لسير العمل الديناميكي
+3. استخدم **التشغيل غير المتزامن** لتحسين الأداء
+4. ادمج **LLM مخصص** للنماذج المتخصصة
+
+### للمستخدمين المتقدمين
+1. ابنِ **وكلاء متعددي الوسائط** لمعالجة الوسائط المعقدة
+2. أنشئ **وكلاء مديرين مخصصين** للتنسيق المتطور
+3. نفّذ **أحضر وكيلك الخاص** للأنظمة الهجينة
+4. استخدم **إعادة تشغيل المهام** لاسترداد الأخطاء بشكل متين
+
+## أفضل الممارسات
+
+### التطوير
+- **ابدأ بالبساطة**: ابدأ بسير العمل التسلسلي الأساسي قبل إضافة التعقيد
+- **اختبر تدريجياً**: اختبر كل مكون قبل دمجه في أنظمة أكبر
+- **استخدم التعليقات التوضيحية**: استفد من تعليقات Python التوضيحية لكود أنظف وأسهل في الصيانة
+- **أدوات مخصصة**: ابنِ أدوات قابلة لإعادة الاستخدام يمكن مشاركتها عبر وكلاء مختلفين
+
+### الإنتاج
+- **معالجة الأخطاء**: نفّذ معالجة أخطاء وآليات استرداد قوية
+- **الأداء**: استخدم التنفيذ غير المتزامن وحسّن استدعاءات LLM لأداء أفضل
+- **المراقبة**: ادمج أدوات المراقبة لتتبع أداء الوكلاء
+- **الإشراف البشري**: ضمّن نقاط تفتيش بشرية للقرارات الحرجة
+
+### التحسين
+- **إدارة الموارد**: راقب وحسّن استخدام الرموز وتكاليف API
+- **تصميم سير العمل**: صمم سير عمل يقلل من استدعاءات LLM غير الضرورية
+- **كفاءة الأدوات**: أنشئ أدوات فعالة توفر أقصى قيمة بأقل حمل
+- **التحسين التكراري**: استخدم التغذية الراجعة والمقاييس لتحسين أداء الوكلاء باستمرار
+
+## الحصول على المساعدة
+
+- **التوثيق**: يتضمن كل دليل أمثلة وشروحات مفصلة
+- **المجتمع**: انضم إلى [منتدى CrewAI](https://community.crewai.com) للمناقشات والدعم
+- **الأمثلة**: تحقق من قسم الأمثلة للتطبيقات العاملة الكاملة
+- **الدعم**: تواصل مع [support@crewai.com](mailto:support@crewai.com) للمساعدة التقنية
+
+ابدأ بالأدلة التي تتوافق مع احتياجاتك الحالية واستكشف تدريجياً المواضيع الأكثر تقدماً مع إتقانك للأساسيات.

docs/edge/ar/learn/replay-tasks-from-latest-crew-kickoff.mdx

@@ -0,0 +1,79 @@
+---
+title: إعادة تشغيل المهام من آخر تنفيذ للطاقم
+description: إعادة تشغيل المهام من آخر crew.kickoff(...)
+icon: arrow-right
+mode: "wide"
+---
+
+## مقدمة
+
+يوفر CrewAI القدرة على إعادة التشغيل من مهمة محددة من آخر تشغيل للطاقم. هذه الميزة مفيدة بشكل خاص عندما تكون قد أنهيت تشغيلاً وقد ترغب في إعادة محاولة مهام معينة أو لا تحتاج إلى إعادة جلب البيانات ووكلاؤك لديهم بالفعل السياق المحفوظ من تنفيذ التشغيل، لذا تحتاج فقط إلى إعادة تشغيل المهام التي تريدها.
+
+<Note>
+    يجب عليك تشغيل `crew.kickoff()` قبل أن تتمكن من إعادة تشغيل مهمة.
+    حالياً، يُدعم فقط آخر تشغيل، لذا إذا استخدمت `kickoff_for_each`، فسيسمح لك فقط بإعادة التشغيل من أحدث تشغيل للطاقم.
+</Note>
+
+إليك مثالاً على كيفية إعادة التشغيل من مهمة:
+
+### إعادة التشغيل من مهمة محددة باستخدام CLI
+
+لاستخدام ميزة إعادة التشغيل، اتبع هذه الخطوات:
+
+<Steps>
+   <Step title="افتح الطرفية أو موجه الأوامر."></Step>
+   <Step title="انتقل إلى المجلد الذي يقع فيه مشروع CrewAI الخاص بك."></Step>
+   <Step title="شغّل الأوامر التالية:">
+      لعرض معرفات المهام من آخر تشغيل، استخدم:
+
+      ```shell
+      crewai log-tasks-outputs
+      ```
+
+      بمجرد حصولك على `task_id` لإعادة التشغيل، استخدم:
+
+      ```shell
+      crewai replay -t <task_id>
+      ```
+   </Step>
+</Steps>
+
+<Note>
+    تأكد من أن `crewai` مثبت ومُعد بشكل صحيح في بيئة التطوير الخاصة بك.
+</Note>
+
+### إعادة التشغيل من مهمة برمجياً
+
+لإعادة التشغيل من مهمة برمجياً، استخدم الخطوات التالية:
+
+<Steps>
+   <Step title="حدد معرف المهمة ومعاملات الإدخال لعملية إعادة التشغيل.">
+      حدد `task_id` ومعاملات الإدخال لعملية إعادة التشغيل.
+   </Step>
+   <Step title="نفّذ أمر إعادة التشغيل ضمن كتلة try-except للتعامل مع الأخطاء المحتملة.">
+      نفّذ أمر إعادة التشغيل ضمن كتلة try-except للتعامل مع الأخطاء المحتملة.
+      <CodeGroup>
+          ```python Code
+            def replay():
+            """
+            Replay the crew execution from a specific task.
+            """
+            task_id = '<task_id>'
+            inputs = {"topic": "CrewAI Training"}  # This is optional; you can pass in the inputs you want to replay; otherwise, it uses the previous kickoff's inputs.
+            try:
+                YourCrewName_Crew().crew().replay(task_id=task_id, inputs=inputs)
+
+            except subprocess.CalledProcessError as e:
+                raise Exception(f"An error occurred while replaying the crew: {e}")
+
+            except Exception as e:
+                raise Exception(f"An unexpected error occurred: {e}")
+            ```
+      </CodeGroup>
+   </Step>
+</Steps>
+
+## الخاتمة
+
+مع التحسينات المذكورة أعلاه والوظائف المفصلة، أصبحت إعادة تشغيل مهام محددة في CrewAI أكثر كفاءة ومتانة.
+تأكد من اتباع الأوامر والخطوات بدقة لتحقيق أقصى استفادة من هذه الميزات.

docs/edge/ar/learn/sequential-process.mdx

@@ -0,0 +1,128 @@
+---
+title: العمليات التسلسلية
+description: دليل شامل لاستخدام العمليات التسلسلية لتنفيذ المهام في مشاريع CrewAI.
+icon: forward
+mode: "wide"
+---
+
+## مقدمة
+
+يقدم CrewAI إطار عمل مرن لتنفيذ المهام بطريقة منظمة، يدعم كلاً من العمليات التسلسلية والهرمية.
+يوضح هذا الدليل كيفية تنفيذ هذه العمليات بفعالية لضمان تنفيذ المهام بكفاءة وإكمال المشروع.
+
+## نظرة عامة على العملية التسلسلية
+
+تضمن العملية التسلسلية تنفيذ المهام واحدة تلو الأخرى، باتباع تقدم خطي.
+هذا النهج مثالي للمشاريع التي تتطلب إكمال المهام بترتيب محدد.
+
+### الميزات الرئيسية
+
+- **تدفق مهام خطي**: يضمن تقدماً منظماً من خلال التعامل مع المهام بتسلسل محدد مسبقاً.
+- **البساطة**: الأنسب للمشاريع ذات المهام الواضحة خطوة بخطوة.
+- **سهولة المراقبة**: يسهل التتبع السهل لإكمال المهام وتقدم المشروع.
+
+## تنفيذ العملية التسلسلية
+
+لاستخدام العملية التسلسلية، قم بتجميع طاقمك وتعريف المهام بالترتيب الذي تحتاج إلى تنفيذها به.
+
+```python Code
+from crewai import Crew, Process, Agent, Task, TaskOutput, CrewOutput
+
+# Define your agents
+researcher = Agent(
+  role='Researcher',
+  goal='Conduct foundational research',
+  backstory='An experienced researcher with a passion for uncovering insights'
+)
+analyst = Agent(
+  role='Data Analyst',
+  goal='Analyze research findings',
+  backstory='A meticulous analyst with a knack for uncovering patterns'
+)
+writer = Agent(
+  role='Writer',
+  goal='Draft the final report',
+  backstory='A skilled writer with a talent for crafting compelling narratives'
+)
+
+# Define your tasks
+research_task = Task(
+  description='Gather relevant data...',
+  agent=researcher,
+  expected_output='Raw Data'
+)
+analysis_task = Task(
+  description='Analyze the data...',
+  agent=analyst,
+  expected_output='Data Insights'
+)
+writing_task = Task(
+  description='Compose the report...',
+  agent=writer,
+  expected_output='Final Report'
+)
+
+# Form the crew with a sequential process
+report_crew = Crew(
+  agents=[researcher, analyst, writer],
+  tasks=[research_task, analysis_task, writing_task],
+  process=Process.sequential
+)
+
+# Execute the crew
+result = report_crew.kickoff()
+
+# Accessing the type-safe output
+task_output: TaskOutput = result.tasks[0].output
+crew_output: CrewOutput = result.output
+```
+
+### ملاحظة:
+
+يجب أن يكون لكل مهمة في عملية تسلسلية وكيل مُعيّن. تأكد من أن كل `Task` تتضمن معامل `agent`.
+
+### سير العمل أثناء التنفيذ
+
+1. **المهمة الأولى**: في العملية التسلسلية، يكمل الوكيل الأول مهمته ويشير إلى الإكمال.
+2. **المهام اللاحقة**: يلتقط الوكلاء مهامهم بناءً على نوع العملية، مع نتائج المهام السابقة أو التوجيهات التي تقود تنفيذهم.
+3. **الإكمال**: تنتهي العملية بمجرد تنفيذ المهمة النهائية، مما يؤدي إلى إكمال المشروع.
+
+## الميزات المتقدمة
+
+### تفويض المهام
+
+في العمليات التسلسلية، إذا كان الوكيل لديه `allow_delegation` مُعيّن إلى `True`، يمكنه تفويض المهام إلى وكلاء آخرين في الطاقم.
+يتم إعداد هذه الميزة تلقائياً عندما يكون هناك عدة وكلاء في الطاقم.
+
+### التنفيذ غير المتزامن
+
+يمكن تنفيذ المهام بشكل غير متزامن، مما يسمح بالمعالجة المتوازية عند الاقتضاء.
+لإنشاء مهمة غير متزامنة، عيّن `async_execution=True` عند تعريف المهمة.
+
+### الذاكرة والتخزين المؤقت
+
+يدعم CrewAI كلاً من ميزتي الذاكرة والتخزين المؤقت:
+
+- **الذاكرة**: فعّلها بتعيين `memory=True` عند إنشاء الطاقم. يتيح هذا للوكلاء الاحتفاظ بالمعلومات عبر المهام.
+- **التخزين المؤقت**: افتراضياً، التخزين المؤقت مفعّل. عيّن `cache=False` لتعطيله.
+
+### دوال الاستدعاء الراجع
+
+يمكنك تعيين دوال استدعاء راجع على مستوى المهمة والخطوة:
+
+- `task_callback`: يُنفذ بعد إكمال كل مهمة.
+- `step_callback`: يُنفذ بعد كل خطوة في تنفيذ الوكيل.
+
+### مقاييس الاستخدام
+
+يتتبع CrewAI استخدام الرموز عبر جميع المهام والوكلاء. يمكنك الوصول إلى هذه المقاييس بعد التنفيذ.
+
+## أفضل الممارسات للعمليات التسلسلية
+
+1. **الترتيب مهم**: رتّب المهام بتسلسل منطقي حيث تبني كل مهمة على سابقتها.
+2. **أوصاف مهام واضحة**: قدم أوصافاً مفصلة لكل مهمة لتوجيه الوكلاء بفعالية.
+3. **اختيار الوكيل المناسب**: طابق مهارات وأدوار الوكلاء مع متطلبات كل مهمة.
+4. **استخدم السياق**: استفد من سياق المهام السابقة لإبلاغ المهام اللاحقة.
+
+يضمن هذا التوثيق المحدث أن التفاصيل تعكس بدقة أحدث التغييرات في قاعدة الكود وتصف بوضوح كيفية الاستفادة من الميزات والإعدادات الجديدة.
+تم الحفاظ على بساطة المحتوى ومباشرته لضمان سهولة الفهم.