feat(flow): log each flow method execution at INFO

Flows emit a Rich console message when they start ('Flow started with ID: …') but produce no further log line until the next significant event. When a flow appears to hang, this makes it hard to tell which @start/@listen method is currently running. Add a single INFO log at the entry of _execute_method that surfaces the active method name. This works for both @start methods and listeners since both paths funnel through _execute_method.
chore: tighten typing across plus_api client
2026-10-19 08:25:09 +02:00 · 2026-05-19 14:45:58 -05:00 · 2026-05-20 01:43:48 +08:00 · 2026-05-20 00:24:26 +08:00 · 2026-05-19 23:38:34 +08:00 · 2026-05-19 10:44:53 -04:00
2335 changed files with 478016 additions and 153137 deletions
@@ -0,0 +1,160 @@
+# =============================================================================
+# Test Environment Variables
+# =============================================================================
+# This file contains all environment variables needed to run tests locally
+# in a way that mimics the GitHub Actions CI environment.
+
+# =============================================================================
+
+# -----------------------------------------------------------------------------
+# LLM Provider API Keys
+# -----------------------------------------------------------------------------
+OPENAI_API_KEY=fake-api-key
+ANTHROPIC_API_KEY=fake-anthropic-key
+GEMINI_API_KEY=fake-gemini-key
+AZURE_API_KEY=fake-azure-key
+OPENROUTER_API_KEY=fake-openrouter-key
+
+# -----------------------------------------------------------------------------
+# AWS Credentials
+# -----------------------------------------------------------------------------
+AWS_ACCESS_KEY_ID=fake-aws-access-key
+AWS_SECRET_ACCESS_KEY=fake-aws-secret-key
+AWS_DEFAULT_REGION=us-east-1
+
+# -----------------------------------------------------------------------------
+# Azure OpenAI Configuration
+# -----------------------------------------------------------------------------
+AZURE_ENDPOINT=https://fake-azure-endpoint.openai.azure.com
+AZURE_OPENAI_ENDPOINT=https://fake-azure-endpoint.openai.azure.com
+AZURE_OPENAI_API_KEY=fake-azure-openai-key
+AZURE_API_VERSION=2024-02-15-preview
+OPENAI_API_VERSION=2024-02-15-preview
+
+# -----------------------------------------------------------------------------
+# Google Cloud Configuration
+# -----------------------------------------------------------------------------
+#GOOGLE_CLOUD_PROJECT=fake-gcp-project
+#GOOGLE_CLOUD_LOCATION=us-central1
+
+# -----------------------------------------------------------------------------
+# OpenAI Configuration
+# -----------------------------------------------------------------------------
+OPENAI_BASE_URL=https://api.openai.com/v1
+OPENAI_API_BASE=https://api.openai.com/v1
+
+# -----------------------------------------------------------------------------
+# Search & Scraping Tool API Keys
+# -----------------------------------------------------------------------------
+SERPER_API_KEY=fake-serper-key
+EXA_API_KEY=fake-exa-key
+BRAVE_API_KEY=fake-brave-key
+FIRECRAWL_API_KEY=fake-firecrawl-key
+TAVILY_API_KEY=fake-tavily-key
+SERPAPI_API_KEY=fake-serpapi-key
+SERPLY_API_KEY=fake-serply-key
+LINKUP_API_KEY=fake-linkup-key
+PARALLEL_API_KEY=fake-parallel-key
+
+# -----------------------------------------------------------------------------
+# Exa Configuration
+# -----------------------------------------------------------------------------
+EXA_BASE_URL=https://api.exa.ai
+
+# -----------------------------------------------------------------------------
+# Web Scraping & Automation
+# -----------------------------------------------------------------------------
+BRIGHT_DATA_API_KEY=fake-brightdata-key
+BRIGHT_DATA_ZONE=fake-zone
+BRIGHTDATA_API_URL=https://api.brightdata.com
+BRIGHTDATA_DEFAULT_TIMEOUT=600
+BRIGHTDATA_DEFAULT_POLLING_INTERVAL=1
+
+OXYLABS_USERNAME=fake-oxylabs-user
+OXYLABS_PASSWORD=fake-oxylabs-pass
+
+SCRAPFLY_API_KEY=fake-scrapfly-key
+SCRAPEGRAPH_API_KEY=fake-scrapegraph-key
+
+BROWSERBASE_API_KEY=fake-browserbase-key
+BROWSERBASE_PROJECT_ID=fake-browserbase-project
+
+HYPERBROWSER_API_KEY=fake-hyperbrowser-key
+MULTION_API_KEY=fake-multion-key
+APIFY_API_TOKEN=fake-apify-token
+
+# -----------------------------------------------------------------------------
+# Database & Vector Store Credentials
+# -----------------------------------------------------------------------------
+SINGLESTOREDB_URL=mysql://fake:fake@localhost:3306/fake
+SINGLESTOREDB_HOST=localhost
+SINGLESTOREDB_PORT=3306
+SINGLESTOREDB_USER=fake-user
+SINGLESTOREDB_PASSWORD=fake-password
+SINGLESTOREDB_DATABASE=fake-database
+SINGLESTOREDB_CONNECT_TIMEOUT=30
+
+SNOWFLAKE_USER=fake-snowflake-user
+SNOWFLAKE_PASSWORD=fake-snowflake-password
+SNOWFLAKE_ACCOUNT=fake-snowflake-account
+SNOWFLAKE_WAREHOUSE=fake-snowflake-warehouse
+SNOWFLAKE_DATABASE=fake-snowflake-database
+SNOWFLAKE_SCHEMA=fake-snowflake-schema
+
+WEAVIATE_URL=http://localhost:8080
+WEAVIATE_API_KEY=fake-weaviate-key
+
+EMBEDCHAIN_DB_URI=sqlite:///test.db
+
+# Databricks Credentials
+DATABRICKS_HOST=https://fake-databricks.cloud.databricks.com
+DATABRICKS_TOKEN=fake-databricks-token
+DATABRICKS_CONFIG_PROFILE=fake-profile
+
+# MongoDB Credentials
+MONGODB_URI=mongodb://fake:fake@localhost:27017/fake
+
+# -----------------------------------------------------------------------------
+# CrewAI Platform & Enterprise
+# -----------------------------------------------------------------------------
+# setting CREWAI_PLATFORM_INTEGRATION_TOKEN causes these test to fail:
+#=========================== short test summary info ============================
+#FAILED tests/test_context.py::TestPlatformIntegrationToken::test_platform_context_manager_basic_usage - AssertionError: assert 'fake-platform-token' is None
+# +  where 'fake-platform-token' = get_platform_integration_token()
+#FAILED tests/test_context.py::TestPlatformIntegrationToken::test_context_var_isolation_between_tests - AssertionError: assert 'fake-platform-token' is None
+# +  where 'fake-platform-token' = get_platform_integration_token()
+#FAILED tests/test_context.py::TestPlatformIntegrationToken::test_multiple_sequential_context_managers - AssertionError: assert 'fake-platform-token' is None
+# +  where 'fake-platform-token' = get_platform_integration_token()
+#CREWAI_PLATFORM_INTEGRATION_TOKEN=fake-platform-token
+CREWAI_PERSONAL_ACCESS_TOKEN=fake-personal-token
+CREWAI_PLUS_URL=https://fake.crewai.com
+
+# -----------------------------------------------------------------------------
+# Other Service API Keys
+# -----------------------------------------------------------------------------
+ZAPIER_API_KEY=fake-zapier-key
+PATRONUS_API_KEY=fake-patronus-key
+MINDS_API_KEY=fake-minds-key
+HF_TOKEN=fake-hf-token
+
+# -----------------------------------------------------------------------------
+# Feature Flags/Testing Modes
+# -----------------------------------------------------------------------------
+CREWAI_DISABLE_TELEMETRY=true
+OTEL_SDK_DISABLED=true
+CREWAI_TESTING=true
+CREWAI_TRACING_ENABLED=false
+
+# -----------------------------------------------------------------------------
+# Testing/CI Configuration
+# -----------------------------------------------------------------------------
+# VCR recording mode: "none" (default), "new_episodes", "all", "once"
+PYTEST_VCR_RECORD_MODE=none
+
+# Set to "true" by GitHub when running in GitHub Actions
+# GITHUB_ACTIONS=false
+
+# -----------------------------------------------------------------------------
+# Python Configuration
+# -----------------------------------------------------------------------------
+PYTHONUNBUFFERED=1
@@ -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).
@@ -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
@@ -0,0 +1,16 @@
+# To get started with Dependabot version updates, you'll need to specify which 
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: uv
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    groups:
+      security-updates:
+        applies-to: security-updates
+        patterns:
+          - "*"
@@ -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 this Bugcrowd submission email will not be reviewed and will be dismissed
@@ -28,7 +28,7 @@ jobs:
      - name: Install uv
        uses: astral-sh/setup-uv@v6
        with:
-          version: "0.8.4"
+          version: "0.11.3"
          python-version: ${{ matrix.python-version }}
          enable-cache: false

@@ -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@v4
      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@v4
      with:
        category: "/language:${{matrix.language}}"
@@ -0,0 +1,35 @@
+name: Check Documentation Broken Links
+
+on:
+  pull_request:
+    paths:
+      - "docs/**"
+      - "docs.json"
+  push:
+    branches:
+      - main
+    paths:
+      - "docs/**"
+      - "docs.json"
+  workflow_dispatch:
+
+jobs:
+  check-links:
+    name: Check broken links
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+
+      - name: Install Mintlify CLI
+        run: npm i -g mintlify
+
+      - name: Run broken link checker
+        run: |
+          # Auto-answer the prompt with yes command
+          yes "" | mintlify broken-links || test $? -eq 141
+        working-directory: ./docs
@@ -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: tibdex/github-app-token@v2
+        with:
+          app_id: ${{ secrets.CREWAI_TOOL_SPECS_APP_ID }}
+          private_key: ${{ secrets.CREWAI_TOOL_SPECS_PRIVATE_KEY }}
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.head_ref }}
+          token: ${{ steps.app-token.outputs.token }}
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@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
@@ -6,17 +6,27 @@ 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: dorny/paths-filter@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@v4

      - name: Restore global uv cache
        id: cache-restore
@@ -33,30 +43,18 @@ jobs:
      - name: Install uv
        uses: astral-sh/setup-uv@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'
@@ -67,3 +65,23 @@ jobs:
            ~/.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
@@ -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@v4
+        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@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@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@v4
+        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@v6
+        with:
+          version: "0.11.3"
+          python-version: "3.12"
+          enable-cache: false
+
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        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
@@ -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 }}"
-            }
-
@@ -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@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/**
@@ -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@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
@@ -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,7 +15,18 @@ jobs:
    permissions:
        contents: read
    steps:
+      - 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@v4
+        with:
+          ref: ${{ steps.release.outputs.tag || github.ref }}

      - name: Set up Python
        uses: actions/setup-python@v5
@@ -45,11 +59,13 @@ jobs:
      contents: read
    steps:
      - uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.release_tag || github.ref }}

      - name: Install uv
        uses: astral-sh/setup-uv@v6
        with:
-          version: "0.8.4"
+          version: "0.11.3"
          python-version: "3.12"
          enable-cache: false

@@ -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@v2.1.0
+        with:
+          webhook: ${{ secrets.SLACK_WEBHOOK_URL }}
+          webhook-type: incoming-webhook
+          payload: ${{ steps.slack.outputs.payload }}
@@ -5,21 +5,26 @@ on: [pull_request]
 permissions:
  contents: read

-env:
-  OPENAI_API_KEY: fake-api-key
-  PYTHONUNBUFFERED: 1
-  BRAVE_API_KEY: fake-brave-key
-  SNOWFLAKE_USER: fake-snowflake-user
-  SNOWFLAKE_PASSWORD: fake-snowflake-password
-  SNOWFLAKE_ACCOUNT: fake-snowflake-account
-  SNOWFLAKE_WAREHOUSE: fake-snowflake-warehouse
-  SNOWFLAKE_DATABASE: fake-snowflake-database
-  SNOWFLAKE_SCHEMA: fake-snowflake-schema
-  EMBEDCHAIN_DB_URI: sqlite:///test.db
-
 jobs:
-  tests:
+  changes:
+    name: Detect changes
+    runs-on: ubuntu-latest
+    outputs:
+      code: ${{ steps.filter.outputs.code }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dorny/paths-filter@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:
@@ -48,7 +53,7 @@ jobs:
      - name: Install uv
        uses: astral-sh/setup-uv@v6
        with:
-          version: "0.8.4"
+          version: "0.11.3"
          python-version: ${{ matrix.python-version }}
          enable-cache: false

@@ -84,26 +89,20 @@ jobs:
          # fi

          cd lib/crewai && uv run pytest \
-            --block-network \
-            --timeout=30 \
            -vv \
            --splits 8 \
            --group ${{ matrix.group }} \
            $DURATIONS_ARG \
            --durations=10 \
-            -n auto \
            --maxfail=3

      - name: Run tool tests (group ${{ matrix.group }} of 8)
        run: |
          cd lib/crewai-tools && uv run pytest \
-            --block-network \
-            --timeout=30 \
            -vv \
            --splits 8 \
            --group ${{ matrix.group }} \
            --durations=10 \
-            -n auto \
            --maxfail=3


@@ -116,3 +115,23 @@ jobs:
            ~/.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
@@ -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@v4
+      - uses: dorny/paths-filter@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
@@ -17,8 +34,6 @@ jobs:
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0 # Fetch all history for proper diff

      - name: Restore global uv cache
        id: cache-restore
@@ -35,44 +50,15 @@ jobs:
      - name: Install uv
        uses: astral-sh/setup-uv@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'
@@ -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
@@ -40,7 +40,7 @@ jobs:
      - name: Install uv
        uses: astral-sh/setup-uv@v6
        with:
-          version: "0.8.4"
+          version: "0.11.3"
          python-version: ${{ matrix.python-version }}
          enable-cache: false

@@ -0,0 +1,99 @@
+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@v4
+
+      - name: Restore global uv cache
+        id: cache-restore
+        uses: actions/cache/restore@v4
+        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@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: |
+          uv run pip-audit --desc --aliases --skip-editable --format json --output pip-audit-report.json \
+            --ignore-vuln CVE-2026-3219 \
+            --ignore-vuln GHSA-r374-rxx8-8654
+        # Ignored CVEs:
+        #   CVE-2026-3219      - pip 26.0.1 (GHSA-58qw-9mgm-455v): no fix available, archive handling issue
+        #   GHSA-r374-rxx8-8654 - paramiko 4.0.0 (SHA-1 in rsakey.py): no fix available; transitive via composio-core
+        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@v4
+        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@v4
+        with:
+          path: |
+            ~/.cache/uv
+            ~/.local/share/uv
+            .venv
+          key: uv-main-py3.11-${{ hashFiles('uv.lock') }}
+
@@ -26,3 +26,8 @@ plan.md
 conceptual_plan.md
 build_image
 chromadb-*.lock
+.claude
+.crewai/memory
+blogs/*
+secrets/*
+UNKNOWN.egg-info/
@@ -19,9 +19,23 @@ 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
+        entry: bash -c 'source .venv/bin/activate && uv run pip-audit --skip-editable --ignore-vuln CVE-2026-3219' --
+        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 ]

@@ -0,0 +1 @@
+3.13
@@ -57,7 +57,7 @@
 > It empowers developers with both high-level simplicity and precise low-level control, ideal for creating autonomous AI agents tailored to any scenario.

 - **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 Flows**: The **enterprise and production architecture** for building and deploying multi-agent systems. Enable granular, event-driven control, single LLM calls for precise task orchestration and supports Crews natively

 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.
@@ -83,6 +83,7 @@ intelligent automations.

 ## Table of contents

+- [Build with AI](#build-with-ai)
 - [Why CrewAI?](#why-crewai)
 - [Getting Started](#getting-started)
 - [Key Features](#key-features)
@@ -101,6 +102,32 @@ intelligent automations.
 - [Telemetry](#telemetry)
 - [License](#license)

+## 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?

 <div align="center" style="margin-bottom: 30px;">
@@ -124,7 +151,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 +169,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 +195,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 +214,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 +300,7 @@ reporting_analyst:

 **tasks.yaml**

-```yaml
+````yaml
 # src/my_project/config/tasks.yaml
 research_task:
  description: >
@@ -290,7 +320,7 @@ reporting_task:
    Formatted as markdown without '```'
  agent: reporting_analyst
  output_file: report.md
-```
+````

 **crew.py**

@@ -556,7 +586,7 @@ Please refer to the [Connect CrewAI to LLMs](https://docs.crewai.com/how-to/LLM-

 - **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.

-*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)).*
+_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.
@@ -611,7 +641,7 @@ uv build
 ### Installing Locally

 ```bash
-pip install dist/*.tar.gz
+uv pip install dist/*.tar.gz
 ```

 ## Telemetry
@@ -687,13 +717,13 @@ A: CrewAI is a standalone, lean, and fast Python framework built specifically fo
 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?
@@ -0,0 +1,298 @@
+"""Pytest configuration for crewAI workspace."""
+
+import base64
+from collections.abc import Generator
+import gzip
+import os
+from pathlib import Path
+import tempfile
+from typing import Any
+
+from dotenv import load_dotenv
+import pytest
+from vcr.request import Request  # type: ignore[import-untyped]
+
+
+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)
+
+
+def _patched_make_vcr_request(httpx_request: Any, **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 = httpx_request.read()
+    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")
+def cleanup_event_handlers() -> Generator[None, Any, None]:
+    """Clean up event bus handlers after each test to prevent test pollution."""
+    yield
+
+    try:
+        from crewai.events.event_bus import crewai_event_bus
+
+        with crewai_event_bus._rwlock.w_locked():
+            crewai_event_bus._sync_handlers.clear()
+            crewai_event_bus._async_handlers.clear()
+    except Exception:  # noqa: S110
+        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."""
+    with tempfile.TemporaryDirectory() as temp_dir:
+        storage_dir = Path(temp_dir) / "crewai_test_storage"
+        storage_dir.mkdir(parents=True, exist_ok=True)
+
+        if not storage_dir.exists() or not storage_dir.is_dir():
+            raise RuntimeError(
+                f"Failed to create test storage directory: {storage_dir}"
+            )
+
+        try:
+            test_file = storage_dir / ".permissions_test"
+            test_file.touch()
+            test_file.unlink()
+        except (OSError, IOError) as e:
+            raise RuntimeError(
+                f"Test storage directory {storage_dir} is not writable: {e}"
+            ) from e
+
+        os.environ["CREWAI_STORAGE_DIR"] = str(storage_dir)
+        os.environ["CREWAI_TESTING"] = "true"
+
+        try:
+            yield
+        finally:
+            os.environ.pop("CREWAI_TESTING", "true")
+            os.environ.pop("CREWAI_STORAGE_DIR", None)
+            os.environ.pop("CREWAI_DISABLE_TELEMETRY", "true")
+            os.environ.pop("OTEL_SDK_DISABLED", "true")
+            os.environ.pop("OPENAI_BASE_URL", "https://api.openai.com/v1")
+            os.environ.pop("OPENAI_API_BASE", "https://api.openai.com/v1")
+
+
+HEADERS_TO_FILTER = {
+    "authorization": "AUTHORIZATION-XXX",
+    "content-security-policy": "CSP-FILTERED",
+    "cookie": "COOKIE-XXX",
+    "set-cookie": "SET-COOKIE-XXX",
+    "permissions-policy": "PERMISSIONS-POLICY-XXX",
+    "referrer-policy": "REFERRER-POLICY-XXX",
+    "strict-transport-security": "STS-XXX",
+    "x-content-type-options": "X-CONTENT-TYPE-XXX",
+    "x-frame-options": "X-FRAME-OPTIONS-XXX",
+    "x-permitted-cross-domain-policies": "X-PERMITTED-XXX",
+    "x-request-id": "X-REQUEST-ID-XXX",
+    "x-runtime": "X-RUNTIME-XXX",
+    "x-xss-protection": "X-XSS-PROTECTION-XXX",
+    "x-stainless-arch": "X-STAINLESS-ARCH-XXX",
+    "x-stainless-os": "X-STAINLESS-OS-XXX",
+    "x-stainless-read-timeout": "X-STAINLESS-READ-TIMEOUT-XXX",
+    "cf-ray": "CF-RAY-XXX",
+    "etag": "ETAG-XXX",
+    "Strict-Transport-Security": "STS-XXX",
+    "access-control-expose-headers": "ACCESS-CONTROL-XXX",
+    "openai-organization": "OPENAI-ORG-XXX",
+    "openai-project": "OPENAI-PROJECT-XXX",
+    "x-ratelimit-limit-requests": "X-RATELIMIT-LIMIT-REQUESTS-XXX",
+    "x-ratelimit-limit-tokens": "X-RATELIMIT-LIMIT-TOKENS-XXX",
+    "x-ratelimit-remaining-requests": "X-RATELIMIT-REMAINING-REQUESTS-XXX",
+    "x-ratelimit-remaining-tokens": "X-RATELIMIT-REMAINING-TOKENS-XXX",
+    "x-ratelimit-reset-requests": "X-RATELIMIT-RESET-REQUESTS-XXX",
+    "x-ratelimit-reset-tokens": "X-RATELIMIT-RESET-TOKENS-XXX",
+    "x-goog-api-key": "X-GOOG-API-KEY-XXX",
+    "api-key": "X-API-KEY-XXX",
+    "User-Agent": "X-USER-AGENT-XXX",
+    "apim-request-id:": "X-API-CLIENT-REQUEST-ID-XXX",
+    "azureml-model-session": "AZUREML-MODEL-SESSION-XXX",
+    "x-ms-client-request-id": "X-MS-CLIENT-REQUEST-ID-XXX",
+    "x-ms-region": "X-MS-REGION-XXX",
+    "apim-request-id": "APIM-REQUEST-ID-XXX",
+    "x-api-key": "X-API-KEY-XXX",
+    "anthropic-organization-id": "ANTHROPIC-ORGANIZATION-ID-XXX",
+    "request-id": "REQUEST-ID-XXX",
+    "anthropic-ratelimit-input-tokens-limit": "ANTHROPIC-RATELIMIT-INPUT-TOKENS-LIMIT-XXX",
+    "anthropic-ratelimit-input-tokens-remaining": "ANTHROPIC-RATELIMIT-INPUT-TOKENS-REMAINING-XXX",
+    "anthropic-ratelimit-input-tokens-reset": "ANTHROPIC-RATELIMIT-INPUT-TOKENS-RESET-XXX",
+    "anthropic-ratelimit-output-tokens-limit": "ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-LIMIT-XXX",
+    "anthropic-ratelimit-output-tokens-remaining": "ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-REMAINING-XXX",
+    "anthropic-ratelimit-output-tokens-reset": "ANTHROPIC-RATELIMIT-OUTPUT-TOKENS-RESET-XXX",
+    "anthropic-ratelimit-tokens-limit": "ANTHROPIC-RATELIMIT-TOKENS-LIMIT-XXX",
+    "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",
+    "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",
+}
+
+
+def _filter_request_headers(request: Request) -> Request:  # type: ignore[no-any-unimported]
+    """Filter sensitive headers from request before recording."""
+    for header_name, replacement in HEADERS_TO_FILTER.items():
+        for variant in [header_name, header_name.upper(), header_name.title()]:
+            if variant in request.headers:
+                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)
+
+    return request
+
+
+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
+
+    for encoding_header in ["Content-Encoding", "content-encoding"]:
+        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 headers:
+                headers[variant] = [replacement]
+    return response
+
+
+@pytest.fixture(scope="module")
+def vcr_cassette_dir(request: Any) -> str:
+    """Generate cassette directory path based on test module location.
+
+    Organizes cassettes to mirror test directory structure within each package:
+    lib/crewai/tests/llms/google/test_google.py -> lib/crewai/tests/cassettes/llms/google/
+    lib/crewai-tools/tests/tools/test_search.py -> lib/crewai-tools/tests/cassettes/tools/
+    """
+    test_file = Path(request.fspath)
+
+    for parent in test_file.parents:
+        if (
+            parent.name
+            in ("crewai", "crewai-tools", "crewai-files", "cli", "crewai-core")
+            and parent.parent.name == "lib"
+        ):
+            package_root = parent
+            break
+    else:
+        package_root = test_file.parent
+
+    tests_root = package_root / "tests"
+    test_dir = test_file.parent
+
+    if test_dir != tests_root:
+        relative_path = test_dir.relative_to(tests_root)
+        cassette_dir = tests_root / "cassettes" / relative_path
+    else:
+        cassette_dir = tests_root / "cassettes"
+
+    cassette_dir.mkdir(parents=True, exist_ok=True)
+
+    return str(cassette_dir)
+
+
+@pytest.fixture(scope="module")
+def vcr_config(vcr_cassette_dir: str) -> dict[str, Any]:
+    """Configure VCR with organized cassette storage."""
+    config = {
+        "cassette_library_dir": vcr_cassette_dir,
+        "record_mode": os.getenv("PYTEST_VCR_RECORD_MODE", "once"),
+        "filter_headers": [(k, v) for k, v in HEADERS_TO_FILTER.items()],
+        "before_record_request": _filter_request_headers,
+        "before_record_response": _filter_response_headers,
+        "filter_query_parameters": ["key"],
+        "match_on": ["method", "scheme", "host", "port", "path"],
+    }
+
+    if os.getenv("GITHUB_ACTIONS") == "true":
+        config["record_mode"] = "none"
+
+    return config
@@ -0,0 +1,8 @@
+---
+title: "GET /inputs"
+description: "الحصول على المدخلات المطلوبة لطاقمك"
+openapi: "/enterprise-api.en.yaml GET /inputs"
+mode: "wide"
+---
+
+
@@ -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>
@@ -0,0 +1,8 @@
+---
+title: "POST /kickoff"
+description: "بدء تنفيذ الطاقم"
+openapi: "/enterprise-api.en.yaml POST /kickoff"
+mode: "wide"
+---
+
+
@@ -0,0 +1,6 @@
+---
+title: "POST /resume"
+description: "استئناف تنفيذ الطاقم مع التغذية الراجعة البشرية"
+openapi: "/enterprise-api.en.yaml POST /resume"
+mode: "wide"
+---
@@ -0,0 +1,6 @@
+---
+title: "GET /status/{kickoff_id}"
+description: "الحصول على حالة التنفيذ"
+openapi: "/enterprise-api.en.yaml GET /status/{kickoff_id}"
+mode: "wide"
+---
@@ -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>
@@ -0,0 +1,357 @@
+---
+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: باستخدام **تهيئة YAML (موصى بها)** أو تعريفهم **مباشرة في الكود**.
+
+### تهيئة YAML (موصى بها)
+
+توفر تهيئة YAML طريقة أنظف وأكثر قابلية للصيانة لتعريف الوكلاء. نوصي بشدة باستخدام هذا النهج في مشاريع CrewAI.
+
+بعد إنشاء مشروع CrewAI كما هو موضح في قسم [التثبيت](/ar/installation)، انتقل إلى ملف `src/latest_ai_development/config/agents.yaml` وعدّل القالب ليتوافق مع متطلباتك.
+
+<Note>
+ستُستبدل المتغيرات في ملفات YAML (مثل `{topic}`) بقيم من مدخلاتك عند تشغيل الطاقم:
+```python Code
+crew.kickoff(inputs={'topic': 'AI Agents'})
+```
+</Note>
+
+إليك مثالًا على كيفية تهيئة الوكلاء باستخدام YAML:
+
+```yaml agents.yaml
+# src/latest_ai_development/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/latest_ai_development/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` المختار يدعم الميزات التي تحتاجها
@@ -0,0 +1,229 @@
+---
+title: Checkpointing
+description: حفظ حالة التنفيذ تلقائيا حتى تتمكن الطواقم والتدفقات والوكلاء من الاستئناف بعد الفشل.
+icon: floppy-disk
+mode: "wide"
+---
+
+<Warning>
+الـ Checkpointing في اصدار مبكر. قد تتغير واجهات البرمجة في الاصدارات المستقبلية.
+</Warning>
+
+## نظرة عامة
+
+يقوم الـ Checkpointing بحفظ حالة التنفيذ تلقائيا اثناء التشغيل. اذا فشل طاقم او تدفق او وكيل اثناء التنفيذ، يمكنك الاستعادة من اخر نقطة حفظ والاستئناف دون اعادة تنفيذ العمل المكتمل.
+
+## البداية السريعة
+
+```python
+from crewai import Crew, CheckpointConfig
+
+crew = Crew(
+    agents=[...],
+    tasks=[...],
+    checkpoint=True,  # يستخدم الافتراضيات: ./.checkpoints, عند task_completed
+)
+result = crew.kickoff()
+```
+
+تتم كتابة ملفات نقاط الحفظ في `./.checkpoints/` بعد اكتمال كل مهمة.
+
+## التكوين
+
+استخدم `CheckpointConfig` للتحكم الكامل:
+
+```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,
+    ),
+)
+```
+
+### حقول CheckpointConfig
+
+| الحقل | النوع | الافتراضي | الوصف |
+|:------|:------|:----------|:------|
+| `location` | `str` | `"./.checkpoints"` | مسار ملفات نقاط الحفظ |
+| `on_events` | `list[str]` | `["task_completed"]` | انواع الاحداث التي تطلق نقطة حفظ |
+| `provider` | `BaseProvider` | `JsonProvider()` | واجهة التخزين |
+| `max_checkpoints` | `int \| None` | `None` | الحد الاقصى للملفات؛ يتم حذف الاقدم اولا |
+
+### الوراثة والانسحاب
+
+يقبل حقل `checkpoint` في Crew و Flow و Agent قيم `CheckpointConfig` او `True` او `False` او `None`:
+
+| القيمة | السلوك |
+|:-------|:-------|
+| `None` (افتراضي) | يرث من الاصل. الوكيل يرث اعدادات الطاقم. |
+| `True` | تفعيل بالاعدادات الافتراضية. |
+| `False` | انسحاب صريح. يوقف الوراثة من الاصل. |
+| `CheckpointConfig(...)` | اعدادات مخصصة. |
+
+```python
+crew = Crew(
+    agents=[
+        Agent(role="Researcher", ...),                  # يرث checkpoint من الطاقم
+        Agent(role="Writer", ..., checkpoint=False),     # منسحب، بدون نقاط حفظ
+    ],
+    tasks=[...],
+    checkpoint=True,
+)
+```
+
+## الاستئناف من نقطة حفظ
+
+```python
+# استعادة واستئناف
+crew = Crew.from_checkpoint("./my_checkpoints/20260407T120000_abc123.json")
+result = crew.kickoff()  # يستأنف من اخر مهمة مكتملة
+```
+
+يتخطى الطاقم المستعاد المهام المكتملة ويستأنف من اول مهمة غير مكتملة.
+
+## يعمل على Crew و Flow و Agent
+
+### Crew
+
+```python
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[research_task, write_task, review_task],
+    checkpoint=CheckpointConfig(location="./crew_cp"),
+)
+```
+
+المشغل الافتراضي: `task_completed` (نقطة حفظ واحدة لكل مهمة مكتملة).
+
+### 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()
+
+# استئناف
+flow = MyFlow.from_checkpoint("./flow_cp/20260407T120000_abc123.json")
+result = flow.kickoff()
+```
+
+### 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"}])
+```
+
+## مزودات التخزين
+
+يتضمن CrewAI مزودي تخزين لنقاط الحفظ.
+
+### JsonProvider (افتراضي)
+
+يكتب كل نقطة حفظ كملف JSON منفصل.
+
+```python
+from crewai import Crew, CheckpointConfig
+from crewai.state import JsonProvider
+
+crew = Crew(
+    agents=[...],
+    tasks=[...],
+    checkpoint=CheckpointConfig(
+        location="./my_checkpoints",
+        provider=JsonProvider(),
+        max_checkpoints=5,
+    ),
+)
+```
+
+### SqliteProvider
+
+يخزن جميع نقاط الحفظ في ملف قاعدة بيانات SQLite واحد.
+
+```python
+from crewai import Crew, CheckpointConfig
+from crewai.state import SqliteProvider
+
+crew = Crew(
+    agents=[...],
+    tasks=[...],
+    checkpoint=CheckpointConfig(
+        location="./.checkpoints.db",
+        provider=SqliteProvider(),
+    ),
+)
+```
+
+
+## انواع الاحداث
+
+يقبل حقل `on_events` اي مجموعة من سلاسل انواع الاحداث. الخيارات الشائعة:
+
+| حالة الاستخدام | الاحداث |
+|:---------------|:--------|
+| بعد كل مهمة (Crew) | `["task_completed"]` |
+| بعد كل طريقة في التدفق | `["method_execution_finished"]` |
+| بعد تنفيذ الوكيل | `["agent_execution_completed"]`, `["lite_agent_execution_completed"]` |
+| عند اكتمال الطاقم فقط | `["crew_kickoff_completed"]` |
+| بعد كل استدعاء LLM | `["llm_call_completed"]` |
+| على كل شيء | `["*"]` |
+
+<Warning>
+استخدام `["*"]` او احداث عالية التردد مثل `llm_call_completed` سيكتب العديد من ملفات نقاط الحفظ وقد يؤثر على الاداء. استخدم `max_checkpoints` للحد من استخدام المساحة.
+</Warning>
+
+## نقاط الحفظ اليدوية
+
+للتحكم الكامل، سجل معالج الاحداث الخاص بك واستدع `state.checkpoint()` مباشرة:
+
+```python
+from crewai.events.event_bus import crewai_event_bus
+from crewai.events.types.llm_events import LLMCallCompletedEvent
+
+# معالج متزامن
+@crewai_event_bus.on(LLMCallCompletedEvent)
+def on_llm_done(source, event, state):
+    path = state.checkpoint("./my_checkpoints")
+    print(f"تم حفظ نقطة الحفظ: {path}")
+
+# معالج غير متزامن
+@crewai_event_bus.on(LLMCallCompletedEvent)
+async def on_llm_done_async(source, event, state):
+    path = await state.acheckpoint("./my_checkpoints")
+    print(f"تم حفظ نقطة الحفظ: {path}")
+```
+
+وسيط `state` هو `RuntimeState` الذي يتم تمريره تلقائيا بواسطة ناقل الاحداث عندما يقبل المعالج 3 معاملات. يمكنك تسجيل معالجات على اي نوع حدث مدرج في وثائق [Event Listeners](/ar/concepts/event-listener).
+
+الـ Checkpointing يعمل بافضل جهد: اذا فشلت كتابة نقطة حفظ، يتم تسجيل الخطأ ولكن التنفيذ يستمر دون انقطاع.
@@ -0,0 +1,287 @@
+---
+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
+```
+
+### 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.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>
@@ -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` لرؤية التعاون في العمل
+- **حسّن أوصاف المهام**: المهام الواضحة تؤدي إلى تعاون أفضل
+- **وسّع النطاق**: جرّب العمليات الهرمية للمشاريع المعقدة
+
+يحوّل التعاون وكلاء الذكاء الاصطناعي الفرديين إلى فرق قوية يمكنها معالجة التحديات المعقدة ومتعددة الأوجه معًا.
@@ -0,0 +1,204 @@
+---
+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: باستخدام **تهيئة YAML (موصى بها)** أو تعريفها **مباشرة في الكود**.
+
+### تهيئة YAML (موصى بها)
+
+توفر تهيئة YAML طريقة أنظف وأكثر قابلية للصيانة لتعريف الأطقم وتتسق مع كيفية تعريف الوكلاء والمهام في مشاريع CrewAI.
+
+```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>
+```
@@ -0,0 +1,236 @@
+---
+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**: يُرسل عند اكتمال تنفيذ تدفق
+- **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، يمكنك توسيع وظائفه ودمجه بسلاسة مع بنيتك التحتية الحالية.
@@ -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"),
+    }
+)
+```
@@ -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 أثناء الاسترجاع العميق. |
@@ -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>
@@ -0,0 +1,67 @@
+---
+title: العمليات
+description: دليل تفصيلي حول إدارة سير العمل من خلال العمليات في CrewAI، مع تفاصيل التنفيذ المحدّثة.
+icon: bars-staggered
+mode: "wide"
+---
+
+## نظرة عامة
+
+<Tip>
+  تنسّق العمليات تنفيذ المهام بواسطة الوكلاء، على غرار إدارة المشاريع في الفرق البشرية.
+  تضمن هذه العمليات توزيع المهام وتنفيذها بكفاءة، وفقًا لاستراتيجية محددة مسبقًا.
+</Tip>
+
+## تنفيذات العمليات
+
+- **تسلسلي**: ينفذ المهام بالتتابع، مما يضمن إكمال المهام بتقدم منظم.
+- **هرمي**: ينظم المهام في تسلسل إداري هرمي، حيث يتم تفويض المهام وتنفيذها بناءً على سلسلة أوامر منظمة. يجب تحديد نموذج لغة المدير (`manager_llm`) أو وكيل مدير مخصص (`manager_agent`) في الطاقم لتفعيل العملية الهرمية، مما يسهّل إنشاء وإدارة المهام من قبل المدير.
+- **العملية التوافقية (مخطط لها)**: تهدف إلى اتخاذ القرارات بشكل تعاوني بين الوكلاء حول تنفيذ المهام، وتقدم هذه العملية نهجًا ديمقراطيًا لإدارة المهام داخل CrewAI. وهي مخطط لها للتطوير المستقبلي وغير مطبقة حاليًا في قاعدة الكود.
+
+## دور العمليات في العمل الجماعي
+تُمكّن العمليات الوكلاء الأفراد من العمل كوحدة متماسكة، مما يبسّط جهودهم لتحقيق أهداف مشتركة بكفاءة وتناسق.
+
+## تعيين العمليات للطاقم
+لتعيين عملية لطاقم، حدد نوع العملية عند إنشاء الطاقم لتعيين استراتيجية التنفيذ. للعملية الهرمية، تأكد من تحديد `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 ضروري لتمكين العمل الجماعي المنهجي بين الوكلاء.
+تم تحديث هذه الوثائق لتعكس أحدث الميزات والتحسينات والتكامل المخطط للعملية التوافقية، مما يضمن وصول المستخدمين إلى أحدث المعلومات وأكثرها شمولاً.
@@ -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. تتعامل مع البنية التحتية والمصادقة والمراقبة نيابة عنك.
+
+راجع [دليل النشر](/ar/enterprise/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 واستمرارية.**
@@ -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.
+```
+
+تساعد خطة الاستدلال هذه الوكيل على تنظيم نهجه تجاه المهمة، والنظر في التحديات المحتملة، وضمان تقديم المخرجات المتوقعة.
@@ -0,0 +1,306 @@
+---
+title: المهارات
+description: حزم المهارات المبنية على نظام الملفات التي تحقن خبرة المجال والتعليمات في إرشادات الوكلاء.
+icon: bolt
+mode: "wide"
+---
+
+## نظرة عامة
+
+المهارات هي مجلدات مستقلة توفر للوكلاء **تعليمات وإرشادات ومواد مرجعية خاصة بالمجال**. تُعرّف كل مهارة بملف `SKILL.md` يحتوي على بيانات وصفية YAML ومحتوى Markdown.
+
+عند التفعيل، يتم حقن تعليمات المهارة مباشرة في إرشادات مهمة الوكيل — مما يمنح الوكيل خبرة دون الحاجة لأي تغييرات في الكود.
+
+<Note type="info" title="المهارات مقابل الأدوات — التمييز الأساسي">
+**المهارات ليست أدوات.** هذه هي نقطة الارتباك الأكثر شيوعًا.
+
+- **المهارات** تحقن *تعليمات وسياق* في إرشادات الوكيل. تخبر الوكيل *كيف يفكر* في مشكلة ما.
+- **الأدوات** تمنح الوكيل *دوال قابلة للاستدعاء* لاتخاذ إجراءات (البحث، قراءة الملفات، استدعاء APIs).
+
+غالبًا ما تحتاج **كليهما**: مهارات للخبرة، وأدوات للإجراء. يتم تكوينهما بشكل مستقل ويُكمّلان بعضهما.
+</Note>
+
+---
+
+## البداية السريعة
+
+### 1. إنشاء مجلد المهارة
+
+```
+skills/
+└── code-review/
+    ├── SKILL.md          # مطلوب — التعليمات
+    ├── references/       # اختياري — مستندات مرجعية
+    │   └── style-guide.md
+    └── scripts/          # اختياري — سكربتات قابلة للتنفيذ
+```
+
+### 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"],             # يمكنه إرسال رسائل بريد وتحديث التذاكر
+)
+```
+
+---
+
+## المهارات على مستوى الطاقم
+
+يمكن تعيين المهارات على الطاقم لتُطبّق على **جميع الوكلاء**:
+
+```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>
@@ -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**     |                                |                                  |
+
+يوضح المثال أعلاه نتائج الاختبار لتشغيلين للطاقم مع مهمتين، مع الدرجة الإجمالية المتوسطة لكل مهمة والطاقم ككل.
@@ -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، استفد من كل من الأدوات المخصصة والموجودة لتمكين وكلائك وتعزيز نظام الذكاء الاصطناعي البيئي. فكّر في استخدام معالجة الأخطاء وآليات التخزين المؤقت ومرونة معاملات الأدوات لتحسين أداء وقدرات وكلائك.
@@ -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.
+
+من المهم ملاحظة أن عملية التدريب قد تستغرق بعض الوقت، اعتمادًا على تعقيد وكلائك وستتطلب أيضًا ملاحظاتك في كل تكرار.
+
+بمجرد اكتمال التدريب، سيكون وكلاؤك مجهزين بقدرات ومعرفة محسّنة، وجاهزين لمعالجة المهام المعقدة وتقديم رؤى أكثر اتساقًا وقيمة.
+
+تذكر تحديث وإعادة تدريب وكلائك بانتظام لضمان بقائهم على اطلاع بأحدث المعلومات والتطورات في المجال.
@@ -0,0 +1,155 @@
+---
+title: 'مستودعات الوكلاء'
+description: 'تعرّف على كيفية استخدام مستودعات الوكلاء لمشاركة وإعادة استخدام وكلائك عبر الفرق والمشاريع'
+icon: 'people-group'
+mode: "wide"
+---
+
+تتيح مستودعات الوكلاء لمستخدمي المؤسسات تخزين ومشاركة وإعادة استخدام تعريفات الوكلاء عبر الفرق والمشاريع. تُمكّن هذه الميزة المؤسسات من الاحتفاظ بمكتبة مركزية من الوكلاء الموحدين، مما يعزز الاتساق ويقلل من ازدواجية الجهود.
+
+<Frame>
+  ![Agent Repositories](/images/enterprise/agent-repositories.png)
+</Frame>
+
+## فوائد مستودعات الوكلاء
+
+- **التوحيد**: الحفاظ على تعريفات وكلاء متسقة عبر مؤسستك
+- **إعادة الاستخدام**: إنشاء وكيل مرة واحدة واستخدامه في أطقم ومشاريع متعددة
+- **الحوكمة**: تطبيق سياسات على مستوى المؤسسة لتهيئات الوكلاء
+- **التعاون**: تمكين الفرق من المشاركة والبناء على عمل بعضهم البعض
+
+## إنشاء واستخدام مستودعات الوكلاء
+
+1. يجب أن يكون لديك حساب في CrewAI، جرّب [الخطة المجانية](https://app.crewai.com).
+2. أنشئ وكلاء بأدوار وأهداف محددة لسير عملك.
+3. هيّئ الأدوات والقدرات لكل مساعد متخصص.
+4. انشر الوكلاء عبر المشاريع من خلال الواجهة المرئية أو تكامل API.
+
+<Frame>
+  ![Agent Repositories](/images/enterprise/create-agent-repository.png)
+</Frame>
+
+
+### تحميل الوكلاء من المستودعات
+
+يمكنك تحميل الوكلاء من المستودعات في الكود باستخدام معامل `from_repository` للتشغيل محليًا:
+
+```python
+from crewai import Agent
+
+# إنشاء وكيل بتحميله من مستودع
+# يتم تحميل الوكيل بجميع إعداداته المحددة مسبقًا
+researcher = Agent(
+    from_repository="market-research-agent"
+)
+```
+
+### تجاوز إعدادات المستودع
+
+يمكنك تجاوز إعدادات محددة من المستودع بتوفيرها في التهيئة:
+
+```python
+researcher = Agent(
+    from_repository="market-research-agent",
+    goal="Research the latest trends in AI development",  # تجاوز هدف المستودع
+    verbose=True  # إضافة إعداد غير موجود في المستودع
+)
+```
+
+### مثال: إنشاء طاقم مع وكلاء المستودع
+
+```python
+from crewai import Crew, Agent, Task
+
+# تحميل الوكلاء من المستودعات
+researcher = Agent(
+    from_repository="market-research-agent"
+)
+
+writer = Agent(
+    from_repository="content-writer-agent"
+)
+
+# إنشاء المهام
+research_task = Task(
+    description="Research the latest trends in AI",
+    agent=researcher
+)
+
+writing_task = Task(
+    description="Write a comprehensive report based on the research",
+    agent=writer
+)
+
+# إنشاء الطاقم
+crew = Crew(
+    agents=[researcher, writer],
+    tasks=[research_task, writing_task],
+    verbose=True
+)
+
+# تشغيل الطاقم
+result = crew.kickoff()
+```
+
+### مثال: استخدام `kickoff()` مع وكلاء المستودع
+
+يمكنك أيضًا استخدام وكلاء المستودع مباشرة مع طريقة `kickoff()` للتفاعلات الأبسط:
+
+```python
+from crewai import Agent
+from pydantic import BaseModel
+from typing import List
+
+# تعريف تنسيق مخرجات منظم
+class MarketAnalysis(BaseModel):
+    key_trends: List[str]
+    opportunities: List[str]
+    recommendation: str
+
+# تحميل وكيل من المستودع
+analyst = Agent(
+    from_repository="market-analyst-agent",
+    verbose=True
+)
+
+# الحصول على استجابة حرة
+result = analyst.kickoff("Analyze the AI market in 2025")
+print(result.raw)  # الوصول إلى الاستجابة الخام
+
+# الحصول على مخرجات منظمة
+structured_result = analyst.kickoff(
+    "Provide a structured analysis of the AI market in 2025",
+    response_format=MarketAnalysis
+)
+
+# الوصول إلى البيانات المنظمة
+print(f"Key Trends: {structured_result.pydantic.key_trends}")
+print(f"Recommendation: {structured_result.pydantic.recommendation}")
+```
+
+## أفضل الممارسات
+
+1. **اصطلاح التسمية**: استخدم أسماء واضحة ووصفية لوكلاء المستودع
+2. **التوثيق**: أدرج أوصافًا شاملة لكل وكيل
+3. **إدارة الأدوات**: تأكد من توفر الأدوات المشار إليها بواسطة وكلاء المستودع في بيئتك
+4. **التحكم في الوصول**: أدر الصلاحيات لضمان أن أعضاء الفريق المصرّح لهم فقط يمكنهم تعديل وكلاء المستودع
+
+## إدارة المؤسسة
+
+للتبديل بين المؤسسات أو عرض مؤسستك الحالية، استخدم واجهة سطر أوامر CrewAI:
+
+```bash
+# عرض المؤسسة الحالية
+crewai org current
+
+# التبديل إلى مؤسسة مختلفة
+crewai org switch <org_id>
+
+# عرض جميع المؤسسات المتاحة
+crewai org list
+```
+
+<Note>
+عند تحميل الوكلاء من المستودعات، يجب أن تكون مصادقًا ومتحولًا إلى المؤسسة الصحيحة. إذا تلقيت أخطاء، تحقق من حالة المصادقة وإعدادات المؤسسة باستخدام أوامر CLI أعلاه.
+</Note>
@@ -0,0 +1,104 @@
+---
+title: الأتمتة
+description: "إدارة ونشر ومراقبة أطقمك المباشرة (الأتمتة) في مكان واحد."
+icon: "rocket"
+mode: "wide"
+---
+
+## نظرة عامة
+
+الأتمتة هي مركز العمليات المباشرة لأطقمك المنشورة. استخدمها للنشر من GitHub أو ملف ZIP، وإدارة متغيرات البيئة، وإعادة النشر عند الحاجة، ومراقبة حالة كل أتمتة.
+
+<Frame>
+  ![Automations Overview](/images/enterprise/automations-overview.png)
+
+</Frame>
+
+## طرق النشر
+
+### النشر من GitHub
+
+استخدم هذا للمشاريع ذات التحكم في الإصدارات والنشر المستمر.
+
+<Steps>
+  <Step title="ربط GitHub">
+    انقر على <b>Configure GitHub</b> وصرّح بالوصول.
+  </Step>
+  <Step title="اختيار المستودع والفرع">
+    اختر <b>المستودع</b> و<b>الفرع</b> الذي تريد النشر منه.
+  </Step>
+  <Step title="تفعيل النشر التلقائي (اختياري)">
+    فعّل <b>النشر التلقائي للالتزامات الجديدة</b> لإرسال التحديثات مع كل دفع.
+  </Step>
+  <Step title="إضافة متغيرات البيئة">
+    أضف المتغيرات السرية فرديًا أو استخدم <b>العرض الجماعي</b> لمتغيرات متعددة.
+  </Step>
+  <Step title="النشر">
+    انقر على <b>Deploy</b> لإنشاء الأتمتة المباشرة.
+  </Step>
+</Steps>
+
+<Frame>
+  ![GitHub Deployment](/images/enterprise/deploy-from-github.png)
+</Frame>
+
+### النشر من ZIP
+
+انشر بسرعة بدون Git — ارفع حزمة مضغوطة من مشروعك.
+
+<Steps>
+  <Step title="اختيار الملف">
+    اختر أرشيف ZIP من جهازك.
+  </Step>
+  <Step title="إضافة متغيرات البيئة">
+    وفّر أي متغيرات أو مفاتيح مطلوبة.
+  </Step>
+  <Step title="النشر">
+    انقر على <b>Deploy</b> لإنشاء الأتمتة المباشرة.
+  </Step>
+</Steps>
+
+<Frame>
+  ![ZIP Deployment](/images/enterprise/deploy-from-zip.png)
+</Frame>
+
+## لوحة تحكم الأتمتة
+
+يعرض الجدول جميع الأتمتة المباشرة مع التفاصيل الرئيسية:
+
+- **CREW**: اسم الأتمتة
+- **STATUS**: متصل / فشل / قيد التنفيذ
+- **URL**: نقطة نهاية التشغيل/الحالة
+- **TOKEN**: رمز الأتمتة
+- **ACTIONS**: إعادة النشر، الحذف، والمزيد
+
+استخدم عناصر التحكم في أعلى اليمين للتصفية والبحث:
+
+- البحث بالاسم
+- التصفية حسب <b>الحالة</b>
+- التصفية حسب <b>المصدر</b> (GitHub / Studio / ZIP)
+
+بعد النشر، يمكنك عرض تفاصيل الأتمتة واستخدام القائمة المنسدلة **الخيارات** لـ `الدردشة مع هذا الطاقم`، `تصدير مكون React` و`التصدير كـ MCP`.
+
+<Frame>
+  ![Automations Table](/images/enterprise/automations-table.png)
+</Frame>
+
+## أفضل الممارسات
+
+- فضّل نشر GitHub للتحكم في الإصدارات وCI/CD
+- استخدم إعادة النشر للتقدم بعد تحديثات الكود أو التهيئة أو اضبطه على النشر التلقائي مع كل دفع
+
+## ذات صلة
+
+<CardGroup cols={3}>
+  <Card title="نشر طاقم" href="/ar/enterprise/guides/deploy-to-amp" icon="rocket">
+    انشر طاقمًا من GitHub أو ملف ZIP.
+  </Card>
+  <Card title="مشغلات الأتمتة" href="/ar/enterprise/guides/automation-triggers" icon="trigger">
+    شغّل الأتمتة عبر webhooks أو API.
+  </Card>
+  <Card title="أتمتة Webhook" href="/ar/enterprise/guides/webhook-automation" icon="webhook">
+    بث الأحداث والتحديثات في الوقت الفعلي إلى أنظمتك.
+  </Card>
+</CardGroup>
@@ -0,0 +1,88 @@
+---
+title: استوديو الطاقم
+description: "إنشاء أتمتة جديدة بمساعدة الذكاء الاصطناعي ومحرر مرئي واختبار متكامل."
+icon: "pencil"
+mode: "wide"
+---
+
+## نظرة عامة
+
+استوديو الطاقم هو مساحة عمل تفاعلية بمساعدة الذكاء الاصطناعي لإنشاء أتمتة جديدة من الصفر باستخدام اللغة الطبيعية ومحرر سير عمل مرئي.
+
+<Frame>
+  ![Crew Studio Overview](/images/enterprise/crew-studio-overview.png)
+</Frame>
+
+## الإنشاء المبني على الأوامر النصية
+
+- صِف الأتمتة التي تريدها؛ يقوم الذكاء الاصطناعي بإنشاء الوكلاء والمهام والأدوات.
+- استخدم الإدخال الصوتي عبر أيقونة الميكروفون إذا فضّلت ذلك.
+- ابدأ من أوامر مدمجة لحالات الاستخدام الشائعة.
+
+<Frame>
+  ![Prompt Builder](/images/enterprise/crew-studio-prompt.png)
+</Frame>
+
+## المحرر المرئي
+
+يعكس اللوح سير العمل كعُقد وأسهم مع ثلاث لوحات داعمة تتيح لك تهيئة سير العمل بسهولة بدون كتابة كود؛ ما يُعرف بـ "**البرمجة الحدسية لوكلاء الذكاء الاصطناعي**".
+
+يمكنك استخدام وظيفة السحب والإفلات لإضافة الوكلاء والمهام والأدوات إلى اللوح أو استخدام قسم الدردشة لبناء الوكلاء. يتشارك كلا النهجين الحالة ويمكن استخدامهما بالتبادل.
+
+- **أفكار AI (يسار)**: الاستدلال المتدفق أثناء تصميم سير العمل
+- **اللوح (المركز)**: الوكلاء والمهام كعقد متصلة
+- **الموارد (يمين)**: مكونات السحب والإفلات (وكلاء، مهام، أدوات)
+
+<Frame>
+  ![Visual Canvas](/images/enterprise/crew-studio-canvas.png)
+</Frame>
+
+## التنفيذ والتصحيح
+
+انتقل إلى عرض <b>التنفيذ</b> لتشغيل سير العمل ومراقبته:
+
+- الجدول الزمني للأحداث
+- سجلات مفصلة (التفاصيل، الرسائل، البيانات الخام)
+- اختبارات محلية قبل النشر
+
+<Frame>
+  ![Execution View](/images/enterprise/crew-studio-execution.png)
+</Frame>
+
+## النشر والتصدير
+
+- <b>انشر</b> لنشر أتمتة مباشرة
+- <b>حمّل</b> المصدر كملف ZIP للتطوير المحلي أو التخصيص
+
+<Frame>
+  ![Publish & Download](/images/enterprise/crew-studio-publish.png)
+</Frame>
+
+بعد النشر، يمكنك عرض تفاصيل الأتمتة واستخدام القائمة المنسدلة **الخيارات** لـ `الدردشة مع هذا الطاقم`، `تصدير مكون React` و`التصدير كـ MCP`.
+
+<Frame>
+  ![Published Automation](/images/enterprise/crew-studio-published.png)
+</Frame>
+
+## أفضل الممارسات
+
+- كرر بسرعة في الاستوديو؛ انشر فقط عندما يكون مستقرًا
+- اقصر الأدوات على الحد الأدنى من الصلاحيات المطلوبة
+- استخدم التتبعات للتحقق من السلوك والأداء
+
+## ذات صلة
+
+<CardGroup cols={4}>
+  <Card title="تفعيل استوديو الطاقم" href="/ar/enterprise/guides/enable-crew-studio" icon="palette">
+    تفعيل استوديو الطاقم.
+  </Card>
+  <Card title="بناء طاقم" href="/ar/enterprise/guides/build-crew" icon="paintbrush">
+    بناء طاقم.
+  </Card>
+  <Card title="نشر طاقم" href="/ar/enterprise/guides/deploy-to-amp" icon="rocket">
+    نشر طاقم من GitHub أو ملف ZIP.
+  </Card>
+  <Card title="تصدير مكون React" href="/ar/enterprise/guides/react-component-export" icon="download">
+    تصدير مكون React.
+  </Card>
+</CardGroup>
@@ -0,0 +1,558 @@
+---
+title: "إدارة HITL للتدفقات"
+description: "مراجعة بشرية بمستوى المؤسسات للتدفقات مع إشعارات البريد الإلكتروني أولاً وقواعد التوجيه وإمكانيات الاستجابة التلقائية"
+icon: "users-gear"
+mode: "wide"
+---
+
+<Note>
+تتطلب ميزات إدارة Flow HITL مزيّن `@human_feedback`، المتاح في **CrewAI الإصدار 1.8.0 أو أحدث**. تنطبق هذه الميزات تحديدًا على **التدفقات (Flows)**، وليس الأطقم (Crews).
+</Note>
+
+يوفر CrewAI Enterprise نظامًا شاملًا لإدارة الإنسان في الحلقة (HITL) للتدفقات يحوّل سير عمل الذكاء الاصطناعي إلى عمليات تعاونية بين الإنسان والذكاء الاصطناعي. تستخدم المنصة **بنية البريد الإلكتروني أولاً** التي تمكّن أي شخص لديه عنوان بريد إلكتروني من الرد على طلبات المراجعة — بدون الحاجة لحساب على المنصة.
+
+## نظرة عامة
+
+<CardGroup cols={3}>
+  <Card title="تصميم البريد الإلكتروني أولاً" icon="envelope">
+    يمكن للمستجيبين الرد مباشرة على رسائل الإشعار لتقديم الملاحظات
+  </Card>
+  <Card title="توجيه مرن" icon="route">
+    توجيه الطلبات إلى بريد إلكتروني محدد بناءً على أنماط الطرق أو حالة التدفق
+  </Card>
+  <Card title="استجابة تلقائية" icon="clock">
+    تهيئة استجابات احتياطية تلقائية عندما لا يرد أي شخص في الوقت المحدد
+  </Card>
+</CardGroup>
+
+### الفوائد الرئيسية
+
+- **نموذج ذهني بسيط**: عناوين البريد الإلكتروني عالمية؛ لا حاجة لإدارة مستخدمين أو أدوار المنصة
+- **مستجيبون خارجيون**: يمكن لأي شخص لديه بريد إلكتروني الرد، حتى غير مستخدمي المنصة
+- **تعيين ديناميكي**: سحب بريد المعيّن مباشرة من حالة التدفق (مثل `sales_rep_email`)
+- **تهيئة مخفضة**: إعدادات أقل للتهيئة، وقت أسرع للقيمة
+- **البريد الإلكتروني كقناة رئيسية**: يفضل معظم المستخدمين الرد عبر البريد الإلكتروني بدلاً من تسجيل الدخول إلى لوحة التحكم
+
+## إعداد نقاط المراجعة البشرية في التدفقات
+
+هيّئ نقاط تفتيش المراجعة البشرية داخل تدفقاتك باستخدام مزيّن `@human_feedback`. عندما يصل التنفيذ إلى نقطة مراجعة، يتوقف النظام ويُخطر المعيّن عبر البريد الإلكتروني وينتظر الاستجابة.
+
+```python
+from crewai.flow.flow import Flow, start, listen, or_
+from crewai.flow.human_feedback import human_feedback, HumanFeedbackResult
+
+class ContentApprovalFlow(Flow):
+    @start()
+    def generate_content(self):
+        return "Generated marketing copy for Q1 campaign..."
+
+    @human_feedback(
+        message="Please review this content for brand compliance:",
+        emit=["approved", "rejected", "needs_revision"],
+    )
+    @listen(or_("generate_content", "needs_revision"))
+    def review_content(self):
+        return "Marketing copy for review..."
+
+    @listen("approved")
+    def publish_content(self, result: HumanFeedbackResult):
+        print(f"Publishing approved content. Reviewer notes: {result.feedback}")
+
+    @listen("rejected")
+    def archive_content(self, result: HumanFeedbackResult):
+        print(f"Content rejected. Reason: {result.feedback}")
+```
+
+للحصول على تفاصيل التنفيذ الكاملة، راجع دليل [التغذية الراجعة البشرية في التدفقات](/ar/learn/human-feedback-in-flows).
+
+### معاملات المزيّن
+
+| المعامل | النوع | الوصف |
+|-----------|------|-------------|
+| `message` | `str` | الرسالة المعروضة للمراجع البشري |
+| `emit` | `list[str]` | خيارات الاستجابة الصالحة (تُعرض كأزرار في الواجهة) |
+
+## تهيئة المنصة
+
+الوصول إلى تهيئة HITL من: **النشر** ← **الإعدادات** ← **تهيئة الإنسان في الحلقة**
+
+<Frame>
+  <img src="/images/enterprise/hitl-settings-overview.png" alt="HITL Configuration Settings" />
+</Frame>
+
+### إشعارات البريد الإلكتروني
+
+تبديل لتفعيل أو تعطيل إشعارات البريد الإلكتروني لطلبات HITL.
+
+| الإعداد | الافتراضي | الوصف |
+|---------|---------|-------------|
+| إشعارات البريد الإلكتروني | مفعّل | إرسال رسائل عند طلب الملاحظات |
+
+<Note>
+عند التعطيل، يجب على المستجيبين استخدام واجهة لوحة التحكم أو يجب تهيئة webhooks لأنظمة إشعارات مخصصة.
+</Note>
+
+### هدف SLA
+
+تعيين وقت استجابة مستهدف لأغراض التتبع والمقاييس.
+
+| الإعداد | الوصف |
+|---------|-------------|
+| هدف SLA (دقائق) | وقت الاستجابة المستهدف. يُستخدم لمقاييس لوحة التحكم وتتبع SLA |
+
+اتركه فارغًا لتعطيل تتبع SLA.
+
+## إشعارات واستجابات البريد الإلكتروني
+
+يستخدم نظام HITL بنية البريد الإلكتروني أولاً حيث يمكن للمستجيبين الرد مباشرة على رسائل الإشعار.
+
+### كيف تعمل استجابات البريد الإلكتروني
+
+<Steps>
+  <Step title="إرسال الإشعار">
+    عند إنشاء طلب HITL، يُرسل بريد إلكتروني إلى المستجيب المعيّن مع محتوى المراجعة والسياق.
+  </Step>
+  <Step title="عنوان الرد">
+    يتضمن البريد عنوان رد خاص مع رمز موقّع للمصادقة.
+  </Step>
+  <Step title="رد المستخدم">
+    يرد المستجيب ببساطة على البريد بملاحظاته — بدون حاجة لتسجيل الدخول.
+  </Step>
+  <Step title="التحقق من الرمز">
+    تستقبل المنصة الرد، وتتحقق من الرمز الموقّع، وتطابق بريد المرسل.
+  </Step>
+  <Step title="استئناف التدفق">
+    تُسجل الملاحظات ويستمر التدفق مع مدخلات الإنسان.
+  </Step>
+</Steps>
+
+### تنسيق الاستجابة
+
+يمكن للمستجيبين الرد بـ:
+
+- **خيار emit**: إذا تطابق الرد مع خيار `emit` (مثل "approved")، يُستخدم مباشرة
+- **نص حر**: أي نص استجابة يُمرر إلى التدفق كملاحظات
+- **نص عادي**: يُستخدم السطر الأول من نص الرد كملاحظات
+
+### رسائل التأكيد
+
+بعد معالجة الرد، يستلم المستجيب رسالة تأكيد تشير إلى ما إذا تم إرسال الملاحظات بنجاح أو حدث خطأ.
+
+### أمان رمز البريد
+
+- الرموز موقّعة تشفيريًا للأمان
+- تنتهي صلاحية الرموز بعد 7 أيام
+- يجب أن يتطابق بريد المرسل مع البريد المصرّح به في الرمز
+- تُرسل رسائل تأكيد/خطأ بعد المعالجة
+
+## قواعد التوجيه
+
+توجيه طلبات HITL إلى عناوين بريد إلكتروني محددة بناءً على أنماط الطرق.
+
+<Frame>
+  <img src="/images/enterprise/hitl-settings-routing-rules.png" alt="HITL Routing Rules Configuration" />
+</Frame>
+
+### هيكل القاعدة
+
+```json
+{
+  "name": "Approvals to Finance",
+  "match": {
+    "method_name": "approve_*"
+  },
+  "assign_to_email": "finance@company.com",
+  "assign_from_input": "manager_email"
+}
+```
+
+### أنماط المطابقة
+
+| النمط | الوصف | مثال المطابقة |
+|---------|-------------|---------------|
+| `approve_*` | حرف بدل (أي أحرف) | `approve_payment`، `approve_vendor` |
+| `review_?` | حرف واحد | `review_a`، `review_1` |
+| `validate_payment` | مطابقة تامة | `validate_payment` فقط |
+
+### أولوية التعيين
+
+1. **تعيين ديناميكي** (`assign_from_input`): إذا تم تهيئته، يسحب البريد من حالة التدفق
+2. **بريد ثابت** (`assign_to_email`): يرجع إلى البريد المهيأ
+3. **منشئ النشر**: إذا لم تتطابق أي قاعدة، يُستخدم بريد منشئ النشر
+
+### مثال التعيين الديناميكي
+
+إذا كانت حالة تدفقك تحتوي على `{"sales_rep_email": "alice@company.com"}`، هيّئ:
+
+```json
+{
+  "name": "Route to Sales Rep",
+  "match": {
+    "method_name": "review_*"
+  },
+  "assign_from_input": "sales_rep_email"
+}
+```
+
+سيتم تعيين الطلب إلى `alice@company.com` تلقائيًا.
+
+<Tip>
+**حالة استخدام**: اسحب المعيّن من CRM أو قاعدة البيانات أو خطوة تدفق سابقة لتوجيه المراجعات ديناميكيًا إلى الشخص المناسب.
+</Tip>
+
+## الاستجابة التلقائية
+
+الاستجابة تلقائيًا لطلبات HITL إذا لم يستجب أي شخص خلال المهلة المحددة. يضمن هذا عدم تعليق التدفقات إلى أجل غير مسمى.
+
+### التهيئة
+
+| الإعداد | الوصف |
+|---------|-------------|
+| مفعّل | تبديل لتفعيل الاستجابة التلقائية |
+| المهلة (دقائق) | الوقت المنتظر قبل الاستجابة التلقائية |
+| النتيجة الافتراضية | قيمة الاستجابة (يجب أن تطابق خيار `emit`) |
+
+<Frame>
+  <img src="/images/enterprise/hitl-settings-auto-respond.png" alt="HITL Auto-Response Configuration" />
+</Frame>
+
+### حالات الاستخدام
+
+- **الامتثال لـ SLA**: ضمان عدم تعليق التدفقات إلى أجل غير مسمى
+- **الموافقة الافتراضية**: الموافقة التلقائية على الطلبات منخفضة المخاطر بعد انتهاء المهلة
+- **التراجع السلس**: المتابعة بافتراضي آمن عندما يكون المراجعون غير متاحين
+
+<Warning>
+استخدم الاستجابة التلقائية بحذر. فعّلها فقط للمراجعات غير الحرجة حيث تكون الاستجابة الافتراضية مقبولة.
+</Warning>
+
+## عملية المراجعة
+
+### واجهة لوحة التحكم
+
+توفر واجهة مراجعة HITL تجربة نظيفة ومركّزة للمراجعين:
+
+- **عرض Markdown**: تنسيق غني لمحتوى المراجعة مع تمييز الصيغة
+- **لوحة السياق**: عرض حالة التدفق وتاريخ التنفيذ والمعلومات ذات الصلة
+- **إدخال الملاحظات**: تقديم ملاحظات وتعليقات مفصلة مع قرارك
+- **إجراءات سريعة**: أزرار خيارات emit بنقرة واحدة مع تعليقات اختيارية
+
+<Frame>
+  <img src="/images/enterprise/hitl-list-pending-feedbacks.png" alt="HITL Pending Requests List" />
+</Frame>
+
+### طرق الاستجابة
+
+يمكن للمراجعين الاستجابة عبر ثلاث قنوات:
+
+| الطريقة | الوصف |
+|--------|-------------|
+| **الرد عبر البريد** | الرد مباشرة على رسالة الإشعار |
+| **لوحة التحكم** | استخدام واجهة لوحة تحكم المؤسسة |
+| **API/Webhook** | استجابة برمجية عبر API |
+
+### السجل ومسار التدقيق
+
+يتم تتبع كل تفاعل HITL بجدول زمني كامل:
+
+- سجل القرارات (موافقة/رفض/مراجعة)
+- هوية المراجع والطابع الزمني
+- الملاحظات والتعليقات المقدمة
+- طريقة الاستجابة (بريد/لوحة تحكم/API)
+- مقاييس وقت الاستجابة
+
+## التحليلات والمراقبة
+
+تتبع أداء HITL مع تحليلات شاملة.
+
+### لوحة تحكم الأداء
+
+<Frame>
+  <img src="/images/enterprise/hitl-metrics.png" alt="HITL Metrics Dashboard" />
+</Frame>
+
+<CardGroup cols={2}>
+  <Card title="أوقات الاستجابة" icon="stopwatch">
+    مراقبة متوسط وميديان أوقات الاستجابة حسب المراجع أو التدفق.
+  </Card>
+  <Card title="اتجاهات الحجم" icon="chart-bar">
+    تحليل أنماط حجم المراجعة لتحسين قدرة الفريق.
+  </Card>
+  <Card title="توزيع القرارات" icon="chart-pie">
+    عرض معدلات الموافقة/الرفض عبر أنواع المراجعة المختلفة.
+  </Card>
+  <Card title="تتبع SLA" icon="chart-line">
+    تتبع نسبة المراجعات المكتملة ضمن أهداف SLA.
+  </Card>
+</CardGroup>
+
+### التدقيق والامتثال
+
+إمكانيات تدقيق جاهزة للمؤسسات للمتطلبات التنظيمية:
+
+- سجل قرارات كامل مع الطوابع الزمنية
+- التحقق من هوية المراجع
+- سجلات تدقيق غير قابلة للتغيير
+- إمكانيات التصدير لتقارير الامتثال
+
+## حالات الاستخدام الشائعة
+
+<AccordionGroup>
+  <Accordion title="المراجعات الأمنية" icon="shield-halved">
+    **حالة الاستخدام**: أتمتة استبيانات الأمان الداخلية مع التحقق البشري
+
+    - يولّد الذكاء الاصطناعي الردود على الاستبيانات الأمنية
+    - يراجع فريق الأمن ويتحقق من الدقة عبر البريد الإلكتروني
+    - يتم تجميع الردود المعتمدة في التقديم النهائي
+    - مسار تدقيق كامل للامتثال
+  </Accordion>
+
+  <Accordion title="الموافقة على المحتوى" icon="file-lines">
+    **حالة الاستخدام**: محتوى تسويقي يتطلب مراجعة قانونية/العلامة التجارية
+
+    - يولّد الذكاء الاصطناعي نصوص تسويقية أو محتوى وسائل التواصل
+    - التوجيه إلى بريد فريق العلامة التجارية لمراجعة النبرة/الأسلوب
+    - النشر التلقائي عند الموافقة
+  </Accordion>
+
+  <Accordion title="الموافقات المالية" icon="money-bill">
+    **حالة الاستخدام**: تقارير النفقات، شروط العقود، تخصيصات الميزانية
+
+    - يعالج الذكاء الاصطناعي مسبقًا ويصنف الطلبات المالية
+    - التوجيه بناءً على عتبات المبالغ باستخدام التعيين الديناميكي
+    - الحفاظ على مسار تدقيق كامل للامتثال المالي
+  </Accordion>
+
+  <Accordion title="التعيين الديناميكي من CRM" icon="database">
+    **حالة الاستخدام**: توجيه المراجعات إلى مالكي الحسابات من CRM
+
+    - يجلب التدفق بريد مالك الحساب من CRM
+    - تخزين البريد في حالة التدفق (مثل `account_owner_email`)
+    - استخدام `assign_from_input` للتوجيه إلى الشخص المناسب تلقائيًا
+  </Accordion>
+
+  <Accordion title="ضمان الجودة" icon="magnifying-glass">
+    **حالة الاستخدام**: التحقق من مخرجات الذكاء الاصطناعي قبل التسليم للعميل
+
+    - يولّد الذكاء الاصطناعي محتوى أو ردود موجهة للعميل
+    - يراجع فريق ضمان الجودة عبر إشعار البريد الإلكتروني
+    - حلقات الملاحظات تحسّن أداء الذكاء الاصطناعي بمرور الوقت
+  </Accordion>
+</AccordionGroup>
+
+## واجهة Webhooks API
+
+عندما تتوقف تدفقاتك للملاحظات البشرية، يمكنك تهيئة webhooks لإرسال بيانات الطلب إلى تطبيقك. يتيح هذا:
+
+- بناء واجهات موافقة مخصصة
+- التكامل مع الأدوات الداخلية (Jira، ServiceNow، لوحات تحكم مخصصة)
+- توجيه الموافقات إلى أنظمة طرف ثالث
+- إشعارات تطبيقات الجوال
+- أنظمة القرار المؤتمتة
+
+<Frame>
+  <img src="/images/enterprise/hitl-settings-webhook.png" alt="HITL Webhook Configuration" />
+</Frame>
+
+### تهيئة Webhooks
+
+<Steps>
+  <Step title="الانتقال إلى الإعدادات">
+    اذهب إلى **النشر** ← **الإعدادات** ← **الإنسان في الحلقة**
+  </Step>
+  <Step title="توسيع قسم Webhooks">
+    انقر لتوسيع تهيئة **Webhooks**
+  </Step>
+  <Step title="إضافة عنوان Webhook">
+    أدخل عنوان webhook الخاص بك (يجب أن يكون HTTPS في الإنتاج)
+  </Step>
+  <Step title="حفظ التهيئة">
+    انقر على **حفظ التهيئة** للتفعيل
+  </Step>
+</Steps>
+
+يمكنك تهيئة webhooks متعددة. يستقبل كل webhook نشط جميع أحداث HITL.
+
+### أحداث Webhook
+
+ستستقبل نقطة النهاية طلبات HTTP POST لهذه الأحداث:
+
+| نوع الحدث | متى يُطلق |
+|------------|----------------|
+| `new_request` | يتوقف تدفق ويطلب ملاحظات بشرية |
+
+### حمولة Webhook
+
+تستقبل جميع webhooks حمولة JSON بهذا الهيكل:
+
+```json
+{
+  "event": "new_request",
+  "request": {
+    "id": "550e8400-e29b-41d4-a716-446655440000",
+    "flow_id": "flow_abc123",
+    "method_name": "review_article",
+    "message": "Please review this article for publication.",
+    "emit_options": ["approved", "rejected", "request_changes"],
+    "state": {
+      "article_id": 12345,
+      "author": "john@example.com",
+      "category": "technology"
+    },
+    "metadata": {},
+    "created_at": "2026-01-14T12:00:00Z"
+  },
+  "deployment": {
+    "id": 456,
+    "name": "Content Review Flow",
+    "organization_id": 789
+  },
+  "callback_url": "https://api.crewai.com/...",
+  "assigned_to_email": "reviewer@company.com"
+}
+```
+
+### الرد على الطلبات
+
+لإرسال الملاحظات، **أرسل POST إلى `callback_url`** المضمّن في حمولة webhook.
+
+```http
+POST {callback_url}
+Content-Type: application/json
+
+{
+  "feedback": "Approved. Great article!",
+  "source": "my_custom_app"
+}
+```
+
+### الأمان
+
+<Info>
+جميع طلبات webhook موقّعة تشفيريًا باستخدام HMAC-SHA256 لضمان الأصالة ومنع التلاعب.
+</Info>
+
+#### أمان Webhook
+
+- **توقيعات HMAC-SHA256**: يتضمن كل webhook توقيعًا تشفيريًا
+- **أسرار لكل webhook**: لكل webhook سر توقيع فريد
+- **مشفرة أثناء التخزين**: أسرار التوقيع مشفرة في قاعدة البيانات
+- **التحقق من الطابع الزمني**: يمنع هجمات الإعادة
+
+#### ترويسات التوقيع
+
+يتضمن كل طلب webhook هذه الترويسات:
+
+| الترويسة | الوصف |
+|--------|-------------|
+| `X-Signature` | توقيع HMAC-SHA256: `sha256=<hex_digest>` |
+| `X-Timestamp` | الطابع الزمني Unix عند توقيع الطلب |
+
+#### التحقق
+
+تحقق بحساب:
+
+```python
+import hmac
+import hashlib
+
+expected = hmac.new(
+    signing_secret.encode(),
+    f"{timestamp}.{payload}".encode(),
+    hashlib.sha256
+).hexdigest()
+
+if hmac.compare_digest(expected, signature):
+    # توقيع صالح
+```
+
+### معالجة الأخطاء
+
+يجب أن تعيد نقطة نهاية webhook كود حالة 2xx لتأكيد الاستلام:
+
+| استجابتك | سلوكنا |
+|---------------|--------------|
+| 2xx | تم تسليم Webhook بنجاح |
+| 4xx/5xx | مسجل كفشل، بدون إعادة محاولة |
+| مهلة (30 ثانية) | مسجل كفشل، بدون إعادة محاولة |
+
+## الأمان والتحكم في الوصول المبني على الأدوار
+
+### الوصول إلى لوحة التحكم
+
+يُتحكم في وصول HITL على مستوى النشر:
+
+| الصلاحية | القدرة |
+|------------|------------|
+| `manage_human_feedback` | تهيئة إعدادات HITL، عرض جميع الطلبات |
+| `respond_to_human_feedback` | الرد على الطلبات، عرض الطلبات المعيّنة |
+
+### تصريح استجابة البريد الإلكتروني
+
+للردود عبر البريد:
+1. يشفّر رمز الرد البريد المصرّح به
+2. يجب أن يتطابق بريد المرسل مع بريد الرمز
+3. يجب ألا يكون الرمز منتهي الصلاحية (7 أيام افتراضيًا)
+4. يجب أن يكون الطلب لا يزال معلقًا
+
+### مسار التدقيق
+
+يتم تسجيل جميع إجراءات HITL:
+- إنشاء الطلب
+- تغييرات التعيين
+- إرسال الاستجابة (مع المصدر: لوحة تحكم/بريد/API)
+- حالة استئناف التدفق
+
+## استكشاف الأخطاء وإصلاحها
+
+### عدم إرسال الرسائل
+
+1. تحقق من تفعيل "إشعارات البريد الإلكتروني" في التهيئة
+2. تحقق من مطابقة قواعد التوجيه لاسم الطريقة
+3. تحقق من صلاحية بريد المعيّن
+4. تحقق من احتياطي منشئ النشر إذا لم تتطابق أي قواعد توجيه
+
+### عدم معالجة ردود البريد
+
+1. تحقق من عدم انتهاء صلاحية الرمز (7 أيام افتراضيًا)
+2. تحقق من مطابقة بريد المرسل للبريد المعيّن
+3. تأكد من أن الطلب لا يزال معلقًا (لم يتم الرد عليه بعد)
+
+### عدم استئناف التدفق
+
+1. تحقق من حالة الطلب في لوحة التحكم
+2. تحقق من إمكانية الوصول إلى callback URL
+3. تأكد من أن النشر لا يزال قيد التشغيل
+
+## أفضل الممارسات
+
+<Tip>
+**ابدأ ببساطة**: ابدأ بإشعارات البريد الإلكتروني لمنشئ النشر، ثم أضف قواعد التوجيه مع نضوج سير عملك.
+</Tip>
+
+1. **استخدم التعيين الديناميكي**: اسحب عناوين بريد المعيّنين من حالة التدفق للتوجيه المرن.
+
+2. **هيّئ الاستجابة التلقائية**: أعد استجابة احتياطية للمراجعات غير الحرجة لمنع تعليق التدفقات.
+
+3. **راقب أوقات الاستجابة**: استخدم التحليلات لتحديد الاختناقات وتحسين عملية المراجعة.
+
+4. **اجعل رسائل المراجعة واضحة**: اكتب رسائل واضحة وقابلة للتنفيذ في مزيّن `@human_feedback`.
+
+5. **اختبر تدفق البريد**: أرسل طلبات اختبار للتحقق من تسليم البريد قبل الانتقال للإنتاج.
+
+## الموارد ذات الصلة
+
+<CardGroup cols={2}>
+  <Card title="التغذية الراجعة البشرية في التدفقات" icon="code" href="/ar/learn/human-feedback-in-flows">
+    دليل التنفيذ لمزيّن `@human_feedback`
+  </Card>
+  <Card title="دليل سير عمل Flow HITL" icon="route" href="/ar/enterprise/guides/human-in-the-loop">
+    دليل خطوة بخطوة لإعداد سير عمل HITL
+  </Card>
+  <Card title="تهيئة RBAC" icon="shield-check" href="/ar/enterprise/features/rbac">
+    تهيئة التحكم في الوصول المبني على الأدوار لمؤسستك
+  </Card>
+  <Card title="بث Webhook" icon="bolt" href="/ar/enterprise/features/webhook-streaming">
+    إعداد إشعارات الأحداث في الوقت الفعلي
+  </Card>
+</CardGroup>
@@ -0,0 +1,251 @@
+---
+title: حاجز الهلوسة
+description: "منع واكتشاف هلوسات الذكاء الاصطناعي في مهام CrewAI"
+icon: "shield-check"
+mode: "wide"
+---
+
+## نظرة عامة
+
+حاجز الهلوسة هو ميزة مؤسسية تتحقق من المحتوى المولّد بالذكاء الاصطناعي لضمان أنه مبني على الحقائق ولا يحتوي على هلوسات. يحلل مخرجات المهام مقابل سياق مرجعي ويوفر ملاحظات مفصلة عند اكتشاف محتوى محتمل الهلوسة.
+
+## ما هي الهلوسات؟
+
+تحدث هلوسات الذكاء الاصطناعي عندما تولّد نماذج اللغة محتوى يبدو معقولاً لكنه غير صحيح من الناحية الواقعية أو غير مدعوم بالسياق المقدم. يساعد حاجز الهلوسة في منع هذه المشكلات من خلال:
+
+- مقارنة المخرجات مع السياق المرجعي
+- تقييم الأمانة للمادة المصدرية
+- توفير ملاحظات مفصلة حول المحتوى المشكل
+- دعم عتبات مخصصة لصرامة التحقق
+
+## الاستخدام الأساسي
+
+### إعداد الحاجز
+
+```python
+from crewai.tasks.hallucination_guardrail import HallucinationGuardrail
+from crewai import LLM
+
+# الاستخدام الأساسي - سيستخدم expected_output للمهمة كسياق
+guardrail = HallucinationGuardrail(
+    llm=LLM(model="gpt-4o-mini")
+)
+
+# مع سياق مرجعي صريح
+context_guardrail = HallucinationGuardrail(
+    context="AI helps with various tasks including analysis and generation.",
+    llm=LLM(model="gpt-4o-mini")
+)
+```
+
+### الإضافة إلى المهام
+
+```python
+from crewai import Task
+
+# إنشاء مهمتك مع الحاجز
+task = Task(
+    description="Write a summary about AI capabilities",
+    expected_output="A factual summary based on the provided context",
+    agent=my_agent,
+    guardrail=guardrail  # إضافة الحاجز للتحقق من المخرجات
+)
+```
+
+## التهيئة المتقدمة
+
+### التحقق بعتبة مخصصة
+
+للتحقق الأكثر صرامة، يمكنك تعيين عتبة أمانة مخصصة (مقياس 0-10):
+
+```python
+# حاجز صارم يتطلب درجة أمانة عالية
+strict_guardrail = HallucinationGuardrail(
+    context="Quantum computing uses qubits that exist in superposition states.",
+    llm=LLM(model="gpt-4o-mini"),
+    threshold=8.0  # يتطلب درجة >= 8 لاجتياز التحقق
+)
+```
+
+### تضمين سياق استجابة الأدوات
+
+عندما تستخدم مهمتك أدوات، يمكنك تضمين استجابات الأدوات لتحقق أكثر دقة:
+
+```python
+# حاجز مع سياق استجابة الأدوات
+weather_guardrail = HallucinationGuardrail(
+    context="Current weather information for the requested location",
+    llm=LLM(model="gpt-4o-mini"),
+    tool_response="Weather API returned: Temperature 22°C, Humidity 65%, Clear skies"
+)
+```
+
+## كيف يعمل
+
+### عملية التحقق
+
+1. **تحليل السياق**: يقارن الحاجز مخرجات المهمة مع السياق المرجعي المقدم
+2. **تسجيل الأمانة**: يستخدم مقيّمًا داخليًا لتعيين درجة أمانة (0-10)
+3. **تحديد الحكم**: يحدد ما إذا كان المحتوى أمينًا أو يحتوي على هلوسات
+4. **التحقق من العتبة**: إذا تم تعيين عتبة مخصصة، يتحقق مقابل تلك الدرجة
+5. **توليد الملاحظات**: يوفر أسبابًا مفصلة عند فشل التحقق
+
+### منطق التحقق
+
+- **الوضع الافتراضي**: يستخدم التحقق المبني على الحكم (FAITHFUL مقابل HALLUCINATED)
+- **وضع العتبة**: يتطلب أن تلبي درجة الأمانة العتبة المحددة أو تتجاوزها
+- **معالجة الأخطاء**: يتعامل بسلاسة مع أخطاء التقييم ويوفر ملاحظات إعلامية
+
+## نتائج الحاجز
+
+يعيد الحاجز نتائج منظمة تشير إلى حالة التحقق:
+
+```python
+# مثال على هيكل نتيجة الحاجز
+{
+    "valid": False,
+    "feedback": "Content appears to be hallucinated (score: 4.2/10, verdict: HALLUCINATED). The output contains information not supported by the provided context."
+}
+```
+
+### خصائص النتيجة
+
+- **valid**: قيمة منطقية تشير إلى ما إذا اجتازت المخرجات التحقق
+- **feedback**: شرح مفصل عند فشل التحقق، يتضمن:
+  - درجة الأمانة
+  - تصنيف الحكم
+  - أسباب محددة للفشل
+
+## التكامل مع نظام المهام
+
+### التحقق التلقائي
+
+عند إضافة حاجز إلى مهمة، يتحقق تلقائيًا من المخرجات قبل اعتبار المهمة مكتملة:
+
+```python
+# تدفق التحقق من مخرجات المهمة
+task_output = agent.execute_task(task)
+validation_result = guardrail(task_output)
+
+if validation_result.valid:
+    # المهمة تكتمل بنجاح
+    return task_output
+else:
+    # المهمة تفشل مع ملاحظات التحقق
+    raise ValidationError(validation_result.feedback)
+```
+
+### تتبع الأحداث
+
+يتكامل الحاجز مع نظام أحداث CrewAI لتوفير المراقبة:
+
+- **بدء التحقق**: عند بدء تقييم الحاجز
+- **اكتمال التحقق**: عند انتهاء التقييم بالنتائج
+- **فشل التحقق**: عند حدوث أخطاء تقنية أثناء التقييم
+
+## أفضل الممارسات
+
+### إرشادات السياق
+
+<Steps>
+  <Step title="توفير سياق شامل">
+    أدرج جميع المعلومات الواقعية ذات الصلة التي يجب أن يبني عليها الذكاء الاصطناعي مخرجاته:
+
+    ```python
+    context = """
+    Company XYZ was founded in 2020 and specializes in renewable energy solutions.
+    They have 150 employees and generated $50M revenue in 2023.
+    Their main products include solar panels and wind turbines.
+    """
+    ```
+  </Step>
+
+  <Step title="الحفاظ على صلة السياق">
+    أدرج فقط المعلومات المرتبطة مباشرة بالمهمة لتجنب الارتباك:
+
+    ```python
+    # جيد: سياق مركّز
+    context = "The current weather in New York is 18°C with light rain."
+
+    # تجنب: معلومات غير ذات صلة
+    context = "The weather is 18°C. The city has 8 million people. Traffic is heavy."
+    ```
+  </Step>
+
+  <Step title="تحديث السياق بانتظام">
+    تأكد من أن السياق المرجعي يعكس معلومات حالية ودقيقة.
+  </Step>
+</Steps>
+
+### اختيار العتبة
+
+<Steps>
+  <Step title="البدء بالتحقق الافتراضي">
+    ابدأ بدون عتبات مخصصة لفهم الأداء الأساسي.
+  </Step>
+
+  <Step title="الضبط بناءً على المتطلبات">
+    - **محتوى عالي الأهمية**: استخدم عتبة 8-10 للدقة القصوى
+    - **محتوى عام**: استخدم عتبة 6-7 للتحقق المتوازن
+    - **محتوى إبداعي**: استخدم عتبة 4-5 أو التحقق الافتراضي المبني على الحكم
+  </Step>
+
+  <Step title="المراقبة والتكرار">
+    تتبع نتائج التحقق واضبط العتبات بناءً على الإيجابيات/السلبيات الكاذبة.
+  </Step>
+</Steps>
+
+## اعتبارات الأداء
+
+### التأثير على زمن التنفيذ
+
+- **عبء التحقق**: يضيف كل حاجز حوالي 1-3 ثوانٍ لكل مهمة
+- **كفاءة LLM**: اختر نماذج فعالة للتقييم (مثل gpt-4o-mini)
+
+### تحسين التكلفة
+
+- **اختيار النموذج**: استخدم نماذج أصغر وفعالة لتقييم الحاجز
+- **حجم السياق**: اجعل السياق المرجعي موجزًا لكن شاملًا
+- **التخزين المؤقت**: فكّر في تخزين نتائج التحقق مؤقتًا للمحتوى المتكرر
+
+## استكشاف الأخطاء وإصلاحها
+
+<Accordion title="فشل التحقق دائمًا">
+  **الأسباب المحتملة:**
+  - السياق مقيّد جدًا أو غير مرتبط بمخرجات المهمة
+  - العتبة معينة عالية جدًا لنوع المحتوى
+  - السياق المرجعي يحتوي على معلومات قديمة
+
+  **الحلول:**
+  - مراجعة وتحديث السياق ليتطابق مع متطلبات المهمة
+  - خفض العتبة أو استخدام التحقق الافتراضي المبني على الحكم
+  - التأكد من أن السياق حالي ودقيق
+</Accordion>
+
+<Accordion title="إيجابيات كاذبة (محتوى صالح يُعلّم كغير صالح)">
+  **الأسباب المحتملة:**
+  - العتبة عالية جدًا للمهام الإبداعية أو التفسيرية
+  - السياق لا يغطي جميع الجوانب الصالحة للمخرجات
+  - نموذج التقييم محافظ بشكل مفرط
+
+  **الحلول:**
+  - خفض العتبة أو استخدام التحقق الافتراضي
+  - توسيع السياق ليشمل محتوى مقبول أوسع
+  - الاختبار مع نماذج تقييم مختلفة
+</Accordion>
+
+<Accordion title="أخطاء التقييم">
+  **الأسباب المحتملة:**
+  - مشكلات في الاتصال بالشبكة
+  - نموذج LLM غير متاح أو محدود المعدل
+  - مخرجات مهمة أو سياق غير صالح
+
+  **الحلول:**
+  - التحقق من الاتصال بالشبكة وحالة خدمة LLM
+  - تنفيذ منطق إعادة المحاولة للأعطال المؤقتة
+  - التحقق من تنسيق مخرجات المهمة قبل تقييم الحاجز
+</Accordion>
+
+<Card title="هل تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+  تواصل مع فريق الدعم للمساعدة في تهيئة حاجز الهلوسة أو استكشاف الأخطاء وإصلاحها.
+</Card>
@@ -0,0 +1,45 @@
+---
+title: السوق
+description: "اكتشف وثبّت وأدِر الأصول القابلة لإعادة الاستخدام لطواقم مؤسستك."
+icon: "store"
+mode: "wide"
+---
+
+## نظرة عامة
+
+يوفر السوق واجهة منظمة لاكتشاف عمليات التكامل والأدوات الداخلية والأصول القابلة لإعادة الاستخدام التي تسرّع تطوير الطواقم.
+
+<Frame>
+  ![نظرة عامة على السوق](/images/enterprise/marketplace-overview.png)
+</Frame>
+
+## قابلية الاكتشاف
+
+- تصفح حسب الفئة والقدرة
+- ابحث عن الأصول بالاسم أو الكلمة المفتاحية
+
+## التثبيت والتفعيل
+
+- تثبيت بنقرة واحدة للأصول المعتمدة
+- تفعيل أو تعطيل لكل طاقم حسب الحاجة
+- تهيئة متغيرات البيئة والنطاقات المطلوبة
+
+<Frame>
+  ![التثبيت والتهيئة](/images/enterprise/marketplace-install.png)
+</Frame>
+
+يمكنك أيضاً تنزيل القوالب مباشرة من السوق بالنقر على زر `Download` لاستخدامها محلياً أو تعديلها حسب احتياجاتك.
+
+## ذو صلة
+
+<CardGroup cols={3}>
+  <Card title="الأدوات والتكاملات" href="/ar/enterprise/features/tools-and-integrations" icon="wrench">
+    اربط التطبيقات الخارجية وأدِر الأدوات الداخلية التي يمكن لوكلائك استخدامها.
+  </Card>
+  <Card title="مستودع الأدوات" href="/ar/enterprise/guides/tool-repository#tool-repository" icon="toolbox">
+    انشر وثبّت الأدوات لتعزيز قدرات طواقمك.
+  </Card>
+  <Card title="مستودع الوكلاء" href="/ar/enterprise/features/agent-repositories" icon="people-group">
+    خزّن وشارك وأعد استخدام تعريفات الوكلاء عبر الفرق والمشاريع.
+  </Card>
+</CardGroup>
@@ -0,0 +1,342 @@
+---
+title: إخفاء البيانات الشخصية في التتبعات
+description: "إخفاء البيانات الحساسة تلقائياً من تتبعات تنفيذ الطواقم والتدفقات"
+icon: "lock"
+mode: "wide"
+---
+
+## نظرة عامة
+
+إخفاء البيانات الشخصية (PII Redaction) هو ميزة في CrewAI AMP تكتشف تلقائياً وتُقنّع معلومات التعريف الشخصية (PII) في تتبعات تنفيذ الطواقم والتدفقات. يضمن ذلك عدم كشف البيانات الحساسة مثل أرقام بطاقات الائتمان وأرقام الضمان الاجتماعي وعناوين البريد الإلكتروني والأسماء في تتبعات CrewAI AMP. يمكنك أيضاً إنشاء مُعرّفات مخصصة لحماية البيانات الخاصة بمؤسستك.
+
+
+<Info>
+  إخفاء البيانات الشخصية متاح في خطة Enterprise.
+  يجب أن يكون إصدار النشر 1.8.0 أو أعلى.
+</Info>
+
+
+<Frame>
+  ![نظرة عامة على إخفاء البيانات الشخصية](/images/enterprise/pii_mask_recognizer_trace_example.png)
+</Frame>
+
+
+## أهمية إخفاء البيانات الشخصية
+
+عند تشغيل وكلاء الذكاء الاصطناعي في بيئة الإنتاج، غالباً ما تمر معلومات حساسة عبر طواقمك:
+
+- بيانات العملاء من تكاملات CRM
+- معلومات مالية من معالجات الدفع
+- تفاصيل شخصية من إرسالات النماذج
+- بيانات الموظفين الداخلية
+
+بدون إخفاء مناسب، تظهر هذه البيانات في التتبعات، مما يجعل الامتثال للوائح مثل GDPR وHIPAA وPCI-DSS أمراً صعباً. يحل إخفاء البيانات الشخصية هذه المشكلة عن طريق إقناع البيانات الحساسة تلقائياً قبل تخزينها في التتبعات.
+
+## كيف يعمل
+
+1. **الاكتشاف** - مسح بيانات أحداث التتبع بحثاً عن أنماط PII المعروفة
+2. **التصنيف** - تحديد نوع البيانات الحساسة (بطاقة ائتمان، SSN، بريد إلكتروني، إلخ.)
+3. **الإقناع/الإخفاء** - استبدال البيانات الحساسة بقيم مُقنّعة بناءً على تهيئتك
+
+```
+Original: "Contact john.doe@company.com or call 555-123-4567"
+Redacted: "Contact <EMAIL_ADDRESS> or call <PHONE_NUMBER>"
+```
+
+## تفعيل إخفاء البيانات الشخصية
+
+<Info>
+  يجب أن تكون على خطة Enterprise وأن يكون إصدار النشر 1.8.0 أو أعلى لاستخدام هذه الميزة.
+</Info>
+
+<Steps>
+  <Step title="الانتقال إلى إعدادات الطاقم">
+    في لوحة تحكم CrewAI AMP، اختر طاقمك المنشور وانتقل إلى أحد عمليات النشر/الأتمتة، ثم انتقل إلى **Settings** → **PII Protection**.
+  </Step>
+
+  <Step title="تفعيل حماية البيانات الشخصية">
+    فعّل **PII Redaction for Traces**. سيؤدي ذلك إلى تفعيل المسح والإخفاء التلقائي لبيانات التتبع.
+
+    <Info>
+      تحتاج إلى تفعيل إخفاء البيانات الشخصية يدوياً لكل عملية نشر.
+    </Info>
+
+    <Frame>
+      ![تفعيل إخفاء البيانات الشخصية](/images/enterprise/pii_mask_recognizer_enable.png)
+    </Frame>
+  </Step>
+
+  <Step title="تهيئة أنواع الكيانات">
+    اختر أنواع البيانات الشخصية التي تريد اكتشافها وإخفاءها. يمكن تفعيل أو تعطيل كل كيان بشكل فردي.
+
+    <Frame>
+      ![تهيئة الكيانات](/images/enterprise/pii_mask_recognizer_supported_entities.png)
+    </Frame>
+  </Step>
+
+  <Step title="الحفظ">
+    احفظ تهيئتك. سيكون إخفاء البيانات الشخصية نشطاً في جميع عمليات تنفيذ الطاقم اللاحقة، دون الحاجة لإعادة النشر.
+  </Step>
+</Steps>
+
+## أنواع الكيانات المدعومة
+
+يدعم CrewAI أنواع كيانات PII التالية، منظمة حسب الفئة.
+
+### الكيانات العالمية
+
+| الكيان | الوصف | مثال |
+|--------|-------|------|
+| `CREDIT_CARD` | أرقام بطاقات الائتمان/الخصم | "4111-1111-1111-1111" |
+| `CRYPTO` | عناوين محافظ العملات الرقمية | "bc1qxy2kgd..." |
+| `DATE_TIME` | التواريخ والأوقات | "January 15, 2024" |
+| `EMAIL_ADDRESS` | عناوين البريد الإلكتروني | "john@example.com" |
+| `IBAN_CODE` | أرقام الحسابات المصرفية الدولية | "DE89 3704 0044 0532 0130 00" |
+| `IP_ADDRESS` | عناوين IPv4 وIPv6 | "192.168.1.1" |
+| `LOCATION` | المواقع الجغرافية | "New York City" |
+| `MEDICAL_LICENSE` | أرقام التراخيص الطبية | "MD12345" |
+| `NRP` | الجنسيات أو المجموعات الدينية أو السياسية | - |
+| `PERSON` | الأسماء الشخصية | "John Doe" |
+| `PHONE_NUMBER` | أرقام الهواتف بتنسيقات مختلفة | "+1 (555) 123-4567" |
+| `URL` | عناوين URL | "https://example.com" |
+
+### كيانات خاصة بالولايات المتحدة
+
+| الكيان | الوصف | مثال |
+|--------|-------|------|
+| `US_BANK_NUMBER` | أرقام الحسابات المصرفية الأمريكية | "1234567890" |
+| `US_DRIVER_LICENSE` | أرقام رخص القيادة الأمريكية | "D1234567" |
+| `US_ITIN` | رقم تعريف دافع الضرائب الفردي | "900-70-0000" |
+| `US_PASSPORT` | أرقام جوازات السفر الأمريكية | "123456789" |
+| `US_SSN` | أرقام الضمان الاجتماعي | "123-45-6789" |
+
+## إجراءات الإخفاء
+
+لكل كيان مُفعّل، يمكنك تهيئة كيفية إخفاء البيانات:
+
+| الإجراء | الوصف | مثال على المخرجات |
+|---------|-------|-------------------|
+| `mask` | الاستبدال بتسمية نوع الكيان | `<CREDIT_CARD>` |
+| `redact` | إزالة النص بالكامل | *(فارغ)* |
+
+## المُعرّفات المخصصة
+
+بالإضافة إلى الكيانات المدمجة، يمكنك إنشاء **مُعرّفات مخصصة** لاكتشاف أنماط PII الخاصة بمؤسستك.
+
+<Frame>
+  ![المُعرّفات المخصصة](/images/enterprise/pii_mask_recognizer.png)
+</Frame>
+
+### أنواع المُعرّفات
+
+لديك خياران للمُعرّفات المخصصة:
+
+| النوع | الأفضل لـ | مثال على حالة الاستخدام |
+|-------|-----------|------------------------|
+| **قائم على النمط (Regex)** | بيانات منظمة بتنسيقات متوقعة | مبالغ الرواتب، معرّفات الموظفين، رموز المشاريع |
+| **قائمة الحظر (Deny-list)** | مطابقة النصوص بالضبط | أسماء الشركات، الأسماء الرمزية الداخلية، مصطلحات محددة |
+
+### إنشاء مُعرّف مخصص
+
+<Steps>
+  <Step title="الانتقال إلى المُعرّفات المخصصة">
+    انتقل إلى **Settings** → **Organization** → **Add Recognizer** في إعدادات مؤسستك.
+  </Step>
+
+  <Step title="تهيئة المُعرّف">
+    <Frame>
+      ![تهيئة المُعرّف](/images/enterprise/pii_mask_recognizer_create.png)
+    </Frame>
+
+    هيّئ الحقول التالية:
+    - **Name**: اسم وصفي للمُعرّف
+    - **Entity Type**: تسمية الكيان التي ستظهر في المخرجات المُخفاة (مثل `EMPLOYEE_ID`، `SALARY`)
+    - **Type**: اختر بين Regex Pattern أو Deny List
+    - **Pattern/Values**: نمط Regex أو قائمة نصوص للمطابقة
+    - **Confidence Threshold**: الحد الأدنى للنتيجة (0.0-1.0) المطلوبة لتفعيل الإخفاء عند المطابقة. القيم الأعلى (مثل 0.8) تقلل الإيجابيات الخاطئة لكن قد تفوّت بعض المطابقات. القيم الأقل (مثل 0.5) تلتقط المزيد من المطابقات لكن قد تُفرط في الإخفاء. القيمة الافتراضية هي 0.8.
+    - **Context Words** (اختياري): كلمات تزيد ثقة الاكتشاف عند وجودها بالقرب
+  </Step>
+
+  <Step title="الحفظ">
+    احفظ المُعرّف. سيكون متاحاً للتفعيل في عمليات النشر الخاصة بك.
+  </Step>
+</Steps>
+
+### فهم أنواع الكيانات
+
+يحدد **Entity Type** كيفية ظهور المحتوى المُطابق في التتبعات المُخفاة:
+
+```
+Entity Type: SALARY
+Pattern: salary:\s*\$\s*\d+
+Input: "Employee salary: $50,000"
+Output: "Employee <SALARY>"
+```
+
+### استخدام كلمات السياق
+
+تحسّن كلمات السياق الدقة عن طريق زيادة الثقة عند ظهور مصطلحات محددة بالقرب من النمط المُطابق:
+
+```
+Context Words: "project", "code", "internal"
+Entity Type: PROJECT_CODE
+Pattern: PRJ-\d{4}
+```
+
+عندما تظهر كلمة "project" أو "code" بالقرب من "PRJ-1234"، يكون لدى المُعرّف ثقة أعلى بأنها مطابقة حقيقية، مما يقلل الإيجابيات الخاطئة.
+
+
+## عرض التتبعات المُخفاة
+
+بمجرد تفعيل إخفاء البيانات الشخصية، ستعرض تتبعاتك قيماً مُخفاة بدلاً من البيانات الحساسة:
+
+```
+Task Output: "Customer <PERSON> placed order #12345.
+Contact email: <EMAIL_ADDRESS>, phone: <PHONE_NUMBER>.
+Payment processed for card ending in <CREDIT_CARD>."
+```
+
+القيم المُخفاة مُعلّمة بوضوح بأقواس زاوية وتسمية نوع الكيان (مثل `<EMAIL_ADDRESS>`)، مما يسهّل فهم البيانات التي تمت حمايتها مع السماح لك بتصحيح الأخطاء ومراقبة سلوك الطاقم.
+
+
+
+## أفضل الممارسات
+
+### اعتبارات الأداء
+
+<Steps>
+  <Step title="فعّل الكيانات المطلوبة فقط">
+    كل كيان مُفعّل يضيف عبء معالجة. فعّل فقط الكيانات ذات الصلة ببياناتك.
+  </Step>
+
+  <Step title="استخدم أنماطاً محددة">
+    للمُعرّفات المخصصة، استخدم أنماطاً محددة لتقليل الإيجابيات الخاطئة وتحسين الأداء. أنماط Regex هي الأفضل عند تحديد أنماط معينة في التتبعات مثل الرواتب ومعرّفات الموظفين ورموز المشاريع وغيرها. مُعرّفات قائمة الحظر هي الأفضل عند تحديد نصوص بعينها في التتبعات مثل أسماء الشركات والأسماء الرمزية الداخلية وغيرها.
+  </Step>
+
+  <Step title="استفد من كلمات السياق">
+    تحسّن كلمات السياق الدقة عن طريق تفعيل الاكتشاف فقط عندما يتطابق النص المحيط.
+  </Step>
+</Steps>
+
+## استكشاف الأخطاء وإصلاحها
+
+<Accordion title="البيانات الشخصية لا تُخفى">
+  **الأسباب المحتملة:**
+  - نوع الكيان غير مُفعّل في التهيئة
+  - النمط لا يتطابق مع تنسيق البيانات
+  - المُعرّف المخصص يحتوي على أخطاء في الصياغة
+
+  **الحلول:**
+  - تحقق من أن الكيان مُفعّل في Settings → Security
+  - اختبر أنماط Regex مع بيانات نموذجية
+  - تحقق من السجلات بحثاً عن أخطاء التهيئة
+</Accordion>
+
+<Accordion title="إخفاء بيانات أكثر من اللازم">
+  **الأسباب المحتملة:**
+  - أنواع كيانات واسعة جداً مُفعّلة (مثل `DATE_TIME` تلتقط التواريخ في كل مكان)
+  - أنماط المُعرّف المخصص عامة جداً
+
+  **الحلول:**
+  - عطّل الكيانات التي تسبب إيجابيات خاطئة
+  - اجعل الأنماط المخصصة أكثر تحديداً
+  - أضف كلمات سياق لتحسين الدقة
+</Accordion>
+
+<Accordion title="مشاكل الأداء">
+  **الأسباب المحتملة:**
+  - عدد كبير جداً من الكيانات المُفعّلة
+  - الكيانات القائمة على NLP (مثل `PERSON` و`LOCATION` و`NRP`) مكلفة حسابياً لأنها تستخدم نماذج تعلم الآلة
+
+  **الحلول:**
+  - فعّل فقط الكيانات التي تحتاجها فعلاً
+  - فكّر في استخدام بدائل قائمة على الأنماط حيثما أمكن
+  - راقب أوقات معالجة التتبعات في لوحة التحكم
+</Accordion>
+
+---
+
+## مثال عملي: مطابقة نمط الراتب
+
+يوضح هذا المثال كيفية إنشاء مُعرّف مخصص لاكتشاف وإقناع معلومات الرواتب في تتبعاتك.
+
+### حالة الاستخدام
+
+يعالج طاقمك بيانات موظفين أو بيانات مالية تتضمن معلومات رواتب بتنسيقات مثل:
+- `salary: $50,000`
+- `salary: $125,000.00`
+- `salary:$1,500.50`
+
+تريد إقناع هذه القيم تلقائياً لحماية بيانات التعويضات الحساسة.
+
+### التهيئة
+
+<Frame>
+  ![تهيئة مُعرّف الراتب](/images/enterprise/pii_mask_custom_recognizer_salary.png)
+</Frame>
+
+| الحقل | القيمة |
+|-------|--------|
+| **Name** | `SALARY` |
+| **Entity Type** | `SALARY` |
+| **Type** | Regex Pattern |
+| **Regex Pattern** | `salary:\s*\$\s*\d{1,3}(,\d{3})*(\.\d{2})?` |
+| **Action** | Mask |
+| **Confidence Threshold** | `0.8` |
+| **Context Words** | `salary, compensation, pay, wage, income` |
+
+### تحليل نمط Regex
+
+| مكون النمط | المعنى |
+|------------|--------|
+| `salary:` | يطابق النص الحرفي "salary:" |
+| `\s*` | يطابق صفر أو أكثر من أحرف المسافات البيضاء |
+| `\$` | يطابق علامة الدولار (مُهرّبة) |
+| `\s*` | يطابق صفر أو أكثر من أحرف المسافات البيضاء بعد $ |
+| `\d{1,3}` | يطابق 1-3 أرقام (مثل "1"، "50"، "125") |
+| `(,\d{3})*` | يطابق الآلاف المفصولة بفواصل (مثل ",000"، ",500,000") |
+| `(\.\d{2})?` | يطابق اختيارياً السنتات (مثل ".00"، ".50") |
+
+### أمثلة على النتائج
+
+```
+Original: "Employee record shows salary: $125,000.00 annually"
+Redacted: "Employee record shows <SALARY> annually"
+
+Original: "Base salary:$50,000 with bonus potential"
+Redacted: "Base <SALARY> with bonus potential"
+```
+
+<Tip>
+  إضافة كلمات سياق مثل "salary" و"compensation" و"pay" و"wage" و"income" تساعد في زيادة ثقة الاكتشاف عند ظهور هذه المصطلحات بالقرب من النمط المُطابق، مما يقلل الإيجابيات الخاطئة.
+</Tip>
+
+### تفعيل المُعرّف لعمليات النشر
+
+<Warning>
+  إنشاء مُعرّف مخصص على مستوى المؤسسة لا يفعّله تلقائياً لعمليات النشر. يجب عليك تفعيل كل مُعرّف يدوياً لكل عملية نشر تريد تطبيقه عليها.
+</Warning>
+
+بعد إنشاء المُعرّف المخصص، فعّله لكل عملية نشر:
+
+<Steps>
+  <Step title="الانتقال إلى عملية النشر">
+    انتقل إلى عملية النشر/الأتمتة وافتح **Settings** → **PII Protection**.
+  </Step>
+
+  <Step title="اختيار المُعرّفات المخصصة">
+    تحت **Mask Recognizers**، سترى المُعرّفات المحددة على مستوى مؤسستك. حدد المربع بجانب المُعرّفات التي تريد تفعيلها.
+
+    <Frame>
+      ![تفعيل المُعرّف المخصص](/images/enterprise/pii_mask_recognizers_options.png)
+    </Frame>
+  </Step>
+
+  <Step title="حفظ التهيئة">
+    احفظ تغييراتك. سيكون المُعرّف نشطاً في جميع عمليات التنفيذ اللاحقة لعملية النشر هذه.
+  </Step>
+</Steps>
+
+<Info>
+  كرر هذه العملية لكل عملية نشر تحتاج فيها إلى المُعرّف المخصص. يمنحك ذلك تحكماً دقيقاً في المُعرّفات النشطة في البيئات المختلفة (مثل بيئة التطوير مقابل بيئة الإنتاج).
+</Info>
@@ -0,0 +1,256 @@
+---
+title: "التحكم في الوصول القائم على الأدوار (RBAC)"
+description: "تحكم في الوصول إلى الطواقم والأدوات والبيانات باستخدام الأدوار والنطاقات والصلاحيات الدقيقة."
+icon: "shield"
+mode: "wide"
+---
+
+## نظرة عامة
+
+يتيح RBAC في CrewAI AMP إدارة وصول آمنة وقابلة للتوسع من خلال طبقتين:
+
+1. **صلاحيات الميزات** — تتحكم في ما يمكن لكل دور القيام به عبر المنصة (إدارة، قراءة، أو بدون وصول)
+2. **صلاحيات على مستوى الكيان** — وصول دقيق للأتمتات الفردية ومتغيرات البيئة واتصالات LLM ومستودعات Git
+
+<Frame>
+  <img src="/images/enterprise/users_and_roles.png" alt="نظرة عامة على RBAC في CrewAI AMP" />
+</Frame>
+
+## المستخدمون والأدوار
+
+يُعيَّن لكل عضو في مساحة عمل CrewAI دور يحدد صلاحيات الوصول عبر الميزات المختلفة.
+
+يمكنك:
+
+- استخدام الأدوار المحددة مسبقاً (Owner، Member)
+- إنشاء أدوار مخصصة مصممة لصلاحيات محددة
+- تعيين الأدوار في أي وقت عبر لوحة الإعدادات
+
+يمكنك تهيئة المستخدمين والأدوار في Settings → Roles.
+
+<Steps>
+  <Step title="فتح إعدادات الأدوار">
+    انتقل إلى <b>Settings → Roles</b> في CrewAI AMP.
+  </Step>
+  <Step title="اختيار نوع الدور">
+    استخدم دوراً محدداً مسبقاً (<b>Owner</b>، <b>Member</b>) أو انقر على{" "}
+    <b>Create role</b> لتحديد دور مخصص.
+  </Step>
+  <Step title="التعيين للأعضاء">
+    اختر المستخدمين وعيّن لهم الدور. يمكنك تغيير ذلك في أي وقت.
+  </Step>
+</Steps>
+
+### الأدوار المحددة مسبقاً
+
+| الدور       | الوصف                                                                 |
+| :---------- | :-------------------------------------------------------------------- |
+| **Owner**   | وصول كامل لجميع الميزات والإعدادات. لا يمكن تقييده.                   |
+| **Member**  | وصول للقراءة لمعظم الميزات، وصول إدارة لمتغيرات البيئة واتصالات LLM ومشاريع Studio. لا يمكنه تعديل إعدادات المؤسسة أو الإعدادات الافتراضية. |
+
+### ملخص التهيئة
+
+| المجال                | مكان التهيئة                       | الخيارات                                |
+| :-------------------- | :--------------------------------- | :-------------------------------------- |
+| المستخدمون والأدوار   | Settings → Roles                   | محددة مسبقاً: Owner، Member؛ أدوار مخصصة |
+| رؤية الأتمتة         | Automation → Settings → Visibility | خاص؛ قائمة بيضاء للمستخدمين/الأدوار     |
+
+---
+
+## مصفوفة صلاحيات الميزات
+
+لكل دور مستوى صلاحية لكل منطقة ميزة. المستويات الثلاثة هي:
+
+- **إدارة (Manage)** — وصول كامل للقراءة/الكتابة (إنشاء، تعديل، حذف)
+- **قراءة (Read)** — وصول للعرض فقط
+- **بدون وصول (No access)** — الميزة مخفية/غير قابلة للوصول
+
+| الميزة                    | Owner   | Member (افتراضي) | المستويات المتاحة                  | الوصف                                                           |
+| :------------------------ | :------ | :--------------- | :--------------------------------- | :-------------------------------------------------------------- |
+| `usage_dashboards`        | Manage  | Read             | Manage / Read / No access          | عرض مقاييس وتحليلات الاستخدام                                   |
+| `crews_dashboards`        | Manage  | Read             | Manage / Read / No access          | عرض لوحات النشر والوصول إلى تفاصيل الأتمتة                      |
+| `invitations`             | Manage  | Read             | Manage / Read / No access          | دعوة أعضاء جدد إلى المؤسسة                                      |
+| `training_ui`             | Manage  | Read             | Manage / Read / No access          | الوصول إلى واجهات التدريب/الضبط الدقيق                           |
+| `tools`                   | Manage  | Read             | Manage / Read / No access          | إنشاء وإدارة الأدوات                                            |
+| `agents`                  | Manage  | Read             | Manage / Read / No access          | إنشاء وإدارة الوكلاء                                            |
+| `environment_variables`   | Manage  | Manage           | Manage / No access                 | إنشاء وإدارة متغيرات البيئة                                     |
+| `llm_connections`         | Manage  | Manage           | Manage / No access                 | تهيئة اتصالات مزودي LLM                                         |
+| `default_settings`        | Manage  | No access        | Manage / No access                 | تعديل الإعدادات الافتراضية على مستوى المؤسسة                     |
+| `organization_settings`   | Manage  | No access        | Manage / No access                 | إدارة الفوترة والخطط وتهيئة المؤسسة                              |
+| `studio_projects`         | Manage  | Manage           | Manage / No access                 | إنشاء وتعديل المشاريع في Studio                                  |
+
+<Tip>
+  عند إنشاء دور مخصص، يمكن ضبط معظم الميزات على **Manage** أو **Read** أو **No access**. ومع ذلك، فإن `environment_variables` و`llm_connections` و`default_settings` و`organization_settings` و`studio_projects` تدعم فقط **Manage** أو **No access** — لا يوجد خيار للقراءة فقط لهذه الميزات.
+</Tip>
+
+---
+
+## النشر من GitHub أو Zip
+
+من أكثر أسئلة RBAC شيوعاً: _"ما الصلاحيات التي يحتاجها عضو الفريق للنشر؟"_
+
+### النشر من GitHub
+
+لنشر أتمتة من مستودع GitHub، يحتاج المستخدم إلى:
+
+1. **`crews_dashboards`**: على الأقل `Read` — مطلوب للوصول إلى لوحة الأتمتات حيث يتم إنشاء عمليات النشر
+2. **الوصول إلى مستودع Git** (إذا كان RBAC على مستوى الكيان لمستودعات Git مفعلاً): يجب منح دور المستخدم الوصول إلى مستودع Git المحدد عبر صلاحيات مستوى الكيان
+3. **`studio_projects`: `Manage`** — إذا كان يبني الطاقم في Studio قبل النشر
+
+### النشر من Zip
+
+لنشر أتمتة من ملف Zip، يحتاج المستخدم إلى:
+
+1. **`crews_dashboards`**: على الأقل `Read` — مطلوب للوصول إلى لوحة الأتمتات
+2. **تفعيل نشر Zip**: يجب ألا تكون المؤسسة قد عطلت نشر Zip في إعدادات المؤسسة
+
+### مرجع سريع: الحد الأدنى من الصلاحيات للنشر
+
+| الإجراء              | صلاحيات الميزات المطلوبة             | متطلبات إضافية                                   |
+| :------------------- | :----------------------------------- | :----------------------------------------------- |
+| النشر من GitHub      | `crews_dashboards: Read`             | وصول كيان مستودع Git (إذا كان Git RBAC مفعلاً)   |
+| النشر من Zip         | `crews_dashboards: Read`             | يجب تفعيل نشر Zip على مستوى المؤسسة              |
+| البناء في Studio     | `studio_projects: Manage`            | —                                                |
+| تهيئة مفاتيح LLM     | `llm_connections: Manage`            | —                                                |
+| ضبط متغيرات البيئة   | `environment_variables: Manage`      | وصول مستوى الكيان (إذا كان RBAC الكيان مفعلاً)   |
+
+---
+
+## التحكم في الوصول على مستوى الأتمتة (صلاحيات الكيان)
+
+بالإضافة إلى الأدوار على مستوى المؤسسة، يدعم CrewAI صلاحيات دقيقة على مستوى الكيان تقيد الوصول إلى موارد فردية.
+
+### رؤية الأتمتة
+
+تدعم الأتمتات إعدادات رؤية تقيد الوصول حسب المستخدم أو الدور. هذا مفيد لـ:
+
+- الحفاظ على خصوصية الأتمتات الحساسة أو التجريبية
+- إدارة الرؤية عبر الفرق الكبيرة أو المتعاونين الخارجيين
+- اختبار الأتمتات في سياقات معزولة
+
+يمكن تهيئة عمليات النشر كخاصة، مما يعني أن المستخدمين والأدوار المدرجين في القائمة البيضاء فقط سيتمكنون من التفاعل معها.
+
+يمكنك تهيئة التحكم في الوصول على مستوى الأتمتة في Automation → Settings → علامة تبويب Visibility.
+
+<Steps>
+  <Step title="فتح علامة تبويب الرؤية">
+    انتقل إلى <b>Automation → Settings → Visibility</b>.
+  </Step>
+  <Step title="ضبط الرؤية">
+    اختر <b>Private</b> لتقييد الوصول. يحتفظ مالك المؤسسة دائماً
+    بالوصول.
+  </Step>
+  <Step title="القائمة البيضاء للوصول">
+    أضف مستخدمين وأدواراً محددة مسموح لهم بالعرض والتشغيل والوصول
+    إلى السجلات/المقاييس/الإعدادات.
+  </Step>
+  <Step title="الحفظ والتحقق">
+    احفظ التغييرات، ثم تأكد من أن المستخدمين غير المدرجين في القائمة البيضاء لا يمكنهم عرض أو تشغيل
+    الأتمتة.
+  </Step>
+</Steps>
+
+### الرؤية الخاصة: نتائج الوصول
+
+| الإجراء                      | المالك | مستخدم/دور في القائمة البيضاء | غير مدرج في القائمة البيضاء |
+| :--------------------------- | :---- | :---------------------------- | :-------------------------- |
+| عرض الأتمتة                  | ✓     | ✓                             | ✗                           |
+| تشغيل الأتمتة/API            | ✓     | ✓                             | ✗                           |
+| الوصول إلى السجلات/المقاييس/الإعدادات | ✓     | ✓                             | ✗                           |
+
+<Tip>
+  يتمتع مالك المؤسسة دائماً بالوصول. في الوضع الخاص، يمكن فقط للمستخدمين
+  والأدوار المدرجين في القائمة البيضاء العرض والتشغيل والوصول إلى السجلات/المقاييس/الإعدادات.
+</Tip>
+
+<Frame>
+  <img src="/images/enterprise/visibility.png" alt="إعدادات رؤية الأتمتة في CrewAI AMP" />
+</Frame>
+
+### أنواع صلاحيات النشر
+
+عند منح وصول على مستوى الكيان لأتمتة محددة، يمكنك تعيين أنواع الصلاحيات التالية:
+
+| الصلاحية             | ما تسمح به                                          |
+| :------------------- | :-------------------------------------------------- |
+| `run`                | تنفيذ الأتمتة واستخدام API الخاص بها                 |
+| `traces`             | عرض تتبعات التنفيذ والسجلات                          |
+| `manage_settings`    | تعديل، إعادة نشر، استرجاع، أو حذف الأتمتة           |
+| `human_in_the_loop`  | الرد على طلبات الإنسان في الحلقة (HITL)              |
+| `full_access`        | جميع ما سبق                                         |
+
+### RBAC على مستوى الكيان لموارد أخرى
+
+عند تفعيل RBAC على مستوى الكيان، يمكن أيضاً التحكم في الوصول لهذه الموارد حسب المستخدم أو الدور:
+
+| المورد                | يتم التحكم فيه بواسطة              | الوصف                                                          |
+| :-------------------- | :--------------------------------- | :------------------------------------------------------------- |
+| متغيرات البيئة        | علامة ميزة RBAC الكيان             | تقييد أي الأدوار/المستخدمين يمكنهم عرض أو إدارة متغيرات بيئة محددة |
+| اتصالات LLM           | علامة ميزة RBAC الكيان             | تقييد الوصول لتهيئات مزودي LLM محددة                            |
+| مستودعات Git           | إعداد RBAC لمستودعات Git بالمؤسسة  | تقييد أي الأدوار/المستخدمين يمكنهم الوصول لمستودعات متصلة محددة  |
+
+---
+
+## أنماط الأدوار الشائعة
+
+بينما يأتي CrewAI بدوري Owner وMember، تستفيد معظم الفرق من إنشاء أدوار مخصصة. إليك الأنماط الشائعة:
+
+### دور المطور
+
+دور لأعضاء الفريق الذين يبنون وينشرون الأتمتات لكن لا يديرون إعدادات المؤسسة.
+
+| الميزة                    | الصلاحية    |
+| :------------------------ | :---------- |
+| `usage_dashboards`        | Read        |
+| `crews_dashboards`        | Manage      |
+| `invitations`             | Read        |
+| `training_ui`             | Read        |
+| `tools`                   | Manage      |
+| `agents`                  | Manage      |
+| `environment_variables`   | Manage      |
+| `llm_connections`         | Manage      |
+| `default_settings`        | No access   |
+| `organization_settings`   | No access   |
+| `studio_projects`         | Manage      |
+
+### دور المشاهد / أصحاب المصلحة
+
+دور للمعنيين غير التقنيين الذين يحتاجون لمراقبة الأتمتات وعرض النتائج.
+
+| الميزة                    | الصلاحية    |
+| :------------------------ | :---------- |
+| `usage_dashboards`        | Read        |
+| `crews_dashboards`        | Read        |
+| `invitations`             | No access   |
+| `training_ui`             | Read        |
+| `tools`                   | Read        |
+| `agents`                  | Read        |
+| `environment_variables`   | No access   |
+| `llm_connections`         | No access   |
+| `default_settings`        | No access   |
+| `organization_settings`   | No access   |
+| `studio_projects`         | No access   |
+
+### دور مسؤول العمليات / المنصة
+
+دور لمشغلي المنصة الذين يديرون إعدادات البنية التحتية لكن قد لا يبنون الوكلاء.
+
+| الميزة                    | الصلاحية    |
+| :------------------------ | :---------- |
+| `usage_dashboards`        | Manage      |
+| `crews_dashboards`        | Manage      |
+| `invitations`             | Manage      |
+| `training_ui`             | Read        |
+| `tools`                   | Read        |
+| `agents`                  | Read        |
+| `environment_variables`   | Manage      |
+| `llm_connections`         | Manage      |
+| `default_settings`        | Manage      |
+| `organization_settings`   | Read        |
+| `studio_projects`         | No access   |
+
+---
+
+<Card title="تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+  تواصل مع فريق الدعم للمساعدة في أسئلة RBAC.
+</Card>
@@ -0,0 +1,261 @@
+---
+title: الأدوات والتكاملات
+description: "اربط التطبيقات الخارجية وأدِر الأدوات الداخلية التي يمكن لوكلائك استخدامها."
+icon: "wrench"
+mode: "wide"
+---
+
+## نظرة عامة
+
+الأدوات والتكاملات هي المركز الرئيسي لربط تطبيقات الجهات الخارجية وإدارة الأدوات الداخلية التي يمكن لوكلائك استخدامها أثناء التشغيل.
+
+<Frame>
+  ![نظرة عامة على الأدوات والتكاملات](/images/enterprise/crew_connectors.png)
+</Frame>
+
+## استكشاف
+
+<Tabs>
+  <Tab title="التكاملات" icon="plug">
+
+## تطبيقات الوكلاء (التكاملات)
+
+اربط تطبيقات المؤسسات (مثل Gmail وGoogle Drive وHubSpot وSlack) عبر OAuth لتمكين إجراءات الوكلاء.
+
+{" "}
+<Steps>
+  <Step title="الاتصال">
+    انقر على <b>Connect</b> في أحد التطبيقات وأكمل عملية OAuth.
+  </Step>
+  <Step title="التهيئة">
+    عدّل اختيارياً النطاقات والمشغلات وتوفر الإجراءات.
+  </Step>
+  <Step title="الاستخدام في الوكلاء">
+    تصبح الخدمات المتصلة متاحة كأدوات لوكلائك.
+  </Step>
+</Steps>
+
+{" "}
+<Frame>![شبكة التكاملات](/images/enterprise/agent-apps.png)</Frame>
+
+### ربط حسابك
+
+1. انتقل إلى <Link href="https://app.crewai.com/crewai_plus/connectors">Integrations</Link>
+2. انقر على <b>Connect</b> في الخدمة المطلوبة
+3. أكمل تدفق OAuth وامنح النطاقات
+4. انسخ رمز Enterprise من <Link href="https://app.crewai.com/crewai_plus/settings/integrations">Integration Settings</Link>
+
+{" "}
+<Frame>
+  ![رمز Enterprise](/images/enterprise/enterprise_action_auth_token.png)
+</Frame>
+
+### تثبيت أدوات التكامل
+
+لاستخدام التكاملات محلياً، تحتاج إلى تثبيت أحدث حزمة `crewai-tools`.
+
+```bash
+uv add crewai-tools
+```
+
+### إعداد متغيرات البيئة
+
+{" "}
+<Note>
+  لاستخدام التكاملات مع `Agent(apps=[])` يجب تعيين متغير البيئة
+  `CREWAI_PLATFORM_INTEGRATION_TOKEN` برمز Enterprise الخاص بك.
+</Note>
+
+```bash
+export CREWAI_PLATFORM_INTEGRATION_TOKEN="your_enterprise_token"
+```
+
+أو أضفه إلى ملف `.env`:
+
+```
+CREWAI_PLATFORM_INTEGRATION_TOKEN=your_enterprise_token
+```
+
+### مثال على الاستخدام
+
+{" "}
+<Tip>
+  استخدم النهج المبسط الجديد لدمج تطبيقات المؤسسات. ما عليك سوى تحديد
+  التطبيق وإجراءاته مباشرة في تهيئة Agent.
+</Tip>
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create an agent with Gmail capabilities
+email_agent = Agent(
+    role="Email Manager",
+    goal="Manage and organize email communications",
+    backstory="An AI assistant specialized in email management and communication.",
+    apps=['gmail', 'gmail/send_email']  # Using canonical name 'gmail'
+)
+
+# Task to send an email
+email_task = Task(
+    description="Draft and send a follow-up email to john@example.com about the project update",
+    agent=email_agent,
+    expected_output="Confirmation that email was sent successfully"
+)
+
+# Run the task
+crew = Crew(
+    agents=[email_agent],
+    tasks=[email_task]
+)
+
+# Run the crew
+crew.kickoff()
+```
+
+### تصفية الأدوات
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create agent with specific Gmail actions only
+gmail_agent = Agent(
+    role="Gmail Manager",
+    goal="Manage gmail communications and notifications",
+    backstory="An AI assistant that helps coordinate gmail communications.",
+    apps=['gmail/fetch_emails']  # Using canonical name with specific action
+)
+
+notification_task = Task(
+    description="Find the email from john@example.com",
+    agent=gmail_agent,
+    expected_output="Email found from john@example.com"
+)
+
+crew = Crew(
+    agents=[gmail_agent],
+    tasks=[notification_task]
+)
+```
+
+في الطاقم المنشور، يمكنك تحديد الإجراءات المتاحة لكل تكامل من صفحة إعدادات الخدمة.
+
+{" "}
+<Frame>
+  ![تصفية الإجراءات](/images/enterprise/filtering_enterprise_action_tools.png)
+</Frame>
+
+### عمليات النشر المحددة النطاق (مؤسسات متعددة المستخدمين)
+
+يمكنك تحديد نطاق كل تكامل لمستخدم معين. على سبيل المثال، طاقم يتصل بـ Google يمكنه استخدام حساب Gmail لمستخدم محدد.
+
+{" "}
+<Tip>مفيد عندما تحتاج فرق/مستخدمون مختلفون للحفاظ على فصل الوصول إلى البيانات.</Tip>
+
+استخدم `user_bearer_token` لتحديد نطاق المصادقة للمستخدم الطالب. إذا لم يكن المستخدم مسجل الدخول، فلن يستخدم الطاقم التكاملات المتصلة. وإلا فسيعود إلى رمز الحامل الافتراضي المهيأ لعملية النشر.
+
+{" "}
+<Frame>![رمز حامل المستخدم](/images/enterprise/user_bearer_token.png)</Frame>
+
+{" "}
+<div id="catalog"></div>
+### الكتالوج
+
+#### الاتصالات والتعاون
+
+- Gmail — إدارة الرسائل الإلكترونية والمسودات
+- Slack — إشعارات وتنبيهات مساحة العمل
+- Microsoft — تكامل Office 365 وTeams
+
+#### إدارة المشاريع
+
+- Jira — تتبع المشكلات وإدارة المشاريع
+- ClickUp — إدارة المهام والإنتاجية
+- Asana — تنسيق مهام ومشاريع الفريق
+- Notion — إدارة الصفحات وقواعد البيانات
+- Linear — تتبع مشاريع البرمجيات والأخطاء
+- GitHub — إدارة المستودعات والمشكلات
+
+#### إدارة علاقات العملاء
+
+- Salesforce — إدارة حسابات وفرص CRM
+- HubSpot — إدارة خط أنابيب المبيعات وجهات الاتصال
+- Zendesk — إدارة تذاكر دعم العملاء
+
+#### الأعمال والمالية
+
+- Stripe — معالجة المدفوعات وإدارة العملاء
+- Shopify — إدارة متجر ومنتجات التجارة الإلكترونية
+
+#### الإنتاجية والتخزين
+
+- Google Sheets — مزامنة بيانات جداول البيانات
+- Google Calendar — إدارة الأحداث والجداول
+- Box — تخزين الملفات وإدارة المستندات
+
+...والمزيد قادم!
+
+  </Tab>
+  <Tab title="الأدوات الداخلية" icon="toolbox">
+
+## الأدوات الداخلية
+
+أنشئ أدوات مخصصة محلياً، وانشرها في مستودع أدوات CrewAI AMP واستخدمها في وكلائك.
+
+{" "}
+<Tip>
+  قبل تشغيل الأوامر أدناه، تأكد من تسجيل الدخول إلى حساب CrewAI AMP
+  بتشغيل هذا الأمر: ```bash crewai login ```
+</Tip>
+
+{" "}
+<Frame>
+  ![تفاصيل الأداة الداخلية](/images/enterprise/tools-integrations-internal.png)
+</Frame>
+
+{" "}
+<Steps>
+  <Step title="الإنشاء">
+    أنشئ أداة جديدة محلياً. ```bash crewai tool create your-tool ```
+  </Step>
+  <Step title="النشر">
+    انشر الأداة في مستودع أدوات CrewAI AMP. ```bash crewai tool
+    publish ```
+  </Step>
+  <Step title="التثبيت">
+    ثبّت الأداة من مستودع أدوات CrewAI AMP. ```bash crewai tool
+    install your-tool ```
+  </Step>
+</Steps>
+
+الإدارة:
+
+- الاسم والوصف
+- الرؤية (خاص / عام)
+- متغيرات البيئة المطلوبة
+- سجل الإصدارات والتنزيلات
+- وصول الفرق والأدوار
+
+{" "}
+<Frame>![تفاصيل الأداة الداخلية](/images/enterprise/tool-configs.png)</Frame>
+
+  </Tab>
+</Tabs>
+
+## ذو صلة
+
+<CardGroup cols={2}>
+  <Card
+    title="مستودع الأدوات"
+    href="/ar/enterprise/guides/tool-repository#tool-repository"
+    icon="toolbox"
+  >
+    أنشئ وانشر وأدِر إصدارات الأدوات المخصصة لمؤسستك.
+  </Card>
+  <Card
+    title="أتمتة Webhook"
+    href="/ar/enterprise/guides/webhook-automation"
+    icon="bolt"
+  >
+    أتمت سير العمل وتكامل مع المنصات والخدمات الخارجية.
+  </Card>
+</CardGroup>
@@ -0,0 +1,148 @@
+---
+title: التتبعات
+description: "استخدام التتبعات لمراقبة طواقمك"
+icon: "timeline"
+mode: "wide"
+---
+
+## نظرة عامة
+
+توفر التتبعات رؤية شاملة لعمليات تنفيذ طواقمك، مما يساعدك على مراقبة الأداء وتصحيح الأخطاء وتحسين سير عمل وكلاء الذكاء الاصطناعي.
+
+## ما هي التتبعات؟
+
+التتبعات في CrewAI AMP هي سجلات تنفيذ مفصلة تلتقط كل جانب من جوانب عمل طاقمك، من المدخلات الأولية إلى المخرجات النهائية. تسجل:
+
+- أفكار الوكلاء واستدلالاتهم
+- تفاصيل تنفيذ المهام
+- استخدام الأدوات ومخرجاتها
+- مقاييس استهلاك الرموز
+- أوقات التنفيذ
+- تقديرات التكلفة
+
+<Frame>![نظرة عامة على التتبعات](/images/enterprise/traces-overview.png)</Frame>
+
+## الوصول إلى التتبعات
+
+<Steps>
+  <Step title="الانتقال إلى علامة تبويب التتبعات">
+    في لوحة تحكم CrewAI AMP، انقر على **Traces** لعرض جميع سجلات التنفيذ.
+  </Step>
+
+  <Step title="اختيار عملية تنفيذ">
+    سترى قائمة بجميع عمليات تنفيذ الطاقم، مرتبة حسب التاريخ. انقر على أي عملية تنفيذ لعرض تتبعها المفصل.
+  </Step>
+</Steps>
+
+## فهم واجهة التتبع
+
+تنقسم واجهة التتبع إلى عدة أقسام، يقدم كل منها رؤى مختلفة حول تنفيذ طاقمك:
+
+### 1. ملخص التنفيذ
+
+يعرض القسم العلوي مقاييس عالية المستوى حول التنفيذ:
+
+- **إجمالي الرموز**: عدد الرموز المستهلكة عبر جميع المهام
+- **رموز الطلب**: الرموز المستخدمة في الطلبات إلى LLM
+- **رموز الإكمال**: الرموز المُنشأة في استجابات LLM
+- **الطلبات**: عدد استدعاءات API المُجراة
+- **وقت التنفيذ**: المدة الإجمالية لتشغيل الطاقم
+- **التكلفة المقدرة**: التكلفة التقريبية بناءً على استخدام الرموز
+
+<Frame>![ملخص التنفيذ](/images/enterprise/trace-summary.png)</Frame>
+
+### 2. المهام والوكلاء
+
+يعرض هذا القسم جميع المهام والوكلاء الذين كانوا جزءاً من تنفيذ الطاقم:
+
+- اسم المهمة وتعيين الوكيل
+- الوكلاء ونماذج LLM المستخدمة لكل مهمة
+- الحالة (مكتملة/فاشلة)
+- وقت التنفيذ الفردي للمهمة
+
+<Frame>![قائمة المهام](/images/enterprise/trace-tasks.png)</Frame>
+
+### 3. المخرجات النهائية
+
+يعرض النتيجة النهائية التي أنتجها الطاقم بعد اكتمال جميع المهام.
+
+<Frame>![المخرجات النهائية](/images/enterprise/final-output.png)</Frame>
+
+### 4. الجدول الزمني للتنفيذ
+
+تمثيل مرئي لوقت بدء وانتهاء كل مهمة، يساعدك على تحديد نقاط الاختناق أو أنماط التنفيذ المتوازي.
+
+<Frame>![الجدول الزمني للتنفيذ](/images/enterprise/trace-timeline.png)</Frame>
+
+### 5. عرض المهمة المفصل
+
+عند النقر على مهمة محددة في الجدول الزمني أو قائمة المهام، سترى:
+
+<Frame>![عرض المهمة المفصل](/images/enterprise/trace-detailed-task.png)</Frame>
+
+- **مفتاح المهمة**: معرّف فريد للمهمة
+- **معرّف المهمة**: معرّف تقني في النظام
+- **الحالة**: الحالة الحالية (مكتملة/قيد التشغيل/فاشلة)
+- **الوكيل**: الوكيل الذي نفّذ المهمة
+- **LLM**: نموذج اللغة المستخدم لهذه المهمة
+- **وقت البدء/الانتهاء**: متى بدأت المهمة واكتملت
+- **وقت التنفيذ**: مدة هذه المهمة المحددة
+- **وصف المهمة**: ما طُلب من الوكيل تنفيذه
+- **المخرجات المتوقعة**: تنسيق المخرجات المطلوب
+- **المدخلات**: أي مدخلات مقدمة لهذه المهمة من مهام سابقة
+- **المخرجات**: النتيجة الفعلية التي أنتجها الوكيل
+
+## استخدام التتبعات لتصحيح الأخطاء
+
+التتبعات لا تقدر بثمن لاستكشاف المشكلات في طواقمك:
+
+<Steps>
+  <Step title="تحديد نقاط الفشل">
+    عندما لا ينتج تنفيذ الطاقم النتائج المتوقعة، افحص التتبع لمعرفة أين حدث الخطأ. ابحث عن:
+
+    - المهام الفاشلة
+    - قرارات الوكيل غير المتوقعة
+    - أخطاء استخدام الأدوات
+    - التعليمات المُساء فهمها
+
+    <Frame>
+      ![نقاط الفشل](/images/enterprise/failure.png)
+    </Frame>
+
+  </Step>
+
+  <Step title="تحسين الأداء">
+    استخدم مقاييس التنفيذ لتحديد نقاط اختناق الأداء:
+
+    - المهام التي استغرقت وقتاً أطول من المتوقع
+    - الاستخدام المفرط للرموز
+    - عمليات الأدوات المكررة
+    - استدعاءات API غير الضرورية
+
+  </Step>
+
+  <Step title="تحسين كفاءة التكلفة">
+    حلل استخدام الرموز وتقديرات التكلفة لتحسين كفاءة طاقمك:
+
+    - فكّر في استخدام نماذج أصغر للمهام الأبسط
+    - صقل الطلبات لتكون أكثر إيجازاً
+    - خزّن المعلومات المُوصول إليها بشكل متكرر مؤقتاً
+    - نظّم المهام لتقليل العمليات المكررة
+
+  </Step>
+</Steps>
+
+## الأداء والتجميع
+
+يجمّع CrewAI تحميلات التتبع لتقليل العبء في عمليات التشغيل ذات الحجم الكبير:
+
+- يقوم TraceBatchManager بتخزين الأحداث مؤقتاً وإرسالها في دفعات عبر عميل Plus API
+- يقلل حركة الشبكة ويحسّن الموثوقية في الاتصالات غير المستقرة
+- يُفعّل تلقائياً في مستمع التتبع الافتراضي؛ لا حاجة لتهيئة
+
+يوفر ذلك تتبعاً أكثر استقراراً تحت الحمل مع الحفاظ على بيانات القياس المفصلة للمهام/الوكلاء.
+
+<Card title="تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+  تواصل مع فريق الدعم للمساعدة في تحليل التتبعات أو أي ميزات أخرى في
+  CrewAI AMP.
+</Card>
@@ -0,0 +1,172 @@
+---
+title: بث Webhook
+description: "استخدام بث Webhook لإرسال الأحداث إلى webhook الخاص بك"
+icon: "webhook"
+mode: "wide"
+---
+
+## نظرة عامة
+
+يتيح لك بث أحداث Enterprise تلقي تحديثات webhook في الوقت الفعلي حول طواقمك وتدفقاتك المنشورة على CrewAI AMP، مثل استدعاءات النماذج واستخدام الأدوات وخطوات التدفق.
+
+## الاستخدام
+
+عند استخدام Kickoff API، أضف كائن `webhooks` إلى طلبك، على سبيل المثال:
+
+```json
+{
+  "inputs": { "foo": "bar" },
+  "webhooks": {
+    "events": ["crew_kickoff_started", "llm_call_started"],
+    "url": "https://your.endpoint/webhook",
+    "realtime": false,
+    "authentication": {
+      "strategy": "bearer",
+      "token": "my-secret-token"
+    }
+  }
+}
+```
+
+إذا تم تعيين `realtime` إلى `true`، يتم تسليم كل حدث بشكل فردي وفوري، على حساب أداء الطاقم/التدفق.
+
+## تنسيق Webhook
+
+يرسل كل webhook قائمة بالأحداث:
+
+```json
+{
+  "events": [
+    {
+      "id": "event-id",
+      "execution_id": "crew-run-id",
+      "timestamp": "2025-02-16T10:58:44.965Z",
+      "type": "llm_call_started",
+      "data": {
+        "model": "gpt-4",
+        "messages": [
+          { "role": "system", "content": "You are an assistant." },
+          { "role": "user", "content": "Summarize this article." }
+        ]
+      }
+    }
+  ]
+}
+```
+
+يختلف هيكل كائن `data` حسب نوع الحدث. راجع [قائمة الأحداث](https://github.com/crewAIInc/crewAI/tree/main/lib/crewai/src/crewai/events/types) على GitHub.
+
+نظراً لأن الطلبات تُرسل عبر HTTP، لا يمكن ضمان ترتيب الأحداث. إذا كنت تحتاج الترتيب، استخدم حقل `timestamp`.
+
+## الأحداث المدعومة
+
+يدعم CrewAI كلاً من أحداث النظام والأحداث المخصصة في بث أحداث Enterprise. تُرسل هذه الأحداث إلى نقطة نهاية webhook المُهيأة أثناء تنفيذ الطاقم والتدفق.
+
+### أحداث التدفق:
+
+- `flow_created`
+- `flow_started`
+- `flow_finished`
+- `flow_plot`
+- `method_execution_started`
+- `method_execution_finished`
+- `method_execution_failed`
+
+### أحداث الوكيل:
+
+- `agent_execution_started`
+- `agent_execution_completed`
+- `agent_execution_error`
+- `lite_agent_execution_started`
+- `lite_agent_execution_completed`
+- `lite_agent_execution_error`
+- `agent_logs_started`
+- `agent_logs_execution`
+- `agent_evaluation_started`
+- `agent_evaluation_completed`
+- `agent_evaluation_failed`
+
+### أحداث الطاقم:
+
+- `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`
+
+### أحداث المهام:
+
+- `task_started`
+- `task_completed`
+- `task_failed`
+- `task_evaluation`
+
+### أحداث استخدام الأدوات:
+
+- `tool_usage_started`
+- `tool_usage_finished`
+- `tool_usage_error`
+- `tool_validate_input_error`
+- `tool_selection_error`
+- `tool_execution_error`
+
+### أحداث LLM:
+
+- `llm_call_started`
+- `llm_call_completed`
+- `llm_call_failed`
+- `llm_stream_chunk`
+
+### أحداث حواجز LLM:
+
+- `llm_guardrail_started`
+- `llm_guardrail_completed`
+
+### أحداث الذاكرة:
+
+- `memory_query_started`
+- `memory_query_completed`
+- `memory_query_failed`
+- `memory_save_started`
+- `memory_save_completed`
+- `memory_save_failed`
+- `memory_retrieval_started`
+- `memory_retrieval_completed`
+
+### أحداث المعرفة:
+
+- `knowledge_search_query_started`
+- `knowledge_search_query_completed`
+- `knowledge_search_query_failed`
+- `knowledge_query_started`
+- `knowledge_query_completed`
+- `knowledge_query_failed`
+
+### أحداث الاستدلال:
+
+- `agent_reasoning_started`
+- `agent_reasoning_completed`
+- `agent_reasoning_failed`
+
+تتطابق أسماء الأحداث مع ناقل الأحداث الداخلي. راجع GitHub للقائمة الكاملة للأحداث.
+
+يمكنك إصدار أحداثك المخصصة الخاصة، وسيتم تسليمها عبر تدفق webhook جنباً إلى جنب مع أحداث النظام.
+
+<CardGroup>
+  <Card
+    title="GitHub"
+    icon="github"
+    href="https://github.com/crewAIInc/crewAI/tree/main/src/crewai/utilities/events"
+  >
+    القائمة الكاملة للأحداث
+  </Card>
+  <Card title="تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+    تواصل مع فريق الدعم للمساعدة في تكامل webhook أو
+    استكشاف الأخطاء.
+  </Card>
+</CardGroup>
@@ -0,0 +1,321 @@
+---
+title: "نظرة عامة على المشغلات"
+description: "فهم كيفية عمل مشغلات CrewAI AMP وكيفية إدارتها وأين تجد أدلة التكامل الخاصة بكل خدمة"
+icon: "face-smile"
+mode: "wide"
+---
+
+تربط مشغلات CrewAI AMP أتمتاتك بالأحداث الفورية عبر الأدوات التي تستخدمها فرقك بالفعل. بدلاً من الاستعلام المتكرر عن الأنظمة أو الاعتماد على التشغيل اليدوي، تستمع المشغلات للتغييرات — رسائل بريد إلكتروني جديدة، تحديثات التقويم، تغييرات حالة CRM — وتطلق فوراً الطاقم أو التدفق الذي تحدده.
+
+<Frame>
+  ![نظرة عامة على مشغلات الأتمتة](/images/enterprise/crew_connectors.png)
+</Frame>
+
+### أدلة التكامل
+
+تقدم الأدلة المفصلة شرحاً لعملية الإعداد وأمثلة على سير العمل لكل تكامل:
+
+<CardGroup cols={2}>
+  <Card title="مشغل Gmail" icon="envelope">
+    <a href="/ar/enterprise/guides/gmail-trigger">فعّل الطواقم عند وصول رسائل بريد إلكتروني أو تحديث سلاسل المحادثات.</a>
+  </Card>
+
+{" "}
+<Card title="مشغل Google Calendar" icon="calendar-days">
+  <a href="/ar/enterprise/guides/google-calendar-trigger">
+    استجب لأحداث التقويم عند إنشائها أو تحديثها أو إلغائها.
+  </a>
+</Card>
+
+{" "}
+<Card title="مشغل Google Drive" icon="folder-open">
+  <a href="/ar/enterprise/guides/google-drive-trigger">
+    تعامل مع تحميلات وتعديلات وحذف ملفات Drive.
+  </a>
+</Card>
+
+{" "}
+<Card title="مشغل Outlook" icon="envelope-open">
+  <a href="/ar/enterprise/guides/outlook-trigger">
+    أتمت الاستجابات لرسائل Outlook الجديدة وتحديثات التقويم.
+  </a>
+</Card>
+
+{" "}
+<Card title="مشغل OneDrive" icon="cloud">
+  <a href="/ar/enterprise/guides/onedrive-trigger">
+    راقب نشاط الملفات وتغييرات المشاركة في OneDrive.
+  </a>
+</Card>
+
+{" "}
+<Card title="مشغل Microsoft Teams" icon="comments">
+  <a href="/ar/enterprise/guides/microsoft-teams-trigger">
+    ابدأ سير العمل عند إنشاء محادثات Teams جديدة.
+  </a>
+</Card>
+
+{" "}
+<Card title="مشغل HubSpot" icon="hubspot">
+  <a href="/ar/enterprise/guides/hubspot-trigger">
+    أطلق الأتمتات من سير عمل HubSpot وأحداث دورة الحياة.
+  </a>
+</Card>
+
+{" "}
+<Card title="مشغل Salesforce" icon="salesforce">
+  <a href="/ar/enterprise/guides/salesforce-trigger">
+    اربط عمليات Salesforce بـ CrewAI لأتمتة CRM.
+  </a>
+</Card>
+
+{" "}
+<Card title="مشغل Slack" icon="slack">
+  <a href="/ar/enterprise/guides/slack-trigger">
+    ابدأ الطواقم مباشرة من أوامر Slack.
+  </a>
+</Card>
+
+  <Card title="مشغل Zapier" icon="bolt">
+    <a href="/ar/enterprise/guides/zapier-trigger">اربط CrewAI بآلاف التطبيقات المدعومة من Zapier.</a>
+  </Card>
+</CardGroup>
+
+## قدرات المشغلات
+
+مع المشغلات، يمكنك:
+
+- **الاستجابة للأحداث الفورية** - تنفيذ سير العمل تلقائياً عند استيفاء شروط محددة
+- **التكامل مع الأنظمة الخارجية** - الاتصال بمنصات مثل Gmail وOutlook وOneDrive وJIRA وSlack وStripe والمزيد
+- **توسيع نطاق الأتمتة** - التعامل مع أحداث كبيرة الحجم دون تدخل يدوي
+- **الحفاظ على السياق** - الوصول إلى بيانات المشغل داخل طواقمك وتدفقاتك
+
+## إدارة المشغلات
+
+### عرض المشغلات المتاحة
+
+للوصول إلى مشغلات الأتمتة وإدارتها:
+
+1. انتقل إلى عملية النشر في لوحة تحكم CrewAI
+2. انقر على علامة تبويب **Triggers** لعرض جميع تكاملات المشغلات المتاحة
+
+<Frame caption="مثال على مشغلات الأتمتة المتاحة لنشر Gmail">
+  <img
+    src="/images/enterprise/list-available-triggers.png"
+    alt="قائمة مشغلات الأتمتة المتاحة"
+  />
+</Frame>
+
+يعرض هذا العرض جميع تكاملات المشغلات المتاحة لعملية النشر، مع حالة الاتصال الحالية.
+
+### تفعيل وتعطيل المشغلات
+
+يمكن تفعيل أو تعطيل كل مشغل بسهولة باستخدام مفتاح التبديل:
+
+<Frame caption="تفعيل أو تعطيل المشغلات بالتبديل">
+  <img
+    src="/images/enterprise/trigger-selected.png"
+    alt="تفعيل أو تعطيل المشغلات بالتبديل"
+  />
+</Frame>
+
+- **مُفعّل (تبديل أزرق)**: المشغل نشط وسينفذ عملية النشر تلقائياً عند حدوث الأحداث المحددة
+- **مُعطّل (تبديل رمادي)**: المشغل غير نشط ولن يستجيب للأحداث
+
+انقر ببساطة على التبديل لتغيير حالة المشغل. تسري التغييرات فوراً.
+
+### مراقبة عمليات تنفيذ المشغلات
+
+تتبع أداء وسجل عمليات التنفيذ المُشغّلة:
+
+<Frame caption="قائمة عمليات التنفيذ المُشغّلة بواسطة الأتمتة">
+  <img
+    src="/images/enterprise/list-executions.png"
+    alt="قائمة عمليات التنفيذ المُشغّلة بواسطة الأتمتة"
+  />
+</Frame>
+
+## بناء أتمتات مدفوعة بالمشغلات
+
+قبل بناء أتمتتك، من المفيد فهم هيكل حمولات المشغلات التي ستتلقاها طواقمك وتدفقاتك.
+
+### قائمة فحص إعداد المشغل
+
+قبل ربط مشغل بالإنتاج، تأكد من:
+
+- ربط التكامل تحت **Tools & Integrations** وإكمال خطوات OAuth أو مفتاح API
+- تفعيل تبديل المشغل في عملية النشر التي يجب أن تستجيب للأحداث
+- توفير متغيرات البيئة المطلوبة (رموز API، معرّفات المستأجر، الأسرار المشتركة)
+- إنشاء أو تحديث المهام التي يمكنها تحليل الحمولة الواردة في أول مهمة طاقم أو خطوة تدفق
+- تحديد ما إذا كنت ستمرر سياق المشغل تلقائياً باستخدام `allow_crewai_trigger_context`
+- إعداد المراقبة — سجلات webhook وسجل تنفيذ CrewAI والتنبيهات الخارجية الاختيارية
+
+### اختبار المشغلات محلياً باستخدام CLI
+
+يوفر CrewAI CLI أوامر قوية لمساعدتك في تطوير واختبار الأتمتات المدفوعة بالمشغلات دون النشر في الإنتاج.
+
+#### عرض المشغلات المتاحة
+
+اعرض جميع المشغلات المتاحة للتكاملات المتصلة:
+
+```bash
+crewai triggers list
+```
+
+يعرض هذا الأمر جميع المشغلات المتاحة بناءً على تكاملاتك المتصلة، ويظهر:
+
+- اسم التكامل وحالة الاتصال
+- أنواع المشغلات المتاحة
+- أسماء وأوصاف المشغلات
+
+#### محاكاة تنفيذ المشغل
+
+اختبر طاقمك بحمولات مشغل واقعية قبل النشر:
+
+```bash
+crewai triggers run <trigger_name>
+```
+
+على سبيل المثال:
+
+```bash
+crewai triggers run microsoft_onedrive/file_changed
+```
+
+يقوم هذا الأمر بـ:
+
+- تنفيذ طاقمك محلياً
+- تمرير حمولة مشغل كاملة وواقعية
+- محاكاة كيفية استدعاء طاقمك في الإنتاج بالضبط
+
+<Warning>
+  **ملاحظات تطوير مهمة:**
+  - استخدم `crewai triggers run <trigger>` لمحاكاة تنفيذ المشغل أثناء التطوير
+  - استخدام `crewai run` لن يحاكي استدعاءات المشغل ولن يمرر حمولة المشغل
+  - بعد النشر، سيتم تنفيذ طاقمك بحمولة المشغل الفعلية
+  - إذا كان طاقمك يتوقع معاملات غير موجودة في حمولة المشغل، فقد يفشل التنفيذ
+</Warning>
+
+### المشغلات مع الطاقم
+
+تعمل تعريفات طاقمك الحالية بسلاسة مع المشغلات، تحتاج فقط إلى مهمة لتحليل الحمولة المستلمة:
+
+```python
+@CrewBase
+class MyAutomatedCrew:
+    @agent
+    def researcher(self) -> Agent:
+        return Agent(
+            config=self.agents_config['researcher'],
+        )
+
+    @task
+    def parse_trigger_payload(self) -> Task:
+        return Task(
+            config=self.tasks_config['parse_trigger_payload'],
+            agent=self.researcher(),
+        )
+
+    @task
+    def analyze_trigger_content(self) -> Task:
+        return Task(
+            config=self.tasks_config['analyze_trigger_data'],
+            agent=self.researcher(),
+        )
+```
+
+سيتلقى الطاقم تلقائياً حمولة المشغل ويمكنه الوصول إليها عبر آليات سياق CrewAI القياسية.
+
+<Note>
+  يمكن أن تتضمن مدخلات الطاقم والتدفق `crewai_trigger_payload`. يحقن CrewAI
+  هذه الحمولة تلقائياً: - المهام: تُلحق بوصف المهمة الأولى افتراضياً ("Trigger Payload: {crewai_trigger_payload}") - التحكم
+  عبر `allow_crewai_trigger_context`: عيّن `True` للحقن دائماً، `False` لعدم
+  الحقن أبداً - التدفقات: أي دالة `@start()` تقبل معامل
+  `crewai_trigger_payload` ستستلمه
+</Note>
+
+### التكامل مع التدفقات
+
+للتدفقات، لديك تحكم أكبر في كيفية التعامل مع بيانات المشغل:
+
+#### الوصول إلى حمولة المشغل
+
+جميع دوال `@start()` في تدفقاتك ستقبل معاملاً إضافياً يسمى `crewai_trigger_payload`:
+
+```python
+from crewai.flow import Flow, start, listen
+
+class MyAutomatedFlow(Flow):
+    @start()
+    def handle_trigger(self, crewai_trigger_payload: dict = None):
+        """
+        This start method can receive trigger data
+        """
+        if crewai_trigger_payload:
+            # Process the trigger data
+            trigger_id = crewai_trigger_payload.get('id')
+            event_data = crewai_trigger_payload.get('payload', {})
+
+            # Store in flow state for use by other methods
+            self.state.trigger_id = trigger_id
+            self.state.trigger_type = event_data
+
+            return event_data
+
+        # Handle manual execution
+        return None
+
+    @listen(handle_trigger)
+    def process_data(self, trigger_data):
+        """
+        Process the data from the trigger
+        """
+        # ... process the trigger
+```
+
+#### تشغيل الطواقم من التدفقات
+
+عند تشغيل طاقم داخل تدفق تم تشغيله بمشغل، مرر حمولة المشغل كما هي:
+
+```python
+@start()
+def delegate_to_crew(self, crewai_trigger_payload: dict = None):
+    """
+    Delegate processing to a specialized crew
+    """
+    crew = MySpecializedCrew()
+
+    # Pass the trigger payload to the crew
+    result = crew.crew().kickoff(
+        inputs={
+            'a_custom_parameter': "custom_value",
+            'crewai_trigger_payload': crewai_trigger_payload
+        },
+    )
+
+    return result
+```
+
+## استكشاف الأخطاء وإصلاحها
+
+**المشغل لا يعمل:**
+
+- تحقق من أن المشغل مُفعّل في علامة تبويب Triggers الخاصة بعملية النشر
+- تحقق من حالة اتصال التكامل تحت Tools & Integrations
+- تأكد من تهيئة جميع متغيرات البيئة المطلوبة بشكل صحيح
+
+**فشل التنفيذ:**
+
+- تحقق من سجلات التنفيذ لتفاصيل الأخطاء
+- استخدم `crewai triggers run <trigger_name>` للاختبار محلياً ورؤية هيكل الحمولة بالضبط
+- تحقق من أن طاقمك يمكنه التعامل مع معامل `crewai_trigger_payload`
+- تأكد من أن طاقمك لا يتوقع معاملات غير مضمنة في حمولة المشغل
+
+**مشاكل التطوير:**
+
+- اختبر دائماً باستخدام `crewai triggers run <trigger>` قبل النشر لرؤية الحمولة الكاملة
+- تذكر أن `crewai run` لا يحاكي استدعاءات المشغل — استخدم `crewai triggers run` بدلاً من ذلك
+- استخدم `crewai triggers list` للتحقق من المشغلات المتاحة لتكاملاتك المتصلة
+- بعد النشر، سيتلقى طاقمك حمولة المشغل الفعلية، لذا اختبر بدقة محلياً أولاً
+
+تحوّل مشغلات الأتمتة عمليات نشر CrewAI إلى أنظمة استجابة مدفوعة بالأحداث يمكنها التكامل بسلاسة مع عمليات عملك وأدواتك الحالية.
@@ -0,0 +1,54 @@
+---
+title: "إعداد Azure OpenAI"
+description: "تهيئة Azure OpenAI مع Crew Studio لاتصالات LLM المؤسسية"
+icon: "microsoft"
+mode: "wide"
+---
+
+يرشدك هذا الدليل خلال ربط Azure OpenAI مع Crew Studio لعمليات الذكاء الاصطناعي المؤسسية السلسة.
+
+## عملية الإعداد
+
+<Steps>
+    <Step title="الوصول إلى Azure AI Foundry">
+        1. في Azure، انتقل إلى [Azure AI Foundry](https://ai.azure.com/) > اختر نشر Azure OpenAI الخاص بك.
+        2. في القائمة اليسرى، انقر على `Deployments`. إذا لم يكن لديك نشر، أنشئ واحداً بالنموذج المطلوب.
+        3. بمجرد الإنشاء، اختر النشر وحدد موقع `Target URI` و`Key` على الجانب الأيمن من الصفحة. أبقِ هذه الصفحة مفتوحة، حيث ستحتاج هذه المعلومات.
+            <Frame>
+                <img src="/images/enterprise/azure-openai-studio.png" alt="Azure AI Foundry" />
+            </Frame>
+    </Step>
+
+    <Step title="تهيئة اتصال CrewAI AMP">
+        4. في علامة تبويب أخرى، افتح `CrewAI AMP > LLM Connections`. سمِّ اتصال LLM، واختر Azure كمزود، واختر نفس النموذج الذي اخترته في Azure.
+        5. في نفس الصفحة، أضف متغيرات البيئة من الخطوة 3:
+            - واحد بالاسم `AZURE_DEPLOYMENT_TARGET_URL` (باستخدام Target URI). يجب أن يبدو الرابط هكذا: https://your-deployment.openai.azure.com/openai/deployments/gpt-4o/chat/completions?api-version=2024-08-01-preview
+            - آخر بالاسم `AZURE_API_KEY` (باستخدام Key).
+        6. انقر على `Add Connection` لحفظ اتصال LLM.
+    </Step>
+
+    <Step title="ضبط التهيئة الافتراضية">
+        7. في `CrewAI AMP > Settings > Defaults > Crew Studio LLM Settings`، عيّن اتصال LLM والنموذج الجديدين كافتراضيين.
+    </Step>
+
+    <Step title="تهيئة الوصول إلى الشبكة">
+        8. تأكد من إعدادات الوصول إلى الشبكة:
+            - في Azure، انتقل إلى `Azure OpenAI > اختر النشر`.
+            - انتقل إلى `Resource Management > Networking`.
+            - تأكد من تفعيل `Allow access from all networks`. إذا كان هذا الإعداد مقيداً، فقد يُحظر وصول CrewAI إلى نقطة نهاية Azure OpenAI.
+    </Step>
+
+</Steps>
+
+## التحقق
+
+أنت جاهز! سيستخدم Crew Studio الآن اتصال Azure OpenAI الخاص بك. اختبر الاتصال بإنشاء طاقم أو مهمة بسيطة للتأكد من أن كل شيء يعمل بشكل صحيح.
+
+## استكشاف الأخطاء وإصلاحها
+
+إذا واجهت مشكلات:
+
+- تحقق من أن تنسيق Target URI يتطابق مع النمط المتوقع
+- تحقق من صحة مفتاح API وأنه يملك الصلاحيات المناسبة
+- تأكد من تهيئة الوصول إلى الشبكة للسماح باتصالات CrewAI
+- تأكد من أن نموذج النشر يتطابق مع ما هيأته في CrewAI
@@ -0,0 +1,48 @@
+---
+title: "بناء طاقم"
+description: "الطاقم هو مجموعة من الوكلاء الذين يعملون معاً لإتمام مهمة."
+icon: "people-arrows"
+mode: "wide"
+---
+
+## نظرة عامة
+
+يبسّط [CrewAI AMP](https://app.crewai.com) عملية **إنشاء** و**نشر** و**إدارة** وكلاء الذكاء الاصطناعي في بيئات الإنتاج.
+
+## البدء
+
+<iframe
+  className="w-full aspect-video rounded-xl"
+  src="https://www.youtube.com/embed/-kSOTtYzgEw"
+  title="بناء الطواقم باستخدام CrewAI CLI"
+  frameBorder="0"
+  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+  allowFullScreen
+></iframe>
+
+### التثبيت والإعداد
+
+<Card
+  title="اتبع دليل التثبيت القياسي"
+  icon="wrench"
+  href="/ar/installation"
+>
+  اتبع دليل التثبيت القياسي لإعداد CrewAI CLI وإنشاء مشروعك
+  الأول.
+</Card>
+
+### بناء طاقمك
+
+<Card title="دليل البدء السريع" icon="rocket" href="/ar/quickstart">
+  اتبع دليل البدء السريع لإنشاء أول طاقم وكلاء باستخدام تهيئة
+  YAML.
+</Card>
+
+## الدعم والموارد
+
+للدعم الخاص بالمؤسسات أو الأسئلة، تواصل مع فريق الدعم المخصص على [support@crewai.com](mailto:support@crewai.com).
+
+<Card title="حجز عرض توضيحي" icon="calendar" href="mailto:support@crewai.com">
+  احجز وقتاً مع فريقنا لمعرفة المزيد عن ميزات Enterprise وكيف يمكنها
+  إفادة مؤسستك.
+</Card>
@@ -0,0 +1,39 @@
+---
+title: "تصدير OpenTelemetry"
+description: "تصدير التتبعات والسجلات من عمليات نشر CrewAI AMP إلى مجمّع OpenTelemetry الخاص بك"
+icon: "magnifying-glass-chart"
+mode: "wide"
+---
+
+يمكن لـ CrewAI AMP تصدير **التتبعات** و**السجلات** من OpenTelemetry من عمليات النشر مباشرة إلى مجمّعك الخاص. يتيح لك ذلك مراقبة أداء الوكلاء وتتبع استدعاءات LLM وتصحيح الأخطاء باستخدام مجموعة المراقبة الحالية.
+
+تتبع بيانات القياس [اتفاقيات OpenTelemetry GenAI الدلالية](https://opentelemetry.io/docs/specs/semconv/gen-ai/) بالإضافة إلى سمات خاصة بـ CrewAI.
+
+## المتطلبات المسبقة
+
+<CardGroup cols={2}>
+  <Card title="حساب CrewAI AMP" icon="users">
+    يجب أن يكون لدى مؤسستك حساب CrewAI AMP نشط.
+  </Card>
+  <Card title="مجمّع OpenTelemetry" icon="server">
+    تحتاج إلى نقطة نهاية مجمّع متوافقة مع OpenTelemetry (مثل OTel Collector الخاص بك أو Datadog أو Grafana أو أي واجهة خلفية متوافقة مع OTLP).
+  </Card>
+</CardGroup>
+
+## إعداد مجمّع
+
+1. في CrewAI AMP، انتقل إلى **Settings** > **OpenTelemetry Collectors**.
+2. انقر على **Add Collector**.
+3. اختر نوع التكامل — **OpenTelemetry Traces** أو **OpenTelemetry Logs**.
+4. هيّئ الاتصال:
+   - **Endpoint** — نقطة نهاية OTLP لمجمّعك (مثل `https://otel-collector.example.com:4317`).
+   - **Service Name** — اسم لتعريف هذه الخدمة في منصة المراقبة.
+   - **Custom Headers** *(اختياري)* — أضف رؤوس المصادقة أو التوجيه كأزواج مفتاح-قيمة.
+   - **Certificate** *(اختياري)* — قدم شهادة TLS إذا كان مجمّعك يتطلبها.
+5. انقر على **Save**.
+
+<Frame>![تهيئة مجمّع OpenTelemetry](/images/crewai-otel-collector-config.png)</Frame>
+
+<Tip>
+  يمكنك إضافة مجمّعات متعددة — على سبيل المثال، واحد للتتبعات وآخر للسجلات، أو الإرسال إلى واجهات خلفية مختلفة لأغراض مختلفة.
+</Tip>
@@ -0,0 +1,136 @@
+---
+title: "خوادم MCP المخصصة"
+description: "اربط خوادم MCP الخاصة بك بـ CrewAI AMP مع وصول عام أو مصادقة بمفتاح API أو OAuth 2.0"
+icon: "plug"
+mode: "wide"
+---
+
+يدعم CrewAI AMP الاتصال بأي خادم MCP يُنفّذ [Model Context Protocol](https://modelcontextprotocol.io/). يمكنك إحضار خوادم عامة لا تتطلب مصادقة، وخوادم محمية بمفتاح API أو رمز حامل، وخوادم تستخدم OAuth 2.0 للوصول المفوّض الآمن.
+
+## المتطلبات المسبقة
+
+<CardGroup cols={2}>
+  <Card title="حساب CrewAI AMP" icon="user">
+    تحتاج إلى حساب [CrewAI AMP](https://app.crewai.com) نشط.
+  </Card>
+  <Card title="رابط خادم MCP" icon="link">
+    رابط خادم MCP الذي تريد الاتصال به. يجب أن يكون الخادم متاحاً من الإنترنت ويدعم نقل Streamable HTTP.
+  </Card>
+</CardGroup>
+
+## إضافة خادم MCP مخصص
+
+<Steps>
+    <Step title="فتح الأدوات والتكاملات">
+        انتقل إلى **Tools & Integrations** في الشريط الجانبي الأيسر لـ CrewAI AMP، ثم اختر علامة تبويب **Connections**.
+    </Step>
+
+    <Step title="بدء إضافة خادم MCP مخصص">
+        انقر على زر **Add Custom MCP Server**. سيظهر مربع حوار مع نموذج التهيئة.
+    </Step>
+
+    <Step title="ملء المعلومات الأساسية">
+        - **Name** (مطلوب): اسم وصفي لخادم MCP (مثل "My Internal Tools Server").
+        - **Description**: ملخص اختياري لما يقدمه خادم MCP هذا.
+        - **Server URL** (مطلوب): الرابط الكامل لنقطة نهاية خادم MCP (مثل `https://my-server.example.com/mcp`).
+    </Step>
+
+    <Step title="اختيار طريقة المصادقة">
+        اختر إحدى طرق المصادقة الثلاث المتاحة بناءً على كيفية تأمين خادم MCP. راجع الأقسام أدناه لتفاصيل كل طريقة.
+    </Step>
+
+    <Step title="إضافة رؤوس مخصصة (اختياري)">
+        إذا كان خادم MCP يتطلب رؤوساً إضافية في كل طلب (مثل معرّفات المستأجر أو رؤوس التوجيه)، انقر على **+ Add Header** وقدم اسم الرأس وقيمته. يمكنك إضافة رؤوس مخصصة متعددة.
+    </Step>
+
+    <Step title="إنشاء الاتصال">
+        انقر على **Create MCP Server** لحفظ الاتصال. سيظهر خادم MCP المخصص الآن في قائمة الاتصالات وستكون أدواته متاحة للاستخدام في طواقمك.
+    </Step>
+</Steps>
+
+## طرق المصادقة
+
+### بدون مصادقة
+
+اختر هذا الخيار عندما يكون خادم MCP متاحاً للجمهور ولا يتطلب أي بيانات اعتماد. هذا شائع للخوادم مفتوحة المصدر أو الخوادم الداخلية العاملة خلف VPN.
+
+### رمز المصادقة
+
+استخدم هذه الطريقة عندما يكون خادم MCP محمياً بمفتاح API أو رمز حامل.
+
+<Frame>
+    <img src="/images/enterprise/custom-mcp-auth-token.png" alt="خادم MCP مخصص برمز مصادقة" />
+</Frame>
+
+| الحقل | مطلوب | الوصف |
+|-------|-------|-------|
+| **Header Name** | نعم | اسم رأس HTTP الذي يحمل الرمز (مثل `X-API-Key`، `Authorization`). |
+| **Value** | نعم | مفتاح API أو رمز الحامل الخاص بك. |
+| **Add to** | لا | أين يتم إرفاق بيانات الاعتماد — **Header** (افتراضي) أو **Query parameter**. |
+
+<Tip>
+إذا كان خادمك يتوقع رمز `Bearer` في رأس `Authorization`، عيّن Header Name إلى `Authorization` والقيمة إلى `Bearer <your-token>`.
+</Tip>
+
+### OAuth 2.0
+
+استخدم هذه الطريقة لخوادم MCP التي تتطلب تفويض OAuth 2.0. سيتعامل CrewAI مع تدفق OAuth الكامل، بما في ذلك تحديث الرمز.
+
+<Frame>
+    <img src="/images/enterprise/custom-mcp-oauth.png" alt="خادم MCP مخصص مع OAuth 2.0" />
+</Frame>
+
+| الحقل | مطلوب | الوصف |
+|-------|-------|-------|
+| **Redirect URI** | — | مُعبأ مسبقاً وللقراءة فقط. انسخ هذا الرابط وسجّله كرابط إعادة توجيه مصرّح به في مزود OAuth. |
+| **Authorization Endpoint** | نعم | الرابط الذي يُوجَّه إليه المستخدمون لتفويض الوصول (مثل `https://auth.example.com/oauth/authorize`). |
+| **Token Endpoint** | نعم | الرابط المستخدم لتبادل رمز التفويض برمز وصول (مثل `https://auth.example.com/oauth/token`). |
+| **Client ID** | نعم | معرّف عميل OAuth الصادر من مزودك. |
+| **Client Secret** | لا | سر عميل OAuth. غير مطلوب للعملاء العامين باستخدام PKCE. |
+| **Scopes** | لا | قائمة نطاقات مفصولة بمسافات للطلب (مثل `read write`). |
+| **Token Auth Method** | لا | كيفية إرسال بيانات اعتماد العميل عند تبادل الرموز — **Standard (POST body)** أو **Basic Auth (header)**. الافتراضي هو Standard. |
+| **PKCE Supported** | لا | فعّل إذا كان مزود OAuth يدعم Proof Key for Code Exchange. موصى به لتحسين الأمان. |
+
+<Info>
+**اكتشاف تهيئة OAuth**: إذا كان مزود OAuth يدعم OpenID Connect Discovery، انقر على رابط **Discover OAuth Config** لملء نقاط نهاية التفويض والرمز تلقائياً من رابط `/.well-known/openid-configuration` الخاص بالمزود.
+</Info>
+
+#### إعداد OAuth 2.0 خطوة بخطوة
+
+<Steps>
+    <Step title="تسجيل رابط إعادة التوجيه">
+        انسخ **Redirect URI** المعروض في النموذج وأضفه كرابط إعادة توجيه مصرّح به في إعدادات تطبيق مزود OAuth.
+    </Step>
+
+    <Step title="إدخال نقاط النهاية وبيانات الاعتماد">
+        املأ **Authorization Endpoint** و**Token Endpoint** و**Client ID**، واختيارياً **Client Secret** و**Scopes**.
+    </Step>
+
+    <Step title="تهيئة طريقة تبادل الرمز">
+        اختر **Token Auth Method** المناسبة. معظم المزودين يستخدمون الافتراضي **Standard (POST body)**. بعض المزودين القدامى يتطلبون **Basic Auth (header)**.
+    </Step>
+
+    <Step title="تفعيل PKCE (موصى به)">
+        حدد **PKCE Supported** إذا كان مزودك يدعمه. يضيف PKCE طبقة أمان إضافية لتدفق رمز التفويض وموصى به لجميع التكاملات الجديدة.
+    </Step>
+
+    <Step title="الإنشاء والتفويض">
+        انقر على **Create MCP Server**. سيتم توجيهك إلى مزود OAuth لتفويض الوصول. بمجرد التفويض، سيخزن CrewAI الرموز ويحدّثها تلقائياً حسب الحاجة.
+    </Step>
+</Steps>
+
+## استخدام خادم MCP المخصص
+
+بمجرد الاتصال، تظهر أدوات خادم MCP المخصص جنباً إلى جنب مع الاتصالات المدمجة في صفحة **Tools & Integrations**. يمكنك:
+
+- **تعيين الأدوات للوكلاء** في طواقمك تماماً كأي أداة CrewAI أخرى.
+- **إدارة الرؤية** للتحكم في أعضاء الفريق الذين يمكنهم استخدام الخادم.
+- **تعديل أو إزالة** الاتصال في أي وقت من قائمة الاتصالات.
+
+<Warning>
+إذا أصبح خادم MCP غير قابل للوصول أو انتهت صلاحية بيانات الاعتماد، ستفشل استدعاءات الأدوات التي تستخدم ذلك الخادم. تأكد من استقرار رابط الخادم وتحديث بيانات الاعتماد.
+</Warning>
+
+<Card title="تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+  تواصل مع فريق الدعم للمساعدة في تهيئة خادم MCP المخصص أو استكشاف الأخطاء.
+</Card>
@@ -0,0 +1,445 @@
+---
+title: "النشر على AMP"
+description: "انشر طاقمك أو تدفقك على CrewAI AMP"
+icon: "rocket"
+mode: "wide"
+---
+
+<Note>
+  بعد إنشاء طاقم أو تدفق محلياً (أو عبر Crew Studio)، الخطوة التالية هي
+  نشره على منصة CrewAI AMP. يغطي هذا الدليل طرق نشر متعددة
+  لمساعدتك في اختيار النهج الأفضل لسير عملك.
+</Note>
+
+## المتطلبات المسبقة
+
+<CardGroup cols={2}>
+  <Card title="مشروع جاهز للنشر" icon="check-circle">
+    يجب أن يكون لديك طاقم أو تدفق يعمل بنجاح محلياً.
+    اتبع [دليل التحضير](/ar/enterprise/guides/prepare-for-deployment) للتحقق من بنية مشروعك.
+  </Card>
+  <Card title="مستودع GitHub" icon="github">
+    يجب أن يكون الكود في مستودع GitHub (لطريقة تكامل
+    GitHub)
+  </Card>
+</CardGroup>
+
+<Info>
+  **الطواقم مقابل التدفقات**: يمكن نشر كلا نوعي المشاريع كـ "أتمتات" على CrewAI AMP.
+  عملية النشر هي نفسها، لكن لهما بنى مشاريع مختلفة.
+  راجع [التحضير للنشر](/ar/enterprise/guides/prepare-for-deployment) للتفاصيل.
+</Info>
+
+## الخيار 1: النشر باستخدام CrewAI CLI
+
+يوفر CLI أسرع طريقة لنشر الطواقم أو التدفقات المطورة محلياً على منصة AMP.
+يكتشف CLI تلقائياً نوع مشروعك من `pyproject.toml` ويبني وفقاً لذلك.
+
+<Steps>
+  <Step title="تثبيت CrewAI CLI">
+    إذا لم تكن قد فعلت بالفعل، ثبّت CrewAI CLI:
+
+    ```bash
+    pip install crewai[tools]
+    ```
+
+    <Tip>
+    يأتي CLI مع حزمة CrewAI الرئيسية، لكن الإضافة `[tools]` تضمن حصولك على جميع اعتماديات النشر.
+    </Tip>
+
+  </Step>
+
+  <Step title="المصادقة مع منصة Enterprise">
+    أولاً، تحتاج لمصادقة CLI مع منصة CrewAI AMP:
+
+    ```bash
+    # إذا كان لديك حساب CrewAI AMP بالفعل، أو تريد إنشاء واحد:
+    crewai login
+    ```
+
+    عند تشغيل أي من الأمرين، سيقوم CLI بـ:
+    1. عرض رابط ورمز جهاز فريد
+    2. فتح متصفحك على صفحة المصادقة
+    3. طلب تأكيد الجهاز
+    4. إتمام عملية المصادقة
+
+    عند المصادقة الناجحة، سترى رسالة تأكيد في الطرفية!
+
+  </Step>
+
+  <Step title="إنشاء عملية نشر">
+
+    من مجلد مشروعك، شغّل:
+
+    ```bash
+    crewai deploy create
+    ```
+
+    سيقوم هذا الأمر بـ:
+    1. اكتشاف معلومات مستودع GitHub
+    2. تحديد متغيرات البيئة في ملف `.env` المحلي
+    3. نقل هذه المتغيرات بأمان إلى منصة Enterprise
+    4. إنشاء عملية نشر جديدة بمعرّف فريد
+
+    عند الإنشاء الناجح، سترى رسالة مثل:
+    ```shell
+    Deployment created successfully!
+    Name: your_project_name
+    Deployment ID: 01234567-89ab-cdef-0123-456789abcdef
+    Current Status: Deploy Enqueued
+    ```
+
+  </Step>
+
+  <Step title="مراقبة تقدم النشر">
+
+    تتبع حالة النشر بـ:
+
+    ```bash
+    crewai deploy status
+    ```
+
+    للسجلات المفصلة لعملية البناء:
+
+    ```bash
+    crewai deploy logs
+    ```
+
+    <Tip>
+    يستغرق النشر الأول عادة حوالي دقيقة واحدة.
+    </Tip>
+
+  </Step>
+</Steps>
+
+## أوامر CLI إضافية
+
+يقدم CrewAI CLI عدة أوامر لإدارة عمليات النشر:
+
+```bash
+# عرض جميع عمليات النشر
+crewai deploy list
+
+# الحصول على حالة النشر
+crewai deploy status
+
+# عرض سجلات النشر
+crewai deploy logs
+
+# دفع التحديثات بعد تغييرات الكود
+crewai deploy push
+
+# إزالة عملية نشر
+crewai deploy remove <deployment_id>
+```
+
+## الخيار 2: النشر مباشرة عبر واجهة الويب
+
+يمكنك أيضاً نشر طواقمك أو تدفقاتك مباشرة عبر واجهة ويب CrewAI AMP بربط حساب GitHub. لا يتطلب هذا النهج استخدام CLI على جهازك المحلي. تكتشف المنصة تلقائياً نوع مشروعك وتتعامل مع البناء بشكل مناسب.
+
+<Steps>
+
+  <Step title="الدفع إلى GitHub">
+
+تحتاج لدفع طاقمك إلى مستودع GitHub. إذا لم تكن قد أنشأت طاقماً بعد، يمكنك [اتباع هذا الدليل](/ar/quickstart).
+
+  </Step>
+
+  <Step title="ربط GitHub بـ CrewAI AMP">
+
+    1. سجّل الدخول إلى [CrewAI AMP](https://app.crewai.com)
+    2. انقر على زر "Connect GitHub"
+
+    <Frame>
+      ![زر ربط GitHub](/images/enterprise/connect-github.png)
+    </Frame>
+
+  </Step>
+
+  <Step title="اختيار المستودع">
+
+    بعد ربط حساب GitHub، ستتمكن من اختيار المستودع للنشر:
+
+    <Frame>
+      ![اختيار المستودع](/images/enterprise/select-repo.png)
+    </Frame>
+
+  </Step>
+
+  <Step title="تعيين متغيرات البيئة">
+
+    قبل النشر، ستحتاج لإعداد متغيرات البيئة للاتصال بمزود LLM أو خدمات أخرى:
+
+    1. يمكنك إضافة المتغيرات فردياً أو بشكل جماعي
+    2. أدخل متغيرات البيئة بتنسيق `KEY=VALUE` (واحد لكل سطر)
+
+    <Frame>
+      ![تعيين متغيرات البيئة](/images/enterprise/set-env-variables.png)
+    </Frame>
+
+    <Info>
+      تستخدم حزم Python خاصة؟ ستحتاج لإضافة بيانات اعتماد السجل هنا أيضاً.
+      راجع [سجلات الحزم الخاصة](/ar/enterprise/guides/private-package-registry) للمتغيرات المطلوبة.
+    </Info>
+
+  </Step>
+
+  <Step title="نشر طاقمك">
+
+    1. انقر على زر "Deploy" لبدء عملية النشر
+    2. يمكنك مراقبة التقدم عبر شريط التقدم
+    3. يستغرق النشر الأول عادة حوالي دقيقة واحدة
+
+    <Frame>
+      ![تقدم النشر](/images/enterprise/deploy-progress.png)
+    </Frame>
+
+    بمجرد اكتمال النشر، سترى:
+    - رابط طاقمك الفريد
+    - رمز Bearer لحماية API طاقمك
+    - زر "Delete" إذا كنت تحتاج لإزالة النشر
+
+  </Step>
+
+</Steps>
+
+## الخيار 3: إعادة النشر باستخدام API (تكامل CI/CD)
+
+لعمليات النشر الآلية في خطوط أنابيب CI/CD، يمكنك استخدام CrewAI API لتشغيل إعادة نشر الطواقم الحالية. هذا مفيد بشكل خاص لـ GitHub Actions وJenkins أو سير عمل الأتمتة الأخرى.
+
+<Steps>
+  <Step title="الحصول على رمز الوصول الشخصي">
+
+    انتقل إلى إعدادات حساب CrewAI AMP لإنشاء رمز API:
+
+    1. انتقل إلى [app.crewai.com](https://app.crewai.com)
+    2. انقر على **Settings** → **Account** → **Personal Access Token**
+    3. أنشئ رمزاً جديداً وانسخه بأمان
+    4. خزّن هذا الرمز كسر في نظام CI/CD
+
+  </Step>
+
+  <Step title="إيجاد UUID الأتمتة">
+
+    حدد موقع المعرّف الفريد لطاقمك المنشور:
+
+    1. انتقل إلى **Automations** في لوحة تحكم CrewAI AMP
+    2. اختر الأتمتة/الطاقم الحالي
+    3. انقر على **Additional Details**
+    4. انسخ **UUID** — يحدد هذا نشر طاقمك المحدد
+
+  </Step>
+
+  <Step title="تشغيل إعادة النشر عبر API">
+
+    استخدم نقطة نهاية Deploy API لتشغيل إعادة النشر:
+
+    ```bash
+    curl -i -X POST \
+         -H "Authorization: Bearer YOUR_PERSONAL_ACCESS_TOKEN" \
+         https://app.crewai.com/crewai_plus/api/v1/crews/YOUR-AUTOMATION-UUID/deploy
+
+    # HTTP/2 200
+    # content-type: application/json
+    #
+    # {
+    #   "uuid": "your-automation-uuid",
+    #   "status": "Deploy Enqueued",
+    #   "public_url": "https://your-crew-deployment.crewai.com",
+    #   "token": "your-bearer-token"
+    # }
+    ```
+
+    <Info>
+    إذا تم إنشاء أتمتتك متصلة بـ Git أولاً، سيسحب API تلقائياً أحدث التغييرات من مستودعك قبل إعادة النشر.
+    </Info>
+
+  </Step>
+
+  <Step title="مثال تكامل GitHub Actions">
+
+    إليك سير عمل GitHub Actions مع مشغلات نشر أكثر تعقيداً:
+
+    ```yaml
+    name: Deploy CrewAI Automation
+
+    on:
+      push:
+        branches: [ main ]
+      pull_request:
+        types: [ labeled ]
+      release:
+        types: [ published ]
+
+    jobs:
+      deploy:
+        runs-on: ubuntu-latest
+        if: |
+          (github.event_name == 'push' && github.ref == 'refs/heads/main') ||
+          (github.event_name == 'pull_request' && contains(github.event.pull_request.labels.*.name, 'deploy')) ||
+          (github.event_name == 'release')
+        steps:
+          - name: Trigger CrewAI Redeployment
+            run: |
+              curl -X POST \
+                   -H "Authorization: Bearer ${{ secrets.CREWAI_PAT }}" \
+                   https://app.crewai.com/crewai_plus/api/v1/crews/${{ secrets.CREWAI_AUTOMATION_UUID }}/deploy
+    ```
+
+    <Tip>
+    أضف `CREWAI_PAT` و`CREWAI_AUTOMATION_UUID` كأسرار مستودع. لعمليات نشر PR، أضف تسمية "deploy" لتشغيل سير العمل.
+    </Tip>
+
+    </Step>
+
+  </Steps>
+
+## التفاعل مع أتمتتك المنشورة
+
+بمجرد اكتمال النشر، يمكنك الوصول إلى طاقمك عبر:
+
+1. **REST API**: تنشئ المنصة نقطة نهاية HTTPS فريدة بهذه المسارات الرئيسية:
+
+   - `/inputs`: يعرض معاملات الإدخال المطلوبة
+   - `/kickoff`: يبدأ التنفيذ بالمدخلات المقدمة
+   - `/status/{kickoff_id}`: يتحقق من حالة التنفيذ
+
+2. **واجهة الويب**: زر [app.crewai.com](https://app.crewai.com) للوصول إلى:
+   - **علامة تبويب Status**: عرض معلومات النشر وتفاصيل نقطة نهاية API ورمز المصادقة
+   - **علامة تبويب Run**: تمثيل مرئي لبنية طاقمك
+   - **علامة تبويب Executions**: سجل جميع عمليات التنفيذ
+   - **علامة تبويب Metrics**: تحليلات الأداء
+   - **علامة تبويب Traces**: رؤى التنفيذ المفصلة
+
+### تشغيل عملية تنفيذ
+
+من لوحة تحكم Enterprise، يمكنك:
+
+1. النقر على اسم طاقمك لفتح تفاصيله
+2. اختيار "Trigger Crew" من واجهة الإدارة
+3. إدخال المدخلات المطلوبة في النافذة المنبثقة
+4. مراقبة التقدم أثناء مرور التنفيذ عبر خط الأنابيب
+
+### المراقبة والتحليلات
+
+توفر منصة Enterprise ميزات مراقبة شاملة:
+
+- **إدارة التنفيذ**: تتبع عمليات التشغيل النشطة والمكتملة
+- **التتبعات**: تحليلات مفصلة لكل عملية تنفيذ
+- **المقاييس**: استخدام الرموز وأوقات التنفيذ والتكاليف
+- **عرض الجدول الزمني**: تمثيل مرئي لتسلسل المهام
+
+### ميزات متقدمة
+
+تقدم منصة Enterprise أيضاً:
+
+- **إدارة متغيرات البيئة**: تخزين وإدارة مفاتيح API بأمان
+- **اتصالات LLM**: تهيئة التكاملات مع مزودي LLM المختلفين
+- **مستودع الأدوات المخصصة**: إنشاء ومشاركة وتثبيت الأدوات
+- **Crew Studio**: بناء الطواقم عبر واجهة محادثة دون كتابة كود
+
+## استكشاف أخطاء النشر وإصلاحها
+
+إذا فشل النشر، تحقق من هذه المشكلات الشائعة:
+
+### فشل البناء
+
+#### ملف uv.lock مفقود
+
+**العرض**: فشل البناء مبكراً مع أخطاء حل الاعتماديات
+
+**الحل**: أنشئ ملف القفل وارفعه:
+
+```bash
+uv lock
+git add uv.lock
+git commit -m "Add uv.lock for deployment"
+git push
+```
+
+<Warning>
+  ملف `uv.lock` مطلوب لجميع عمليات النشر. بدونه، لا يمكن للمنصة
+  تثبيت اعتمادياتك بشكل موثوق.
+</Warning>
+
+#### بنية المشروع الخاطئة
+
+**العرض**: أخطاء "Could not find entry point" أو "Module not found"
+
+**الحل**: تحقق من أن مشروعك يتطابق مع البنية المتوقعة:
+
+- **كل من الطواقم والتدفقات**: يجب أن تكون نقطة الدخول في `src/project_name/main.py`
+- **الطواقم**: تستخدم دالة `run()` كنقطة دخول
+- **التدفقات**: تستخدم دالة `kickoff()` كنقطة دخول
+
+راجع [التحضير للنشر](/ar/enterprise/guides/prepare-for-deployment) لمخططات البنية المفصلة.
+
+#### مُزخرف CrewBase مفقود
+
+**العرض**: أخطاء "Crew not found" أو "Config not found" أو أخطاء تهيئة الوكيل/المهمة
+
+**الحل**: تأكد من أن **جميع** فئات الطاقم تستخدم مُزخرف `@CrewBase`:
+
+```python
+from crewai.project import CrewBase, agent, crew, task
+
+@CrewBase  # This decorator is REQUIRED
+class YourCrew():
+    """Your crew description"""
+
+    @agent
+    def my_agent(self) -> Agent:
+        return Agent(
+            config=self.agents_config['my_agent'],  # type: ignore[index]
+            verbose=True
+        )
+
+    # ... rest of crew definition
+```
+
+<Info>
+  ينطبق هذا على الطواقم المستقلة والطواقم المضمنة داخل مشاريع التدفق.
+  كل فئة طاقم تحتاج المُزخرف.
+</Info>
+
+#### نوع pyproject.toml غير صحيح
+
+**العرض**: نجاح البناء لكن فشل وقت التشغيل، أو سلوك غير متوقع
+
+**الحل**: تحقق من أن قسم `[tool.crewai]` يتطابق مع نوع مشروعك:
+
+```toml
+# For Crew projects:
+[tool.crewai]
+type = "crew"
+
+# For Flow projects:
+[tool.crewai]
+type = "flow"
+```
+
+### فشل وقت التشغيل
+
+#### فشل اتصال LLM
+
+**العرض**: أخطاء مفتاح API، "model not found"، أو فشل المصادقة
+
+**الحل**:
+1. تحقق من صحة تعيين مفتاح API لمزود LLM في متغيرات البيئة
+2. تأكد من تطابق أسماء متغيرات البيئة مع ما يتوقعه الكود
+3. اختبر محلياً بنفس متغيرات البيئة بالضبط قبل النشر
+
+#### أخطاء تنفيذ الطاقم
+
+**العرض**: يبدأ الطاقم لكن يفشل أثناء التنفيذ
+
+**الحل**:
+1. تحقق من سجلات التنفيذ في لوحة تحكم AMP (علامة تبويب Traces)
+2. تحقق من أن جميع الأدوات لديها مفاتيح API المطلوبة مُهيأة
+3. تأكد من صحة تهيئات الوكلاء في `agents.yaml`
+4. تحقق من تهيئات المهام في `tasks.yaml` بحثاً عن أخطاء الصياغة
+
+<Card title="تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+  تواصل مع فريق الدعم للمساعدة في مشاكل النشر أو أسئلة حول
+  منصة AMP.
+</Card>
@@ -0,0 +1,179 @@
+---
+title: "تفعيل Crew Studio"
+description: "تفعيل Crew Studio على CrewAI AMP"
+icon: "comments"
+mode: "wide"
+---
+
+<Tip>
+  Crew Studio هو أداة قوية **بدون كود/منخفضة الكود** تتيح لك بسرعة
+  بناء أو هيكلة الطواقم عبر واجهة محادثة.
+</Tip>
+
+## ما هو Crew Studio؟
+
+Crew Studio هو طريقة مبتكرة لإنشاء طواقم وكلاء الذكاء الاصطناعي بدون كتابة كود.
+
+<Frame>
+  ![واجهة Crew Studio](/images/enterprise/crew-studio-interface.png)
+</Frame>
+
+مع Crew Studio، يمكنك:
+
+- الدردشة مع مساعد الطاقم لوصف مشكلتك
+- إنشاء الوكلاء والمهام تلقائياً
+- اختيار الأدوات المناسبة
+- تهيئة المدخلات الضرورية
+- إنشاء كود قابل للتنزيل للتخصيص
+- النشر مباشرة على منصة CrewAI AMP
+
+## خطوات التهيئة
+
+قبل البدء باستخدام Crew Studio، تحتاج لتهيئة اتصالات LLM:
+
+<Steps>
+  <Step title="إعداد اتصال LLM">
+    انتقل إلى علامة تبويب **LLM Connections** في لوحة تحكم CrewAI AMP وأنشئ اتصال LLM جديداً.
+
+    <Note>
+      يمكنك استخدام أي مزود LLM تريده ويدعمه CrewAI.
+    </Note>
+
+    هيّئ اتصال LLM:
+
+    - أدخل `Connection Name` (مثل `OpenAI`)
+    - اختر مزود النموذج: `openai` أو `azure`
+    - اختر النماذج التي تريد استخدامها في طواقم Studio
+      - نوصي بـ `gpt-4o` و`o1-mini` و`gpt-4o-mini` على الأقل
+    - أضف مفتاح API كمتغير بيئة:
+      - لـ OpenAI: أضف `OPENAI_API_KEY` مع مفتاح API
+      - لـ Azure OpenAI: راجع [هذه المقالة](https://blog.crewai.com/configuring-azure-openai-with-crewai-a-comprehensive-guide/) لتفاصيل التهيئة
+    - انقر على `Add Connection` لحفظ التهيئة
+
+    <Frame>
+      ![تهيئة اتصال LLM](/images/enterprise/llm-connection-config.png)
+    </Frame>
+
+  </Step>
+
+  <Step title="التحقق من إضافة الاتصال">
+    بمجرد إتمام الإعداد، سترى الاتصال الجديد مُضافاً إلى قائمة الاتصالات المتاحة.
+
+    <Frame>
+      ![تم إضافة الاتصال](/images/enterprise/connection-added.png)
+    </Frame>
+
+  </Step>
+
+  <Step title="تهيئة إعدادات LLM الافتراضية">
+    في القائمة الرئيسية، انتقل إلى **Settings → Defaults** وهيّئ إعدادات LLM الافتراضية:
+
+    - اختر النماذج الافتراضية للوكلاء والمكونات الأخرى
+    - عيّن التهيئات الافتراضية لـ Crew Studio
+
+    انقر على `Save Settings` لتطبيق تغييراتك.
+
+    <Frame>
+      ![تهيئة إعدادات LLM الافتراضية](/images/enterprise/llm-defaults.png)
+    </Frame>
+
+  </Step>
+</Steps>
+
+## استخدام Crew Studio
+
+الآن بعد تهيئة اتصال LLM والإعدادات الافتراضية، أنت جاهز لبدء استخدام Crew Studio!
+
+<Steps>
+  <Step title="الوصول إلى Studio">
+    انتقل إلى قسم **Studio** في لوحة تحكم CrewAI AMP.
+  </Step>
+
+  <Step title="بدء محادثة">
+    ابدأ محادثة مع مساعد الطاقم بوصف المشكلة التي تريد حلها:
+
+    ```md
+    I need a crew that can research the latest AI developments and create a summary report.
+    ```
+
+    سيطرح مساعد الطاقم أسئلة توضيحية لفهم متطلباتك بشكل أفضل.
+
+  </Step>
+
+  <Step title="مراجعة الطاقم المُنشأ">
+    راجع تهيئة الطاقم المُنشأ، بما في ذلك:
+
+    - الوكلاء وأدوارهم
+    - المهام المطلوب تنفيذها
+    - المدخلات المطلوبة
+    - الأدوات المستخدمة
+
+    هذه فرصتك لتنقيح التهيئة قبل المتابعة.
+
+  </Step>
+
+  <Step title="النشر أو التنزيل">
+    بمجرد رضاك عن التهيئة، يمكنك:
+
+    - تنزيل الكود المُنشأ للتخصيص المحلي
+    - نشر الطاقم مباشرة على منصة CrewAI AMP
+    - تعديل التهيئة وإعادة إنشاء الطاقم
+
+  </Step>
+
+  <Step title="اختبار طاقمك">
+    بعد النشر، اختبر طاقمك بمدخلات نموذجية للتأكد من أنه يعمل كما هو متوقع.
+  </Step>
+</Steps>
+
+<Tip>
+  للحصول على أفضل النتائج، قدم أوصافاً واضحة ومفصلة لما تريد أن
+  يحققه طاقمك. ضمّن مدخلات ومخرجات محددة متوقعة في
+  وصفك.
+</Tip>
+
+## مثال على سير العمل
+
+إليك سير عمل نموذجي لإنشاء طاقم مع Crew Studio:
+
+<Steps>
+  <Step title="وصف مشكلتك">
+    ابدأ بوصف مشكلتك:
+
+    ```md
+    I need a crew that can analyze financial news and provide investment recommendations
+    ```
+
+  </Step>
+
+<Step title="الإجابة على الأسئلة">
+  أجب على أسئلة التوضيح من مساعد الطاقم لتنقيح
+  متطلباتك.
+</Step>
+
+  <Step title="مراجعة الخطة">
+    راجع خطة الطاقم المُنشأة، التي قد تتضمن:
+
+    - وكيل بحث لجمع الأخبار المالية
+    - وكيل تحليل لتفسير البيانات
+    - وكيل توصيات لتقديم نصائح استثمارية
+
+  </Step>
+
+<Step title="الموافقة أو التعديل">
+  وافق على الخطة أو اطلب تغييرات إذا لزم الأمر.
+</Step>
+
+<Step title="التنزيل أو النشر">
+  نزّل الكود للتخصيص أو انشر مباشرة على المنصة.
+</Step>
+
+  <Step title="الاختبار والتنقيح">
+    اختبر طاقمك بمدخلات نموذجية ونقّح حسب الحاجة.
+  </Step>
+</Steps>
+
+<Card title="تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+  تواصل مع فريق الدعم للمساعدة في Crew Studio أو أي ميزات أخرى في CrewAI
+  AMP.
+</Card>
@@ -0,0 +1,97 @@
+---
+title: "مشغل Gmail"
+description: "تشغيل الأتمتات عند حدوث أحداث Gmail (مثل رسائل بريد إلكتروني جديدة، تسميات)."
+icon: "envelope"
+mode: "wide"
+---
+
+## نظرة عامة
+
+استخدم مشغل Gmail لتشغيل طواقمك المنشورة عند حدوث أحداث Gmail في الحسابات المتصلة، مثل استلام رسالة بريد إلكتروني جديدة أو رسائل تطابق تسمية/فلتر.
+
+<Tip>
+  تأكد من ربط Gmail في Tools & Integrations وتفعيل المشغل
+  لعملية النشر.
+</Tip>
+
+## تفعيل مشغل Gmail
+
+1. افتح عملية النشر في CrewAI AMP
+2. انتقل إلى علامة تبويب **Triggers**
+3. حدد موقع **Gmail** وبدّل مفتاح التبديل للتفعيل
+
+<Frame>
+  <img
+    src="/images/enterprise/trigger-selected.png"
+    alt="تفعيل أو تعطيل المشغلات بالتبديل"
+  />
+</Frame>
+
+## مثال: معالجة الرسائل الجديدة
+
+عند وصول رسالة بريد إلكتروني جديدة، سيرسل مشغل Gmail الحمولة إلى طاقمك أو تدفقك. فيما يلي مثال على طاقم يحلل ويعالج حمولة المشغل.
+
+```python
+@CrewBase
+class GmailProcessingCrew:
+    @agent
+    def parser(self) -> Agent:
+        return Agent(
+            config=self.agents_config['parser'],
+        )
+
+    @task
+    def parse_gmail_payload(self) -> Task:
+        return Task(
+            config=self.tasks_config['parse_gmail_payload'],
+            agent=self.parser(),
+        )
+
+    @task
+    def act_on_email(self) -> Task:
+        return Task(
+            config=self.tasks_config['act_on_email'],
+            agent=self.parser(),
+        )
+```
+
+ستكون حمولة Gmail متاحة عبر آليات السياق القياسية.
+
+### الاختبار المحلي
+
+اختبر تكامل مشغل Gmail محلياً باستخدام CrewAI CLI:
+
+```bash
+# عرض جميع المشغلات المتاحة
+crewai triggers list
+
+# محاكاة مشغل Gmail بحمولة واقعية
+crewai triggers run gmail/new_email_received
+```
+
+سينفذ أمر `crewai triggers run` طاقمك بحمولة Gmail كاملة، مما يتيح لك اختبار منطق التحليل قبل النشر.
+
+<Warning>
+  استخدم `crewai triggers run gmail/new_email_received` (وليس `crewai run`) لمحاكاة
+  تنفيذ المشغل أثناء التطوير. بعد النشر، سيتلقى طاقمك
+  حمولة المشغل تلقائياً.
+</Warning>
+
+## مراقبة عمليات التنفيذ
+
+تتبع سجل وأداء عمليات التشغيل المُشغّلة:
+
+<Frame>
+  <img
+    src="/images/enterprise/list-executions.png"
+    alt="قائمة عمليات التنفيذ المُشغّلة بواسطة الأتمتة"
+  />
+</Frame>
+
+## استكشاف الأخطاء وإصلاحها
+
+- تأكد من ربط Gmail في Tools & Integrations
+- تحقق من تفعيل مشغل Gmail في علامة تبويب Triggers
+- اختبر محلياً بـ `crewai triggers run gmail/new_email_received` لرؤية هيكل الحمولة بالضبط
+- تحقق من سجلات التنفيذ وتأكد من تمرير الحمولة كـ `crewai_trigger_payload`
+- تذكر: استخدم `crewai triggers run` (وليس `crewai run`) لمحاكاة تنفيذ المشغل
@@ -0,0 +1,83 @@
+---
+title: "مشغل Google Calendar"
+description: "تشغيل الطواقم عند إنشاء أو تحديث أو إلغاء أحداث Google Calendar"
+icon: "calendar"
+mode: "wide"
+---
+
+## نظرة عامة
+
+استخدم مشغل Google Calendar لإطلاق الأتمتات كلما تغيرت أحداث التقويم. تشمل حالات الاستخدام الشائعة إحاطة الفريق قبل اجتماع، وإخطار أصحاب المصلحة عند إلغاء حدث هام، أو تلخيص الجداول اليومية.
+
+<Tip>
+  تأكد من ربط Google Calendar في **Tools & Integrations** وتفعيله
+  لعملية النشر التي تريد أتمتتها.
+</Tip>
+
+## تفعيل مشغل Google Calendar
+
+1. افتح عملية النشر في CrewAI AMP
+2. انتقل إلى علامة تبويب **Triggers**
+3. حدد موقع **Google Calendar** وبدّل مفتاح التبديل للتفعيل
+
+<Frame>
+  <img
+    src="/images/enterprise/calendar-trigger.png"
+    alt="تفعيل أو تعطيل المشغلات بالتبديل"
+  />
+</Frame>
+
+## مثال: تلخيص تفاصيل الاجتماع
+
+المقتطف أدناه يعكس مثال `calendar-event-crew.py` في مستودع المشغلات. يحلل الحمولة، ويحلل الحاضرين والتوقيت، وينتج ملخصاً للاجتماع للأدوات اللاحقة.
+
+```python
+from calendar_event_crew import GoogleCalendarEventTrigger
+
+crew = GoogleCalendarEventTrigger().crew()
+result = crew.kickoff({
+    "crewai_trigger_payload": calendar_payload,
+})
+print(result.raw)
+```
+
+استخدم `crewai_trigger_payload` تماماً كما يتم تسليمه من المشغل حتى يتمكن الطاقم من استخراج الحقول المناسبة.
+
+## الاختبار المحلي
+
+اختبر تكامل مشغل Google Calendar محلياً باستخدام CrewAI CLI:
+
+```bash
+# عرض جميع المشغلات المتاحة
+crewai triggers list
+
+# محاكاة مشغل Google Calendar بحمولة واقعية
+crewai triggers run google_calendar/event_changed
+```
+
+سينفذ أمر `crewai triggers run` طاقمك بحمولة Calendar كاملة، مما يتيح لك اختبار منطق التحليل قبل النشر.
+
+<Warning>
+  استخدم `crewai triggers run google_calendar/event_changed` (وليس `crewai run`) لمحاكاة
+  تنفيذ المشغل أثناء التطوير. بعد النشر، سيتلقى طاقمك
+  حمولة المشغل تلقائياً.
+</Warning>
+
+## مراقبة عمليات التنفيذ
+
+تتبع قائمة **Executions** في لوحة تحكم النشر كل عملية تشغيل مُشغّلة وتعرض بيانات الحمولة الوصفية وملخصات المخرجات والأخطاء.
+
+<Frame>
+  <img
+    src="/images/enterprise/list-executions.png"
+    alt="قائمة عمليات التنفيذ المُشغّلة بواسطة الأتمتة"
+  />
+</Frame>
+
+## استكشاف الأخطاء وإصلاحها
+
+- تأكد من ربط حساب Google الصحيح وتفعيل المشغل
+- اختبر محلياً بـ `crewai triggers run google_calendar/event_changed` لرؤية هيكل الحمولة بالضبط
+- تأكد من أن سير عملك يتعامل مع أحداث اليوم الكامل (الحمولات تستخدم `start.date` و`end.date` بدلاً من الطوابع الزمنية)
+- تحقق من سجلات التنفيذ إذا كانت التذكيرات أو مصفوفات الحاضرين مفقودة — قد تحد صلاحيات التقويم من الحقول في الحمولة
+- تذكر: استخدم `crewai triggers run` (وليس `crewai run`) لمحاكاة تنفيذ المشغل
@@ -0,0 +1,80 @@
+---
+title: "مشغل Google Drive"
+description: "الاستجابة لأحداث ملفات Google Drive بطواقم آلية"
+icon: "folder"
+mode: "wide"
+---
+
+## نظرة عامة
+
+شغّل أتمتاتك عند إنشاء أو تحديث أو حذف ملفات في Google Drive. تشمل سير العمل النموذجية تلخيص المحتوى المُحمّل حديثاً، وتطبيق سياسات المشاركة، أو إخطار المالكين عند تغيير ملفات هامة.
+
+<Tip>
+  اربط Google Drive في **Tools & Integrations** وتأكد من تفعيل المشغل
+  للأتمتة التي تريد مراقبتها.
+</Tip>
+
+## تفعيل مشغل Google Drive
+
+1. افتح عملية النشر في CrewAI AMP
+2. انتقل إلى علامة تبويب **Triggers**
+3. حدد موقع **Google Drive** وبدّل مفتاح التبديل للتفعيل
+
+<Frame>
+  <img
+    src="/images/enterprise/gdrive-trigger.png"
+    alt="تفعيل أو تعطيل المشغلات بالتبديل"
+  />
+</Frame>
+
+## مثال: تلخيص نشاط الملفات
+
+تحلل طواقم Drive النموذجية الحمولة لاستخراج بيانات الملف الوصفية وتقييم الصلاحيات ونشر ملخص.
+
+```python
+from drive_file_crew import GoogleDriveFileTrigger
+
+crew = GoogleDriveFileTrigger().crew()
+crew.kickoff({
+    "crewai_trigger_payload": drive_payload,
+})
+```
+
+## الاختبار المحلي
+
+اختبر تكامل مشغل Google Drive محلياً باستخدام CrewAI CLI:
+
+```bash
+# عرض جميع المشغلات المتاحة
+crewai triggers list
+
+# محاكاة مشغل Google Drive بحمولة واقعية
+crewai triggers run google_drive/file_changed
+```
+
+سينفذ أمر `crewai triggers run` طاقمك بحمولة Drive كاملة، مما يتيح لك اختبار منطق التحليل قبل النشر.
+
+<Warning>
+  استخدم `crewai triggers run google_drive/file_changed` (وليس `crewai run`) لمحاكاة
+  تنفيذ المشغل أثناء التطوير. بعد النشر، سيتلقى طاقمك
+  حمولة المشغل تلقائياً.
+</Warning>
+
+## مراقبة عمليات التنفيذ
+
+تتبع سجل وأداء عمليات التشغيل المُشغّلة عبر قائمة **Executions** في لوحة تحكم النشر.
+
+<Frame>
+  <img
+    src="/images/enterprise/list-executions.png"
+    alt="قائمة عمليات التنفيذ المُشغّلة بواسطة الأتمتة"
+  />
+</Frame>
+
+## استكشاف الأخطاء وإصلاحها
+
+- تحقق من ربط Google Drive وتفعيل مفتاح التبديل للمشغل
+- اختبر محلياً بـ `crewai triggers run google_drive/file_changed` لرؤية هيكل الحمولة بالضبط
+- إذا كانت الحمولة تفتقد بيانات الصلاحيات، تأكد من أن الحساب المتصل لديه صلاحية الوصول إلى الملف أو المجلد
+- يرسل المشغل معرّفات الملفات فقط؛ استخدم Drive API إذا كنت تحتاج جلب المحتوى الثنائي أثناء تشغيل الطاقم
+- تذكر: استخدم `crewai triggers run` (وليس `crewai run`) لمحاكاة تنفيذ المشغل
@@ -0,0 +1,61 @@
+---
+title: "مشغل HubSpot"
+description: "تشغيل طواقم CrewAI مباشرة من سير عمل HubSpot"
+icon: "hubspot"
+mode: "wide"
+---
+
+يقدم هذا الدليل عملية خطوة بخطوة لإعداد مشغلات HubSpot لـ CrewAI AMP، مما يتيح لك بدء الطواقم مباشرة من سير عمل HubSpot.
+
+## المتطلبات المسبقة
+
+- حساب CrewAI AMP
+- حساب HubSpot مع ميزة [HubSpot Workflows](https://knowledge.hubspot.com/workflows/create-workflows)
+
+## خطوات الإعداد
+
+<Steps>
+  <Step title="ربط حساب HubSpot بـ CrewAI AMP">
+    - سجّل الدخول إلى `حساب CrewAI AMP > Triggers` - اختر `HubSpot` من
+    قائمة المشغلات المتاحة - اختر حساب HubSpot الذي تريد ربطه
+    بـ CrewAI AMP - اتبع التعليمات على الشاشة لتفويض وصول CrewAI AMP
+    إلى حساب HubSpot - ستظهر رسالة تأكيد بمجرد
+    ربط HubSpot بنجاح مع CrewAI AMP
+  </Step>
+  <Step title="إنشاء سير عمل HubSpot">
+    - سجّل الدخول إلى `حساب HubSpot > Automations > Workflows > New workflow`
+    - اختر نوع سير العمل المناسب لاحتياجاتك (مثل Start from scratch) -
+    في منشئ سير العمل، انقر على أيقونة Plus (+) لإضافة إجراء جديد. -
+    اختر `Integrated apps > CrewAI > Kickoff a Crew`. - اختر الطاقم الذي
+    تريد تشغيله. - انقر على `Save` لإضافة الإجراء إلى سير عملك
+    <Frame>
+      <img
+        src="/images/enterprise/hubspot-workflow-1.png"
+        alt="سير عمل HubSpot 1"
+      />
+    </Frame>
+  </Step>
+  <Step title="استخدام نتائج الطاقم مع إجراءات أخرى">
+    - بعد خطوة Kickoff a Crew، انقر على أيقونة Plus (+) لإضافة
+    إجراء جديد. - على سبيل المثال، لإرسال إشعار بريد إلكتروني داخلي، اختر
+    `Communications > Send internal email notification` - في حقل Body،
+    انقر على `Insert data`، اختر `View properties or action outputs from > Action
+    outputs > Crew Result` لتضمين بيانات الطاقم في البريد الإلكتروني
+    <Frame>
+      <img
+        src="/images/enterprise/hubspot-workflow-2.png"
+        alt="سير عمل HubSpot 2"
+      />
+  </Frame>
+  - هيّئ أي إجراءات إضافية حسب الحاجة - راجع خطوات
+    سير عملك للتأكد من إعداد كل شيء بشكل صحيح - فعّل سير العمل
+    <Frame>
+      <img
+        src="/images/enterprise/hubspot-workflow-3.png"
+        alt="سير عمل HubSpot 3"
+      />
+    </Frame>
+  </Step>
+</Steps>
+
+لمزيد من المعلومات المفصلة حول الإجراءات المتاحة وخيارات التخصيص، راجع [وثائق HubSpot Workflows](https://knowledge.hubspot.com/workflows/create-workflows).
@@ -0,0 +1,157 @@
+---
+title: "سير عمل HITL"
+description: "تعلم كيفية تنفيذ سير عمل Human-In-The-Loop في CrewAI لتعزيز اتخاذ القرار"
+icon: "user-check"
+mode: "wide"
+---
+
+Human-In-The-Loop (HITL) هو نهج قوي يجمع بين الذكاء الاصطناعي والخبرة البشرية لتعزيز اتخاذ القرار وتحسين نتائج المهام. يوضح هذا الدليل كيفية تنفيذ HITL داخل CrewAI Enterprise.
+
+## نهجا HITL في CrewAI
+
+يقدم CrewAI نهجين لتنفيذ سير عمل Human-In-The-Loop:
+
+| النهج | الأفضل لـ | الإصدار |
+|-------|-----------|---------|
+| **قائم على التدفق** (مُزخرف `@human_feedback`) | الإنتاج مع واجهة Enterprise، سير عمل البريد الإلكتروني أولاً، ميزات المنصة الكاملة | **1.8.0+** |
+| **قائم على Webhook** | التكاملات المخصصة، الأنظمة الخارجية (Slack، Teams، إلخ.)، الإعدادات القديمة | جميع الإصدارات |
+
+## HITL القائم على التدفق مع منصة Enterprise
+
+<Note>
+يتطلب مُزخرف `@human_feedback` **إصدار CrewAI 1.8.0 أو أعلى**.
+</Note>
+
+عند استخدام مُزخرف `@human_feedback` في تدفقاتك، يوفر CrewAI Enterprise **نظام HITL يعتمد على البريد الإلكتروني أولاً** يمكّن أي شخص لديه عنوان بريد إلكتروني من الاستجابة لطلبات المراجعة:
+
+<CardGroup cols={2}>
+  <Card title="تصميم البريد الإلكتروني أولاً" icon="envelope">
+    يتلقى المستجيبون إشعارات بريد إلكتروني ويمكنهم الرد مباشرة — لا حاجة لتسجيل الدخول.
+  </Card>
+  <Card title="مراجعة من لوحة التحكم" icon="desktop">
+    راجع واستجب لطلبات HITL في لوحة تحكم Enterprise عند التفضيل.
+  </Card>
+  <Card title="توجيه مرن" icon="route">
+    وجّه الطلبات إلى عناوين بريد محددة بناءً على أنماط الدوال أو استخراجها من حالة التدفق.
+  </Card>
+  <Card title="استجابة تلقائية" icon="clock">
+    هيّئ استجابات احتياطية تلقائية عندما لا يرد أي شخص خلال المهلة الزمنية.
+  </Card>
+</CardGroup>
+
+### الفوائد الرئيسية
+
+- **مستجيبون خارجيون**: أي شخص لديه بريد إلكتروني يمكنه الاستجابة، حتى غير مستخدمي المنصة
+- **تعيين ديناميكي**: استخراج بريد المُعيَّن من حالة التدفق (مثل `account_owner_email`)
+- **تهيئة بسيطة**: التوجيه عبر البريد الإلكتروني أسهل في الإعداد من إدارة المستخدمين/الأدوار
+- **احتياطي منشئ النشر**: إذا لم تتطابق قاعدة توجيه، يتم إخطار منشئ النشر
+
+<Tip>
+لتفاصيل التنفيذ حول مُزخرف `@human_feedback`، راجع دليل [التغذية الراجعة البشرية في التدفقات](/ar/learn/human-feedback-in-flows).
+</Tip>
+
+## إعداد سير عمل HITL القائم على Webhook
+
+للتكاملات المخصصة مع الأنظمة الخارجية مثل Slack وMicrosoft Teams أو تطبيقاتك الخاصة، يمكنك استخدام النهج القائم على Webhook:
+
+<Steps>
+    <Step title="تهيئة المهمة">
+        هيّئ مهمتك مع تفعيل الإدخال البشري:
+        <Frame>
+            <img src="/images/enterprise/crew-human-input.png" alt="إدخال بشري للطاقم" />
+        </Frame>
+    </Step>
+
+    <Step title="تقديم رابط Webhook">
+        عند تشغيل طاقمك، أضف رابط webhook للإدخال البشري:
+        <Frame>
+            <img src="/images/enterprise/crew-webhook-url.png" alt="رابط Webhook للطاقم" />
+        </Frame>
+    </Step>
+
+    <Step title="استلام إشعار Webhook">
+        بمجرد إتمام الطاقم للمهمة التي تتطلب إدخالاً بشرياً، ستتلقى إشعار webhook يحتوي على:
+            - **معرّف التنفيذ**
+            - **معرّف المهمة**
+            - **مخرجات المهمة**
+    </Step>
+
+    <Step title="مراجعة مخرجات المهمة">
+        سيتوقف النظام في حالة `Pending Human Input`. راجع مخرجات المهمة بعناية.
+    </Step>
+
+    <Step title="إرسال التغذية الراجعة البشرية">
+        استدعِ نقطة نهاية الاستئناف لطاقمك بالمعلومات التالية:
+        <Frame>
+            <img src="/images/enterprise/crew-resume-endpoint.png" alt="نقطة نهاية استئناف الطاقم" />
+        </Frame>
+
+        <Warning>
+            **هام: يجب تقديم روابط Webhook مرة أخرى**:
+            **يجب** تقديم نفس روابط webhook (`taskWebhookUrl`، `stepWebhookUrl`، `crewWebhookUrl`) في استدعاء الاستئناف التي استخدمتها في استدعاء التشغيل. لا تُنقل تهيئات Webhook تلقائياً من التشغيل — يجب تضمينها صراحة في طلب الاستئناف لمواصلة تلقي الإشعارات لاكتمال المهام وخطوات الوكيل واكتمال الطاقم.
+        </Warning>
+
+        مثال على استدعاء الاستئناف مع webhooks:
+        ```bash
+        curl -X POST {BASE_URL}/resume \
+          -H "Authorization: Bearer YOUR_API_TOKEN" \
+          -H "Content-Type: application/json" \
+          -d '{
+            "execution_id": "abcd1234-5678-90ef-ghij-klmnopqrstuv",
+            "task_id": "research_task",
+            "human_feedback": "Great work! Please add more details.",
+            "is_approve": true,
+            "taskWebhookUrl": "https://your-server.com/webhooks/task",
+            "stepWebhookUrl": "https://your-server.com/webhooks/step",
+            "crewWebhookUrl": "https://your-server.com/webhooks/crew"
+          }'
+        ```
+
+        <Warning>
+            **تأثير التغذية الراجعة على تنفيذ المهمة**:
+            من الضروري توخي الحذر عند تقديم التغذية الراجعة، حيث سيتم دمج محتوى التغذية الراجعة بالكامل كسياق إضافي لعمليات تنفيذ المهام اللاحقة.
+        </Warning>
+        وهذا يعني:
+        - جميع المعلومات في تغذيتك الراجعة تصبح جزءاً من سياق المهمة.
+        - التفاصيل غير ذات الصلة قد تؤثر سلباً عليها.
+        - التغذية الراجعة الموجزة وذات الصلة تساعد في الحفاظ على تركيز وكفاءة المهمة.
+        - راجع دائماً تغذيتك الراجعة بعناية قبل الإرسال للتأكد من أنها تحتوي فقط على معلومات ذات صلة توجه تنفيذ المهمة بشكل إيجابي.
+    </Step>
+    <Step title="التعامل مع التغذية الراجعة السلبية">
+        إذا قدمت تغذية راجعة سلبية:
+        - سيعيد الطاقم محاولة المهمة مع سياق إضافي من تغذيتك الراجعة.
+        - ستتلقى إشعار webhook آخر لمزيد من المراجعة.
+        - كرر الخطوات 4-6 حتى ترضى.
+    </Step>
+
+    <Step title="استمرار التنفيذ">
+        عندما ترسل تغذية راجعة إيجابية، سيستمر التنفيذ إلى الخطوات التالية.
+    </Step>
+</Steps>
+
+## أفضل الممارسات
+
+- **كن محدداً**: قدم تغذية راجعة واضحة وقابلة للتنفيذ تعالج المهمة مباشرة
+- **كن ذا صلة**: ضمّن فقط المعلومات التي ستساعد في تحسين تنفيذ المهمة
+- **كن سريعاً**: استجب لمطالبات HITL بسرعة لتجنب تأخير سير العمل
+- **راجع بعناية**: تحقق من تغذيتك الراجعة قبل الإرسال لضمان الدقة
+
+## حالات الاستخدام الشائعة
+
+سير عمل HITL ذو قيمة خاصة لـ:
+- ضمان الجودة والتحقق
+- سيناريوهات اتخاذ القرار المعقدة
+- العمليات الحساسة أو عالية المخاطر
+- المهام الإبداعية التي تتطلب حكماً بشرياً
+- مراجعات الامتثال والتنظيم
+
+## اعرف المزيد
+
+<CardGroup cols={2}>
+  <Card title="إدارة HITL للتدفقات" icon="users-gear" href="/ar/enterprise/features/flow-hitl-management">
+    استكشف قدرات منصة Enterprise الكاملة لـ Flow HITL بما في ذلك إشعارات البريد الإلكتروني وقواعد التوجيه والاستجابة التلقائية والتحليلات.
+  </Card>
+  <Card title="التغذية الراجعة البشرية في التدفقات" icon="code" href="/ar/learn/human-feedback-in-flows">
+    دليل التنفيذ لمُزخرف `@human_feedback` في تدفقاتك.
+  </Card>
+</CardGroup>
@@ -0,0 +1,178 @@
+---
+title: "تشغيل الطاقم"
+description: "تشغيل طاقم على CrewAI AMP"
+icon: "flag-checkered"
+mode: "wide"
+---
+
+## نظرة عامة
+
+بمجرد نشر طاقمك على منصة CrewAI AMP، يمكنك بدء عمليات التنفيذ عبر واجهة الويب أو API. يغطي هذا الدليل كلا النهجين.
+
+## الطريقة 1: استخدام واجهة الويب
+
+### الخطوة 1: الانتقال إلى طاقمك المنشور
+
+1. سجّل الدخول إلى [CrewAI AMP](https://app.crewai.com)
+2. انقر على اسم الطاقم من قائمة مشاريعك
+3. ستنتقل إلى صفحة تفاصيل الطاقم
+
+<Frame>![لوحة تحكم الطاقم](/images/enterprise/crew-dashboard.png)</Frame>
+
+### الخطوة 2: بدء التنفيذ
+
+من صفحة تفاصيل طاقمك، لديك خياران لبدء التنفيذ:
+
+#### الخيار أ: التشغيل السريع
+
+1. انقر على رابط `Kickoff` في قسم Test Endpoints
+2. أدخل معاملات الإدخال المطلوبة لطاقمك في محرر JSON
+3. انقر على زر `Send Request`
+
+<Frame>![نقطة نهاية التشغيل](/images/enterprise/kickoff-endpoint.png)</Frame>
+
+#### الخيار ب: استخدام الواجهة المرئية
+
+1. انقر على علامة تبويب `Run` في صفحة تفاصيل الطاقم
+2. أدخل المدخلات المطلوبة في حقول النموذج
+3. انقر على زر `Run Crew`
+
+<Frame>![تشغيل الطاقم](/images/enterprise/run-crew.png)</Frame>
+
+### الخطوة 3: مراقبة تقدم التنفيذ
+
+بعد بدء التنفيذ:
+
+1. ستتلقى استجابة تحتوي على `kickoff_id` - **انسخ هذا المعرّف**
+2. هذا المعرّف ضروري لتتبع تنفيذك
+
+<Frame>![نسخ معرّف المهمة](/images/enterprise/copy-task-id.png)</Frame>
+
+### الخطوة 4: التحقق من حالة التنفيذ
+
+لمراقبة تقدم تنفيذك:
+
+1. انقر على نقطة نهاية "Status" في قسم Test Endpoints
+2. الصق `kickoff_id` في الحقل المخصص
+3. انقر على زر "Get Status"
+
+<Frame>![الحصول على الحالة](/images/enterprise/get-status.png)</Frame>
+
+ستعرض استجابة الحالة:
+
+- حالة التنفيذ الحالية (`running`، `completed`، إلخ.)
+- تفاصيل حول المهام الجارية
+- أي مخرجات أُنتجت حتى الآن
+
+### الخطوة 5: عرض النتائج النهائية
+
+بمجرد اكتمال التنفيذ:
+
+1. ستتغير الحالة إلى `completed`
+2. يمكنك عرض نتائج ومخرجات التنفيذ الكاملة
+3. لعرض أكثر تفصيلاً، تحقق من علامة تبويب `Executions` في صفحة تفاصيل الطاقم
+
+## الطريقة 2: استخدام API
+
+يمكنك أيضاً تشغيل الطواقم برمجياً باستخدام REST API لـ CrewAI AMP.
+
+### المصادقة
+
+جميع طلبات API تتطلب رمز حامل للمصادقة:
+
+```bash
+curl -H "Authorization: Bearer YOUR_CREW_TOKEN" https://your-crew-url.crewai.com
+```
+
+رمز الحامل متاح في علامة تبويب Status في صفحة تفاصيل طاقمك.
+
+### التحقق من صحة الطاقم
+
+قبل تنفيذ العمليات، يمكنك التحقق من أن طاقمك يعمل بشكل صحيح:
+
+```bash
+curl -H "Authorization: Bearer YOUR_CREW_TOKEN" https://your-crew-url.crewai.com
+```
+
+ستعيد الاستجابة الناجحة رسالة تشير إلى أن الطاقم يعمل:
+
+```
+Healthy%
+```
+
+### الخطوة 1: استرداد المدخلات المطلوبة
+
+أولاً، حدد المدخلات التي يتطلبها طاقمك:
+
+```bash
+curl -X GET \
+  -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  https://your-crew-url.crewai.com/inputs
+```
+
+ستكون الاستجابة كائن JSON يحتوي على مصفوفة من معاملات الإدخال المطلوبة، على سبيل المثال:
+
+```json
+{ "inputs": ["topic", "current_year"] }
+```
+
+يوضح هذا المثال أن هذا الطاقم المحدد يتطلب مدخلين: `topic` و`current_year`.
+
+### الخطوة 2: بدء التنفيذ
+
+ابدأ التنفيذ بتقديم المدخلات المطلوبة:
+
+```bash
+curl -X POST \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  -d '{"inputs": {"topic": "AI Agent Frameworks", "current_year": "2025"}}' \
+  https://your-crew-url.crewai.com/kickoff
+```
+
+ستتضمن الاستجابة `kickoff_id` الذي ستحتاجه للتتبع:
+
+```json
+{ "kickoff_id": "abcd1234-5678-90ef-ghij-klmnopqrstuv" }
+```
+
+### الخطوة 3: التحقق من حالة التنفيذ
+
+راقب تقدم التنفيذ باستخدام kickoff_id:
+
+```bash
+curl -X GET \
+  -H "Authorization: Bearer YOUR_CREW_TOKEN" \
+  https://your-crew-url.crewai.com/status/abcd1234-5678-90ef-ghij-klmnopqrstuv
+```
+
+## التعامل مع عمليات التنفيذ
+
+### عمليات التنفيذ طويلة المدة
+
+لعمليات التنفيذ التي قد تستغرق وقتاً طويلاً:
+
+1. فكّر في تنفيذ آلية استعلام دوري للتحقق من الحالة بشكل دوري
+2. استخدم webhooks (إذا كانت متاحة) للإشعار عند اكتمال التنفيذ
+3. نفّذ معالجة الأخطاء للمهلات الزمنية المحتملة
+
+### سياق التنفيذ
+
+يتضمن سياق التنفيذ:
+
+- المدخلات المقدمة عند التشغيل
+- متغيرات البيئة المُهيأة أثناء النشر
+- أي حالة محفوظة بين المهام
+
+### تصحيح أخطاء عمليات التنفيذ الفاشلة
+
+إذا فشل التنفيذ:
+
+1. تحقق من علامة تبويب "Executions" للسجلات المفصلة
+2. راجع علامة تبويب "Traces" لتفاصيل التنفيذ خطوة بخطوة
+3. ابحث عن استجابات LLM واستخدام الأدوات في تفاصيل التتبع
+
+<Card title="تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+  تواصل مع فريق الدعم للمساعدة في مشاكل التنفيذ أو أسئلة حول
+  منصة Enterprise.
+</Card>
@@ -0,0 +1,70 @@
+---
+title: "مشغل Microsoft Teams"
+description: "تشغيل الطواقم من نشاط محادثات Microsoft Teams"
+icon: "microsoft"
+mode: "wide"
+---
+
+## نظرة عامة
+
+استخدم مشغل Microsoft Teams لبدء الأتمتات كلما أُنشئت محادثة جديدة. تشمل الأنماط الشائعة تلخيص الطلبات الواردة وتوجيه الرسائل العاجلة لفرق الدعم أو إنشاء مهام متابعة في أنظمة أخرى.
+
+<Tip>
+  تأكد من ربط Microsoft Teams تحت **Tools & Integrations** و
+  تفعيله في علامة تبويب **Triggers** لعملية النشر.
+</Tip>
+
+## تفعيل مشغل Microsoft Teams
+
+1. افتح عملية النشر في CrewAI AMP
+2. انتقل إلى علامة تبويب **Triggers**
+3. حدد موقع **Microsoft Teams** وبدّل مفتاح التبديل للتفعيل
+
+<Frame caption="اتصال مشغل Microsoft Teams">
+  <img
+    src="/images/enterprise/msteams-trigger.png"
+    alt="تفعيل أو تعطيل المشغلات بالتبديل"
+  />
+</Frame>
+
+## مثال: تلخيص سلسلة محادثة جديدة
+
+```python
+from teams_chat_created_crew import MicrosoftTeamsChatTrigger
+
+crew = MicrosoftTeamsChatTrigger().crew()
+result = crew.kickoff({
+    "crewai_trigger_payload": teams_payload,
+})
+print(result.raw)
+```
+
+يحلل الطاقم بيانات المحادثة الوصفية (الموضوع، وقت الإنشاء، قائمة الأعضاء) وينشئ خطة عمل للفريق المستقبل.
+
+## الاختبار المحلي
+
+اختبر تكامل مشغل Microsoft Teams محلياً باستخدام CrewAI CLI:
+
+```bash
+# عرض جميع المشغلات المتاحة
+crewai triggers list
+
+# محاكاة مشغل Microsoft Teams بحمولة واقعية
+crewai triggers run microsoft_teams/teams_message_created
+```
+
+سينفذ أمر `crewai triggers run` طاقمك بحمولة Teams كاملة، مما يتيح لك اختبار منطق التحليل قبل النشر.
+
+<Warning>
+  استخدم `crewai triggers run microsoft_teams/teams_message_created` (وليس `crewai
+  run`) لمحاكاة تنفيذ المشغل أثناء التطوير. بعد النشر، سيتلقى
+  طاقمك حمولة المشغل تلقائياً.
+</Warning>
+
+## استكشاف الأخطاء وإصلاحها
+
+- تأكد من أن اتصال Teams نشط؛ يجب تحديثه إذا سحب المستأجر الصلاحيات
+- اختبر محلياً بـ `crewai triggers run microsoft_teams/teams_message_created` لرؤية هيكل الحمولة بالضبط
+- تأكد من أن اشتراك webhook في Microsoft 365 لا يزال صالحاً إذا توقفت الحمولات عن الوصول
+- راجع سجلات التنفيذ لعدم تطابق شكل الحمولة — قد تحذف إشعارات Graph حقولاً عندما تكون المحادثة خاصة أو مقيدة
+- تذكر: استخدم `crewai triggers run` (وليس `crewai run`) لمحاكاة تنفيذ المشغل
@@ -0,0 +1,69 @@
+---
+title: "مشغل OneDrive"
+description: "أتمتة الاستجابات لنشاط ملفات OneDrive"
+icon: "cloud"
+mode: "wide"
+---
+
+## نظرة عامة
+
+ابدأ الأتمتات عند تغيير الملفات داخل OneDrive. يمكنك إنشاء ملخصات تدقيق وإخطار فرق الأمان بشأن المشاركة الخارجية أو تحديث أنظمة الأعمال اللاحقة ببيانات المستندات الوصفية الجديدة.
+
+<Tip>
+  اربط OneDrive في **Tools & Integrations** وبدّل المشغل لعملية
+  النشر.
+</Tip>
+
+## تفعيل مشغل OneDrive
+
+1. افتح عملية النشر في CrewAI AMP
+2. انتقل إلى علامة تبويب **Triggers**
+3. حدد موقع **OneDrive** وبدّل مفتاح التبديل للتفعيل
+
+<Frame caption="اتصال مشغل Microsoft OneDrive">
+  <img
+    src="/images/enterprise/onedrive-trigger.png"
+    alt="تفعيل أو تعطيل المشغلات بالتبديل"
+  />
+</Frame>
+
+## مثال: تدقيق صلاحيات الملفات
+
+```python
+from onedrive_file_crew import OneDriveFileTrigger
+
+crew = OneDriveFileTrigger().crew()
+crew.kickoff({
+    "crewai_trigger_payload": onedrive_payload,
+})
+```
+
+يفحص الطاقم بيانات الملف الوصفية ونشاط المستخدم وتغييرات الصلاحيات لإنتاج ملخص متوافق مع متطلبات الامتثال.
+
+## الاختبار المحلي
+
+اختبر تكامل مشغل OneDrive محلياً باستخدام CrewAI CLI:
+
+```bash
+# عرض جميع المشغلات المتاحة
+crewai triggers list
+
+# محاكاة مشغل OneDrive بحمولة واقعية
+crewai triggers run microsoft_onedrive/file_changed
+```
+
+سينفذ أمر `crewai triggers run` طاقمك بحمولة OneDrive كاملة، مما يتيح لك اختبار منطق التحليل قبل النشر.
+
+<Warning>
+  استخدم `crewai triggers run microsoft_onedrive/file_changed` (وليس `crewai run`)
+  لمحاكاة تنفيذ المشغل أثناء التطوير. بعد النشر، سيتلقى طاقمك
+  حمولة المشغل تلقائياً.
+</Warning>
+
+## استكشاف الأخطاء وإصلاحها
+
+- تأكد من أن الحساب المتصل لديه صلاحية قراءة بيانات الملف الوصفية المضمنة في webhook
+- اختبر محلياً بـ `crewai triggers run microsoft_onedrive/file_changed` لرؤية هيكل الحمولة بالضبط
+- إذا كان المشغل يعمل لكن الحمولة تفتقد `permissions`، تأكد من أن إعدادات المشاركة على مستوى الموقع تسمح لـ Graph بإرجاع هذا الحقل
+- للمستأجرين الكبار، صفّ الإشعارات مسبقاً حتى يعمل الطاقم فقط على المجلدات ذات الصلة
+- تذكر: استخدم `crewai triggers run` (وليس `crewai run`) لمحاكاة تنفيذ المشغل
@@ -0,0 +1,69 @@
+---
+title: "مشغل Outlook"
+description: "إطلاق الأتمتات من رسائل Outlook وتحديثات التقويم"
+icon: "microsoft"
+mode: "wide"
+---
+
+## نظرة عامة
+
+أتمت الاستجابات عندما يسلّم Outlook رسالة جديدة أو عند إزالة حدث من التقويم. تقوم الفرق عادة بتوجيه التصعيدات وإنشاء تذاكر أو تنبيه الحاضرين بالإلغاءات.
+
+<Tip>
+  اربط Outlook في **Tools & Integrations** وتأكد من تفعيل المشغل
+  لعملية النشر.
+</Tip>
+
+## تفعيل مشغل Outlook
+
+1. افتح عملية النشر في CrewAI AMP
+2. انتقل إلى علامة تبويب **Triggers**
+3. حدد موقع **Outlook** وبدّل مفتاح التبديل للتفعيل
+
+<Frame caption="اتصال مشغل Microsoft Outlook">
+  <img
+    src="/images/enterprise/outlook-trigger.png"
+    alt="تفعيل أو تعطيل المشغلات بالتبديل"
+  />
+</Frame>
+
+## مثال: تلخيص رسالة بريد إلكتروني جديدة
+
+```python
+from outlook_message_crew import OutlookMessageTrigger
+
+crew = OutlookMessageTrigger().crew()
+crew.kickoff({
+    "crewai_trigger_payload": outlook_payload,
+})
+```
+
+يستخرج الطاقم تفاصيل المرسل والموضوع ومعاينة النص والمرفقات قبل إنشاء استجابة منظمة.
+
+## الاختبار المحلي
+
+اختبر تكامل مشغل Outlook محلياً باستخدام CrewAI CLI:
+
+```bash
+# عرض جميع المشغلات المتاحة
+crewai triggers list
+
+# محاكاة مشغل Outlook بحمولة واقعية
+crewai triggers run microsoft_outlook/email_received
+```
+
+سينفذ أمر `crewai triggers run` طاقمك بحمولة Outlook كاملة، مما يتيح لك اختبار منطق التحليل قبل النشر.
+
+<Warning>
+  استخدم `crewai triggers run microsoft_outlook/email_received` (وليس `crewai run`)
+  لمحاكاة تنفيذ المشغل أثناء التطوير. بعد النشر، سيتلقى طاقمك
+  حمولة المشغل تلقائياً.
+</Warning>
+
+## استكشاف الأخطاء وإصلاحها
+
+- تحقق من أن موصل Outlook لا يزال مفوّضاً؛ يجب تجديد الاشتراك دورياً
+- اختبر محلياً بـ `crewai triggers run microsoft_outlook/email_received` لرؤية هيكل الحمولة بالضبط
+- إذا كانت المرفقات مفقودة، تأكد من أن اشتراك webhook يتضمن علامة `includeResourceData`
+- راجع سجلات التنفيذ عندما تفشل الأحداث في المطابقة — حمولات الإلغاء تفتقد قوائم الحاضرين حسب التصميم ويجب أن يأخذ الطاقم ذلك في الاعتبار
+- تذكر: استخدم `crewai triggers run` (وليس `crewai run`) لمحاكاة تنفيذ المشغل
@@ -0,0 +1,311 @@
+---
+title: "التحضير للنشر"
+description: "تأكد من جاهزية طاقمك أو تدفقك للنشر على CrewAI AMP"
+icon: "clipboard-check"
+mode: "wide"
+---
+
+<Note>
+  قبل النشر على CrewAI AMP، من الضروري التحقق من صحة بنية مشروعك.
+  يمكن نشر كل من الطواقم والتدفقات كـ "أتمتات"، لكن لهما بنى مشاريع
+  ومتطلبات مختلفة يجب استيفاؤها لنجاح النشر.
+</Note>
+
+## فهم الأتمتات
+
+في CrewAI AMP، **الأتمتات** هو المصطلح الشامل لمشاريع الذكاء الاصطناعي الوكيل القابلة للنشر. يمكن أن تكون الأتمتة إما:
+
+- **طاقم**: فريق مستقل من وكلاء الذكاء الاصطناعي يعملون معاً على المهام
+- **تدفق**: سير عمل مُنسّق يمكنه الجمع بين طواقم متعددة واستدعاءات LLM المباشرة والمنطق الإجرائي
+
+فهم النوع الذي تنشره ضروري لأن لهما بنى مشاريع ونقاط دخول مختلفة.
+
+## الطواقم مقابل التدفقات: الفروقات الرئيسية
+
+<CardGroup cols={2}>
+  <Card title="مشاريع الطاقم" icon="users">
+    فرق وكلاء ذكاء اصطناعي مستقلة مع `crew.py` يحدد الوكلاء والمهام. الأفضل للمهام المركزة والتعاونية.
+  </Card>
+  <Card title="مشاريع التدفق" icon="diagram-project">
+    سير عمل مُنسّق مع طواقم مضمنة في مجلد `crews/`. الأفضل للعمليات المعقدة متعددة المراحل.
+  </Card>
+</CardGroup>
+
+| الجانب | الطاقم | التدفق |
+|--------|--------|--------|
+| **بنية المشروع** | `src/project_name/` مع `crew.py` | `src/project_name/` مع مجلد `crews/` |
+| **موقع المنطق الرئيسي** | `src/project_name/crew.py` | `src/project_name/main.py` (فئة Flow) |
+| **دالة نقطة الدخول** | `run()` في `main.py` | `kickoff()` في `main.py` |
+| **نوع pyproject.toml** | `type = "crew"` | `type = "flow"` |
+| **أمر CLI للإنشاء** | `crewai create crew name` | `crewai create flow name` |
+| **موقع التهيئة** | `src/project_name/config/` | `src/project_name/crews/crew_name/config/` |
+| **يمكن أن يحتوي طواقم أخرى** | لا | نعم (في مجلد `crews/`) |
+
+## مرجع بنية المشروع
+
+### بنية مشروع الطاقم
+
+عند تشغيل `crewai create crew my_crew`، تحصل على هذه البنية:
+
+```
+my_crew/
+├── .gitignore
+├── pyproject.toml          # Must have type = "crew"
+├── README.md
+├── .env
+├── uv.lock                  # REQUIRED for deployment
+└── src/
+    └── my_crew/
+        ├── __init__.py
+        ├── main.py          # Entry point with run() function
+        ├── crew.py          # Crew class with @CrewBase decorator
+        ├── tools/
+        │   ├── custom_tool.py
+        │   └── __init__.py
+        └── config/
+            ├── agents.yaml  # Agent definitions
+            └── tasks.yaml   # Task definitions
+```
+
+<Warning>
+  بنية `src/project_name/` المتداخلة ضرورية للطواقم.
+  وضع الملفات في المستوى الخاطئ سيسبب فشل النشر.
+</Warning>
+
+### بنية مشروع التدفق
+
+عند تشغيل `crewai create flow my_flow`، تحصل على هذه البنية:
+
+```
+my_flow/
+├── .gitignore
+├── pyproject.toml          # Must have type = "flow"
+├── README.md
+├── .env
+├── uv.lock                  # REQUIRED for deployment
+└── src/
+    └── my_flow/
+        ├── __init__.py
+        ├── main.py          # Entry point with kickoff() function + Flow class
+        ├── crews/           # Embedded crews folder
+        │   └── poem_crew/
+        │       ├── __init__.py
+        │       ├── poem_crew.py  # Crew with @CrewBase decorator
+        │       └── config/
+        │           ├── agents.yaml
+        │           └── tasks.yaml
+        └── tools/
+            ├── __init__.py
+            └── custom_tool.py
+```
+
+<Info>
+  كلا الطواقم والتدفقات تستخدم بنية `src/project_name/`.
+  الفرق الرئيسي أن التدفقات لها مجلد `crews/` للطواقم المضمنة،
+  بينما الطواقم لها `crew.py` مباشرة في مجلد المشروع.
+</Info>
+
+## قائمة فحص ما قبل النشر
+
+استخدم هذه القائمة للتحقق من جاهزية مشروعك للنشر.
+
+### 1. التحقق من تهيئة pyproject.toml
+
+يجب أن يتضمن `pyproject.toml` قسم `[tool.crewai]` الصحيح:
+
+<Tabs>
+  <Tab title="للطواقم">
+    ```toml
+    [tool.crewai]
+    type = "crew"
+    ```
+  </Tab>
+  <Tab title="للتدفقات">
+    ```toml
+    [tool.crewai]
+    type = "flow"
+    ```
+  </Tab>
+</Tabs>
+
+<Warning>
+  إذا لم يتطابق `type` مع بنية مشروعك، سيفشل البناء أو
+  لن تعمل الأتمتة بشكل صحيح.
+</Warning>
+
+### 2. التأكد من وجود ملف uv.lock
+
+يستخدم CrewAI `uv` لإدارة الاعتماديات. يضمن ملف `uv.lock` بناءً قابلاً للتكرار وهو **مطلوب** للنشر.
+
+```bash
+# إنشاء أو تحديث ملف القفل
+uv lock
+
+# التحقق من وجوده
+ls -la uv.lock
+```
+
+إذا لم يكن الملف موجوداً، شغّل `uv lock` وارفعه إلى مستودعك:
+
+```bash
+uv lock
+git add uv.lock
+git commit -m "Add uv.lock for deployment"
+git push
+```
+
+### 3. التحقق من استخدام مُزخرف CrewBase
+
+**يجب أن تستخدم كل فئة طاقم مُزخرف `@CrewBase`.** ينطبق هذا على:
+
+- مشاريع الطاقم المستقلة
+- الطواقم المضمنة داخل مشاريع التدفق
+
+```python
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+from crewai.agents.agent_builder.base_agent import BaseAgent
+from typing import List
+
+@CrewBase  # This decorator is REQUIRED
+class MyCrew():
+    """My crew description"""
+
+    agents: List[BaseAgent]
+    tasks: List[Task]
+
+    @agent
+    def my_agent(self) -> Agent:
+        return Agent(
+            config=self.agents_config['my_agent'],  # type: ignore[index]
+            verbose=True
+        )
+
+    @task
+    def my_task(self) -> Task:
+        return Task(
+            config=self.tasks_config['my_task']  # type: ignore[index]
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        return Crew(
+            agents=self.agents,
+            tasks=self.tasks,
+            process=Process.sequential,
+            verbose=True,
+        )
+```
+
+<Warning>
+  إذا نسيت مُزخرف `@CrewBase`، سيفشل النشر بأخطاء حول
+  تهيئات الوكلاء أو المهام المفقودة.
+</Warning>
+
+### 4. التحقق من نقاط دخول المشروع
+
+كل من الطواقم والتدفقات لها نقطة دخول في `src/project_name/main.py`:
+
+<Tabs>
+  <Tab title="للطواقم">
+    تستخدم نقطة الدخول دالة `run()`:
+
+    ```python
+    # src/my_crew/main.py
+    from my_crew.crew import MyCrew
+
+    def run():
+        """Run the crew."""
+        inputs = {'topic': 'AI in Healthcare'}
+        result = MyCrew().crew().kickoff(inputs=inputs)
+        return result
+
+    if __name__ == "__main__":
+        run()
+    ```
+  </Tab>
+  <Tab title="للتدفقات">
+    تستخدم نقطة الدخول دالة `kickoff()` مع فئة Flow:
+
+    ```python
+    # src/my_flow/main.py
+    from crewai.flow import Flow, listen, start
+    from my_flow.crews.poem_crew.poem_crew import PoemCrew
+
+    class MyFlow(Flow):
+        @start()
+        def begin(self):
+            # Flow logic here
+            result = PoemCrew().crew().kickoff(inputs={...})
+            return result
+
+    def kickoff():
+        """Run the flow."""
+        MyFlow().kickoff()
+
+    if __name__ == "__main__":
+        kickoff()
+    ```
+  </Tab>
+</Tabs>
+
+### 5. تحضير متغيرات البيئة
+
+قبل النشر، تأكد من أن لديك:
+
+1. **مفاتيح API لـ LLM** جاهزة (OpenAI، Anthropic، Google، إلخ.)
+2. **مفاتيح API للأدوات** إذا كنت تستخدم أدوات خارجية (Serper، إلخ.)
+
+<Info>
+  إذا كان مشروعك يعتمد على حزم من **سجل PyPI خاص**، ستحتاج أيضاً لتهيئة
+  بيانات اعتماد مصادقة السجل كمتغيرات بيئة. راجع
+  دليل [سجلات الحزم الخاصة](/ar/enterprise/guides/private-package-registry) للتفاصيل.
+</Info>
+
+<Tip>
+  اختبر مشروعك محلياً بنفس متغيرات البيئة قبل النشر
+  لاكتشاف مشاكل التهيئة مبكراً.
+</Tip>
+
+## أوامر التحقق السريع
+
+شغّل هذه الأوامر من جذر مشروعك للتحقق السريع من إعدادك:
+
+```bash
+# 1. Check project type in pyproject.toml
+grep -A2 "\[tool.crewai\]" pyproject.toml
+
+# 2. Verify uv.lock exists
+ls -la uv.lock || echo "ERROR: uv.lock missing! Run 'uv lock'"
+
+# 3. Verify src/ structure exists
+ls -la src/*/main.py 2>/dev/null || echo "No main.py found in src/"
+
+# 4. For Crews - verify crew.py exists
+ls -la src/*/crew.py 2>/dev/null || echo "No crew.py (expected for Crews)"
+
+# 5. For Flows - verify crews/ folder exists
+ls -la src/*/crews/ 2>/dev/null || echo "No crews/ folder (expected for Flows)"
+
+# 6. Check for CrewBase usage
+grep -r "@CrewBase" . --include="*.py"
+```
+
+## أخطاء الإعداد الشائعة
+
+| الخطأ | العرض | الإصلاح |
+|-------|-------|---------|
+| `uv.lock` مفقود | فشل البناء أثناء حل الاعتماديات | شغّل `uv lock` وارفعه |
+| `type` خاطئ في pyproject.toml | نجاح البناء لكن فشل وقت التشغيل | غيّر إلى النوع الصحيح |
+| مُزخرف `@CrewBase` مفقود | أخطاء "Config not found" | أضف المُزخرف لجميع فئات الطاقم |
+| ملفات في الجذر بدل `src/` | نقطة الدخول غير موجودة | انقلها إلى `src/project_name/` |
+| `run()` أو `kickoff()` مفقودة | لا يمكن بدء الأتمتة | أضف دالة الدخول الصحيحة |
+
+## الخطوات التالية
+
+بمجرد اجتياز مشروعك لجميع عناصر القائمة، أنت جاهز للنشر:
+
+<Card title="النشر على AMP" icon="rocket" href="/ar/enterprise/guides/deploy-to-amp">
+  اتبع دليل النشر لنشر طاقمك أو تدفقك على CrewAI AMP باستخدام
+  CLI أو واجهة الويب أو تكامل CI/CD.
+</Card>
@@ -0,0 +1,263 @@
+---
+title: "سجلات الحزم الخاصة"
+description: "تثبيت حزم Python الخاصة من سجلات PyPI المصادق عليها في CrewAI AMP"
+icon: "lock"
+mode: "wide"
+---
+
+<Note>
+  يغطي هذا الدليل كيفية تهيئة مشروع CrewAI لتثبيت حزم Python
+  من سجلات PyPI الخاصة (Azure DevOps Artifacts، GitHub Packages، GitLab، AWS CodeArtifact، إلخ.)
+  عند النشر على CrewAI AMP.
+</Note>
+
+## متى تحتاج هذا
+
+إذا كان مشروعك يعتمد على حزم Python داخلية أو خاصة مستضافة على سجل خاص
+بدلاً من PyPI العام، ستحتاج إلى:
+
+1. إخبار UV **أين** يجد الحزمة (رابط فهرس)
+2. إخبار UV **أي** حزم تأتي من ذلك الفهرس (تعيين مصدر)
+3. تقديم **بيانات اعتماد** حتى يتمكن UV من المصادقة أثناء التثبيت
+
+يستخدم CrewAI AMP [UV](https://docs.astral.sh/uv/) لحل وتثبيت الاعتماديات.
+يدعم UV السجلات الخاصة المصادق عليها عبر تهيئة `pyproject.toml` مع
+متغيرات بيئة لبيانات الاعتماد.
+
+## الخطوة 1: تهيئة pyproject.toml
+
+ثلاثة أجزاء تعمل معاً في `pyproject.toml`:
+
+### 1أ. التصريح بالاعتمادية
+
+أضف الحزمة الخاصة إلى `[project.dependencies]` كأي اعتمادية أخرى:
+
+```toml
+[project]
+dependencies = [
+    "crewai[tools]>=0.100.1,<1.0.0",
+    "my-private-package>=1.2.0",
+]
+```
+
+### 1ب. تعريف الفهرس
+
+سجّل سجلك الخاص كفهرس مسمّى تحت `[[tool.uv.index]]`:
+
+```toml
+[[tool.uv.index]]
+name = "my-private-registry"
+url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
+explicit = true
+```
+
+<Info>
+  حقل `name` مهم — يستخدمه UV لبناء أسماء متغيرات البيئة
+  للمصادقة (راجع [الخطوة 2](#step-2-set-authentication-credentials) أدناه).
+
+  تعيين `explicit = true` يعني أن UV لن يبحث في هذا الفهرس عن كل حزمة — فقط
+  الحزم التي تعيّنها صراحة له في `[tool.uv.sources]`. يتجنب ذلك الاستعلامات غير الضرورية
+  ضد سجلك الخاص ويحمي من هجمات ارتباك الاعتماديات.
+</Info>
+
+### 1ج. تعيين الحزمة للفهرس
+
+أخبر UV أي حزم يجب حلها من فهرسك الخاص باستخدام `[tool.uv.sources]`:
+
+```toml
+[tool.uv.sources]
+my-private-package = { index = "my-private-registry" }
+```
+
+### مثال كامل
+
+```toml
+[project]
+name = "my-crew-project"
+version = "0.1.0"
+requires-python = ">=3.10,<=3.13"
+dependencies = [
+    "crewai[tools]>=0.100.1,<1.0.0",
+    "my-private-package>=1.2.0",
+]
+
+[tool.crewai]
+type = "crew"
+
+[[tool.uv.index]]
+name = "my-private-registry"
+url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
+explicit = true
+
+[tool.uv.sources]
+my-private-package = { index = "my-private-registry" }
+```
+
+بعد تحديث `pyproject.toml`، أعد إنشاء ملف القفل:
+
+```bash
+uv lock
+```
+
+<Warning>
+  ارفع دائماً `uv.lock` المُحدّث مع تغييرات `pyproject.toml`.
+  ملف القفل مطلوب للنشر — راجع [التحضير للنشر](/ar/enterprise/guides/prepare-for-deployment).
+</Warning>
+
+## الخطوة 2: تعيين بيانات اعتماد المصادقة
+
+يصادق UV ضد الفهارس الخاصة باستخدام متغيرات بيئة تتبع اصطلاح تسمية
+بناءً على اسم الفهرس الذي حددته في `pyproject.toml`:
+
+```
+UV_INDEX_{UPPER_NAME}_USERNAME
+UV_INDEX_{UPPER_NAME}_PASSWORD
+```
+
+حيث `{UPPER_NAME}` هو اسم فهرسك محوّلاً إلى **أحرف كبيرة** مع **استبدال الشرطات بشرطات سفلية**.
+
+على سبيل المثال، فهرس باسم `my-private-registry` يستخدم:
+
+| المتغير | القيمة |
+|---------|--------|
+| `UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME` | اسم مستخدم السجل أو اسم الرمز |
+| `UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD` | كلمة مرور السجل أو الرمز/PAT |
+
+<Warning>
+  هذه المتغيرات **يجب** إضافتها عبر إعدادات **Environment Variables** في CrewAI AMP —
+  إما عالمياً أو على مستوى النشر. لا يمكن تعيينها في ملفات `.env` أو ترميزها في مشروعك.
+
+  راجع [تعيين متغيرات البيئة في AMP](#setting-environment-variables-in-amp) أدناه.
+</Warning>
+
+## مرجع مزودي السجلات
+
+يوضح الجدول أدناه تنسيق رابط الفهرس وقيم بيانات الاعتماد لمزودي السجلات الشائعين.
+استبدل القيم المؤقتة بتفاصيل مؤسستك وخلاصتك الفعلية.
+
+| المزود | رابط الفهرس | اسم المستخدم | كلمة المرور |
+|--------|-------------|--------------|-------------|
+| **Azure DevOps Artifacts** | `https://pkgs.dev.azure.com/{org}/_packaging/{feed}/pypi/simple/` | أي نص غير فارغ (مثل `token`) | Personal Access Token (PAT) بنطاق Packaging Read |
+| **GitHub Packages** | `https://pypi.pkg.github.com/{owner}/simple/` | اسم مستخدم GitHub | Personal Access Token (classic) بنطاق `read:packages` |
+| **GitLab Package Registry** | `https://gitlab.com/api/v4/projects/{project_id}/packages/pypi/simple/` | `__token__` | Project أو Personal Access Token بنطاق `read_api` |
+| **AWS CodeArtifact** | استخدم الرابط من `aws codeartifact get-repository-endpoint` | `aws` | رمز من `aws codeartifact get-authorization-token` |
+| **Google Artifact Registry** | `https://{region}-python.pkg.dev/{project}/{repo}/simple/` | `_json_key_base64` | مفتاح حساب الخدمة بتشفير Base64 |
+| **JFrog Artifactory** | `https://{instance}.jfrog.io/artifactory/api/pypi/{repo}/simple/` | اسم المستخدم أو البريد الإلكتروني | مفتاح API أو رمز الهوية |
+| **مستضاف ذاتياً (devpi، Nexus، إلخ.)** | رابط Simple API لسجلك | اسم مستخدم السجل | كلمة مرور السجل |
+
+<Tip>
+  لـ **AWS CodeArtifact**، تنتهي صلاحية رمز التفويض دورياً.
+  ستحتاج لتحديث قيمة `UV_INDEX_*_PASSWORD` عند انتهاء صلاحيتها.
+  فكّر في أتمتة هذا في خط أنابيب CI/CD.
+</Tip>
+
+## تعيين متغيرات البيئة في AMP
+
+يجب تهيئة بيانات اعتماد السجل الخاص كمتغيرات بيئة في CrewAI AMP.
+لديك خياران:
+
+<Tabs>
+  <Tab title="واجهة الويب">
+    1. سجّل الدخول إلى [CrewAI AMP](https://app.crewai.com)
+    2. انتقل إلى أتمتتك
+    3. افتح علامة تبويب **Environment Variables**
+    4. أضف كل متغير (`UV_INDEX_*_USERNAME` و`UV_INDEX_*_PASSWORD`) مع قيمته
+
+    راجع خطوة [النشر على AMP — تعيين متغيرات البيئة](/ar/enterprise/guides/deploy-to-amp#set-environment-variables) للتفاصيل.
+  </Tab>
+  <Tab title="النشر عبر CLI">
+    أضف المتغيرات إلى ملف `.env` المحلي قبل تشغيل `crewai deploy create`.
+    سينقلها CLI بأمان إلى المنصة:
+
+    ```bash
+    # .env
+    OPENAI_API_KEY=sk-...
+    UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
+    UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat-here
+    ```
+
+    ```bash
+    crewai deploy create
+    ```
+  </Tab>
+</Tabs>
+
+<Warning>
+  **لا ترفع** أبداً بيانات الاعتماد إلى مستودعك. استخدم متغيرات بيئة AMP لجميع الأسرار.
+  يجب إدراج ملف `.env` في `.gitignore`.
+</Warning>
+
+لتحديث بيانات الاعتماد في نشر حالي، راجع [تحديث طاقمك — متغيرات البيئة](/ar/enterprise/guides/update-crew).
+
+## كيف يعمل الكل معاً
+
+عندما يبني CrewAI AMP أتمتتك، يعمل تدفق الحل هكذا:
+
+<Steps>
+  <Step title="بدء البناء">
+    يسحب AMP مستودعك ويقرأ `pyproject.toml` و`uv.lock`.
+  </Step>
+  <Step title="UV يحل الاعتماديات">
+    يقرأ UV `[tool.uv.sources]` لتحديد أي فهرس يجب أن تأتي منه كل حزمة.
+  </Step>
+  <Step title="UV يصادق">
+    لكل فهرس خاص، يبحث UV عن `UV_INDEX_{NAME}_USERNAME` و`UV_INDEX_{NAME}_PASSWORD`
+    من متغيرات البيئة التي هيأتها في AMP.
+  </Step>
+  <Step title="تثبيت الحزم">
+    يحمّل UV ويثبّت جميع الحزم — العامة (من PyPI) والخاصة (من سجلك).
+  </Step>
+  <Step title="تشغيل الأتمتة">
+    يبدأ طاقمك أو تدفقك مع توفر جميع الاعتماديات.
+  </Step>
+</Steps>
+
+## استكشاف الأخطاء وإصلاحها
+
+### أخطاء المصادقة أثناء البناء
+
+**العرض**: فشل البناء بـ `401 Unauthorized` أو `403 Forbidden` عند حل حزمة خاصة.
+
+**تحقق من**:
+- أسماء متغيرات البيئة `UV_INDEX_*` تتطابق مع اسم فهرسك بالضبط (أحرف كبيرة، شرطات → شرطات سفلية)
+- بيانات الاعتماد معيّنة في متغيرات بيئة AMP، وليس فقط في `.env` محلي
+- الرمز/PAT لديه صلاحيات القراءة المطلوبة لخلاصة الحزم
+- الرمز لم تنتهِ صلاحيته (ذو صلة خاصة لـ AWS CodeArtifact)
+
+### الحزمة غير موجودة
+
+**العرض**: `No matching distribution found for my-private-package`.
+
+**تحقق من**:
+- رابط الفهرس في `pyproject.toml` ينتهي بـ `/simple/`
+- إدخال `[tool.uv.sources]` يعيّن اسم الحزمة الصحيح لاسم الفهرس الصحيح
+- الحزمة منشورة فعلاً في سجلك الخاص
+- شغّل `uv lock` محلياً بنفس بيانات الاعتماد للتحقق من عمل الحل
+
+### تعارضات ملف القفل
+
+**العرض**: فشل `uv lock` أو نتائج غير متوقعة بعد إضافة فهرس خاص.
+
+**الحل**: عيّن بيانات الاعتماد محلياً وأعد الإنشاء:
+
+```bash
+export UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
+export UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat
+uv lock
+```
+
+ثم ارفع `uv.lock` المُحدّث.
+
+## أدلة ذات صلة
+
+<CardGroup cols={3}>
+  <Card title="التحضير للنشر" icon="clipboard-check" href="/ar/enterprise/guides/prepare-for-deployment">
+    تحقق من بنية المشروع والاعتماديات قبل النشر.
+  </Card>
+  <Card title="النشر على AMP" icon="rocket" href="/ar/enterprise/guides/deploy-to-amp">
+    انشر طاقمك أو تدفقك وهيّئ متغيرات البيئة.
+  </Card>
+  <Card title="تحديث طاقمك" icon="arrows-rotate" href="/ar/enterprise/guides/update-crew">
+    حدّث متغيرات البيئة وادفع التغييرات إلى نشر قائم.
+  </Card>
+</CardGroup>
@@ -0,0 +1,112 @@
+---
+title: "تصدير مكون React"
+description: "تعلم كيفية تصدير ودمج مكونات React من CrewAI AMP في تطبيقاتك"
+icon: "react"
+mode: "wide"
+---
+
+يشرح هذا الدليل كيفية تصدير طواقم CrewAI AMP كمكونات React ودمجها في تطبيقاتك.
+
+## تصدير مكون React
+
+<Steps>
+    <Step title="تصدير المكون">
+        انقر على القائمة (ثلاث نقاط على يمين طاقمك المنشور) واختر خيار التصدير واحفظ الملف محلياً. سنستخدم `CrewLead.jsx` في مثالنا.
+
+        <Frame>
+            <img src="/images/enterprise/export-react-component.png" alt="تصدير مكون React" />
+        </Frame>
+    </Step>
+
+</Steps>
+
+## إعداد بيئة React
+
+لتشغيل مكون React هذا محلياً، ستحتاج لإعداد بيئة تطوير React ودمج هذا المكون في مشروع React.
+
+<Steps>
+    <Step title="تثبيت Node.js">
+        - حمّل وثبّت Node.js من الموقع الرسمي: https://nodejs.org/
+        - اختر إصدار LTS (الدعم طويل المدى) للاستقرار.
+    </Step>
+
+    <Step title="إنشاء مشروع React جديد">
+        - افتح Command Prompt أو PowerShell
+        - انتقل إلى المجلد الذي تريد إنشاء مشروعك فيه
+        - شغّل الأمر التالي لإنشاء مشروع React جديد:
+
+            ```bash
+            npx create-react-app my-crew-app
+            ```
+        - انتقل إلى مجلد المشروع:
+
+            ```bash
+            cd my-crew-app
+            ```
+    </Step>
+
+    <Step title="تثبيت الاعتماديات اللازمة">
+        ```bash
+        npm install react-dom
+        ```
+    </Step>
+
+    <Step title="إنشاء مكون CrewLead">
+        - انقل الملف المُحمّل `CrewLead.jsx` إلى مجلد `src` في مشروعك.
+    </Step>
+
+    <Step title="تعديل App.js لاستخدام مكون CrewLead">
+        - افتح `src/App.js`
+        - استبدل محتوياته بشيء مثل هذا:
+
+        ```jsx
+        import React from 'react';
+        import CrewLead from './CrewLead';
+
+        function App() {
+            return (
+                <div className="App">
+                    <CrewLead baseUrl="YOUR_API_BASE_URL" bearerToken="YOUR_BEARER_TOKEN" />
+                </div>
+            );
+        }
+
+        export default App;
+        ```
+        - استبدل `YOUR_API_BASE_URL` و`YOUR_BEARER_TOKEN` بالقيم الفعلية لـ API.
+    </Step>
+
+    <Step title="بدء خادم التطوير">
+        - في مجلد مشروعك، شغّل:
+
+            ```bash
+            npm start
+            ```
+        - سيبدأ خادم التطوير، ويجب أن يفتح متصفح الويب الافتراضي تلقائياً على `http://localhost:3000`، حيث سترى تطبيق React يعمل.
+    </Step>
+
+</Steps>
+
+## التخصيص
+
+يمكنك بعد ذلك تخصيص `CrewLead.jsx` لإضافة اللون والعنوان وغيرها.
+
+<Frame>
+  <img
+    src="/images/enterprise/customise-react-component.png"
+    alt="تخصيص مكون React"
+  />
+</Frame>
+<Frame>
+  <img
+    src="/images/enterprise/customise-react-component-2.png"
+    alt="تخصيص مكون React"
+  />
+</Frame>
+
+## الخطوات التالية
+
+- خصّص تنسيق المكون ليتوافق مع تصميم تطبيقك
+- أضف خصائص إضافية للتهيئة
+- ادمج مع إدارة حالة تطبيقك
+- أضف معالجة الأخطاء وحالات التحميل
@@ -0,0 +1,50 @@
+---
+title: "مشغل Salesforce"
+description: "تشغيل طواقم CrewAI من سير عمل Salesforce لأتمتة CRM"
+icon: "salesforce"
+mode: "wide"
+---
+
+يمكن تشغيل CrewAI AMP من Salesforce لأتمتة سير عمل إدارة علاقات العملاء وتعزيز عمليات المبيعات.
+
+## نظرة عامة
+
+Salesforce هي منصة رائدة لإدارة علاقات العملاء (CRM) تساعد الشركات على تبسيط عمليات المبيعات والخدمة والتسويق. من خلال إعداد مشغلات CrewAI من Salesforce، يمكنك:
+
+- أتمتة تسجيل وتأهيل العملاء المحتملين
+- إنشاء مواد مبيعات مخصصة
+- تعزيز خدمة العملاء بردود مدعومة بالذكاء الاصطناعي
+- تبسيط تحليل البيانات وإعداد التقارير
+
+## عرض توضيحي
+
+<iframe
+  className="w-full aspect-video rounded-xl"
+  src="https://www.youtube.com/embed/oJunVqjjfu4"
+  title="عرض توضيحي لمشغل CrewAI + Salesforce"
+  frameBorder="0"
+  allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
+  allowFullScreen
+></iframe>
+
+## البدء
+
+لإعداد مشغلات Salesforce:
+
+1. **تواصل مع الدعم**: تواصل مع دعم CrewAI AMP للمساعدة في إعداد مشغل Salesforce
+2. **مراجعة المتطلبات**: تأكد من أن لديك صلاحيات Salesforce اللازمة والوصول إلى API
+3. **تهيئة الاتصال**: اعمل مع فريق الدعم لإنشاء الاتصال بين CrewAI ومثيل Salesforce الخاص بك
+4. **اختبار المشغلات**: تحقق من عمل المشغلات بشكل صحيح مع حالات الاستخدام المحددة
+
+## حالات الاستخدام
+
+سيناريوهات Salesforce + CrewAI الشائعة تشمل:
+
+- **معالجة العملاء المحتملين**: تحليل وتسجيل العملاء المحتملين الوافدين تلقائياً
+- **إنشاء العروض**: إنشاء عروض مخصصة بناءً على بيانات الفرص
+- **رؤى العملاء**: إنشاء تقارير تحليلية من سجل تفاعلات العملاء
+- **أتمتة المتابعة**: إنشاء رسائل متابعة وتوصيات مخصصة
+
+## الخطوات التالية
+
+للحصول على تعليمات الإعداد المفصلة وخيارات التهيئة المتقدمة، يرجى التواصل مع دعم CrewAI AMP الذي يمكنه تقديم إرشادات مخصصة لبيئة Salesforce واحتياجات عملك المحددة.
@@ -0,0 +1,62 @@
+---
+title: "مشغل Slack"
+description: "تشغيل طواقم CrewAI مباشرة من Slack باستخدام أوامر الشرطة المائلة"
+icon: "slack"
+mode: "wide"
+---
+
+يشرح هذا الدليل كيفية بدء طاقم مباشرة من Slack باستخدام مشغلات CrewAI.
+
+## المتطلبات المسبقة
+
+- مشغل CrewAI لـ Slack مُثبّت ومتصل بمساحة عمل Slack
+- طاقم واحد على الأقل مُهيأ في CrewAI
+
+## خطوات الإعداد
+
+<Steps>
+    <Step title="التأكد من إعداد مشغل CrewAI لـ Slack">
+        في لوحة تحكم CrewAI، انتقل إلى قسم **Triggers**.
+
+        <Frame>
+            <img src="/images/enterprise/slack-integration.png" alt="تكامل CrewAI مع Slack" />
+        </Frame>
+
+        تحقق من أن Slack مدرج ومتصل.
+    </Step>
+    <Step title="فتح قناة Slack">
+        - انتقل إلى القناة التي تريد تشغيل الطاقم منها.
+        - اكتب أمر الشرطة المائلة "**/kickoff**" لبدء عملية تشغيل الطاقم.
+        - يجب أن ترى "**Kickoff crew**" تظهر أثناء الكتابة:
+            <Frame>
+                <img src="/images/enterprise/kickoff-slack-crew.png" alt="تشغيل الطاقم" />
+            </Frame>
+        - اضغط Enter أو اختر خيار "**Kickoff crew**". سيظهر مربع حوار بعنوان "**Kickoff an AI Crew**".
+    </Step>
+    <Step title="اختيار الطاقم الذي تريد بدءه">
+        - في القائمة المنسدلة "**Select of the crews online:**"، اختر الطاقم الذي تريد بدءه.
+        - في المثال أدناه، تم اختيار "**prep-for-meeting**":
+            <Frame>
+                <img src="/images/enterprise/kickoff-slack-crew-dropdown.png" alt="القائمة المنسدلة لتشغيل الطاقم" />
+            </Frame>
+        - إذا كان طاقمك يتطلب أي مدخلات، انقر على زر "**Add Inputs**" لتقديمها.
+            <Note>
+                زر "**Add Inputs**" معروض في المثال أعلاه لكن لم يُنقر عليه بعد.
+            </Note>
+    </Step>
+    <Step title="النقر على Kickoff والانتظار حتى يكتمل الطاقم">
+        - بمجرد اختيار الطاقم وإضافة أي مدخلات ضرورية، انقر على "**Kickoff**" لبدء الطاقم.
+            <Frame>
+                <img src="/images/enterprise/kickoff-slack-crew-kickoff.png" alt="تشغيل الطاقم" />
+            </Frame>
+        - سيبدأ الطاقم بالتنفيذ وسترى النتائج في قناة Slack.
+            <Frame>
+                <img src="/images/enterprise/kickoff-slack-crew-results.png" alt="نتائج تشغيل الطاقم" />
+            </Frame>
+    </Step>
+</Steps>
+
+## نصائح
+
+- تأكد من أن لديك الصلاحيات اللازمة لاستخدام أمر `/kickoff` في مساحة عمل Slack.
+- إذا لم تر الطاقم المطلوب في القائمة المنسدلة، تأكد من أنه مُهيأ بشكل صحيح ومتصل في CrewAI.
@@ -0,0 +1,91 @@
+---
+title: "إدارة الفريق"
+description: "تعلم كيفية دعوة وإدارة أعضاء الفريق في مؤسسة CrewAI AMP"
+icon: "users"
+mode: "wide"
+---
+
+بصفتك مسؤولاً عن حساب CrewAI AMP، يمكنك بسهولة دعوة أعضاء جدد للانضمام إلى مؤسستك. يرشدك هذا الدليل خلال العملية خطوة بخطوة.
+
+## دعوة أعضاء الفريق
+
+<Steps>
+  <Step title="الوصول إلى صفحة الإعدادات">
+    - سجّل الدخول إلى حساب CrewAI AMP - ابحث عن أيقونة الترس في
+    الزاوية العلوية اليمنى من لوحة التحكم - انقر على أيقونة الترس للوصول إلى
+    صفحة **Settings**:
+    <Frame caption="صفحة الإعدادات">
+      <img src="/images/enterprise/settings-page.png" alt="صفحة الإعدادات" />
+    </Frame>
+  </Step>
+  <Step title="الانتقال إلى قسم الأعضاء">
+    - في صفحة الإعدادات، سترى علامة تبويب `Members` - انقر على علامة تبويب `Members`
+    للوصول إلى صفحة **Members**:
+    <Frame caption="علامة تبويب الأعضاء">
+      <img src="/images/enterprise/members-tab.png" alt="علامة تبويب الأعضاء" />
+    </Frame>
+  </Step>
+  <Step title="دعوة أعضاء جدد">
+    - في قسم الأعضاء، سترى قائمة بالأعضاء الحاليين (بما فيهم
+    أنت) - حدد موقع حقل إدخال `Email` - أدخل عنوان البريد الإلكتروني للشخص
+    الذي تريد دعوته - انقر على زر `Invite` لإرسال الدعوة
+  </Step>
+  <Step title="التكرار حسب الحاجة">
+    - يمكنك تكرار هذه العملية لدعوة أعضاء فريق متعددين - سيتلقى كل عضو
+    مدعو دعوة عبر البريد الإلكتروني للانضمام إلى مؤسستك
+  </Step>
+</Steps>
+
+## إضافة الأدوار
+
+يمكنك إضافة أدوار لأعضاء فريقك للتحكم في وصولهم إلى أجزاء مختلفة من المنصة.
+
+<Steps>
+  <Step title="الوصول إلى صفحة الإعدادات">
+    - سجّل الدخول إلى حساب CrewAI AMP - ابحث عن أيقونة الترس في
+    الزاوية العلوية اليمنى من لوحة التحكم - انقر على أيقونة الترس للوصول إلى
+    صفحة **Settings**:
+    <Frame>
+      <img src="/images/enterprise/settings-page.png" alt="صفحة الإعدادات" />
+    </Frame>
+  </Step>
+  <Step title="الانتقال إلى قسم الأعضاء">
+    - في صفحة الإعدادات، سترى علامة تبويب `Roles` - انقر على علامة تبويب `Roles`
+    للوصول إلى صفحة **Roles**.
+    <Frame>
+      <img src="/images/enterprise/roles-tab.png" alt="علامة تبويب الأدوار" />
+    </Frame>
+    - انقر على زر `Add Role` لإضافة دور جديد. - أدخل
+    تفاصيل وصلاحيات الدور وانقر على زر `Create Role` لإنشاء
+    الدور.
+    <Frame>
+      <img src="/images/enterprise/add-role-modal.png" alt="نافذة إضافة الدور" />
+    </Frame>
+  </Step>
+  <Step title="إضافة أدوار للأعضاء">
+    - في قسم الأعضاء، سترى قائمة بالأعضاء الحاليين (بما فيهم
+    أنت)
+    <Frame>
+      <img
+        src="/images/enterprise/member-accepted-invitation.png"
+        alt="العضو قبل الدعوة"
+      />
+    </Frame>
+    - بمجرد قبول العضو للدعوة، يمكنك إضافة دور
+    له. - عد إلى علامة تبويب `Roles` - انتقل إلى العضو الذي تريد إضافة
+    دور له وتحت عمود `Role`، انقر على القائمة المنسدلة - اختر الدور
+    الذي تريد إضافته للعضو - انقر على زر `Update` لحفظ الدور
+    <Frame>
+      <img src="/images/enterprise/assign-role.png" alt="إضافة دور للعضو" />
+    </Frame>
+  </Step>
+</Steps>
+
+## ملاحظات مهمة
+
+- **صلاحيات المسؤول**: فقط المستخدمون ذوو الصلاحيات الإدارية يمكنهم دعوة أعضاء جدد
+- **دقة البريد الإلكتروني**: تأكد من صحة عناوين البريد الإلكتروني لأعضاء فريقك
+- **قبول الدعوة**: سيحتاج الأعضاء المدعوون لقبول الدعوة للانضمام إلى مؤسستك
+- **إشعارات البريد الإلكتروني**: قد ترغب في إعلام أعضاء فريقك بالتحقق من بريدهم الإلكتروني (بما في ذلك مجلدات البريد غير المرغوب) للدعوة
+
+باتباع هذه الخطوات، يمكنك بسهولة توسيع فريقك والتعاون بشكل أكثر فعالية داخل مؤسسة CrewAI AMP.
@@ -0,0 +1,154 @@
+---
+title: مستودع الأدوات
+description: "استخدام مستودع الأدوات لإدارة أدواتك"
+icon: "toolbox"
+mode: "wide"
+---
+
+## نظرة عامة
+
+مستودع الأدوات هو مدير حزم لأدوات CrewAI. يتيح للمستخدمين نشر وتثبيت وإدارة الأدوات التي تتكامل مع طواقم وتدفقات CrewAI.
+
+يمكن أن تكون الأدوات:
+
+- **خاصة**: متاحة فقط داخل مؤسستك (افتراضي)
+- **عامة**: متاحة لجميع مستخدمي CrewAI إذا نُشرت بعلامة `--public`
+
+المستودع ليس نظام تحكم في الإصدارات. استخدم Git لتتبع تغييرات الكود وتمكين التعاون.
+
+## المتطلبات المسبقة
+
+قبل استخدام مستودع الأدوات، تأكد من أن لديك:
+
+- حساب [CrewAI AMP](https://app.crewai.com)
+- [CrewAI CLI](/ar/concepts/cli#cli) مُثبّت
+- uv>=0.5.0 مُثبّت. راجع [كيفية الترقية](https://docs.astral.sh/uv/getting-started/installation/#upgrading-uv)
+- [Git](https://git-scm.com) مُثبّت ومُهيأ
+- صلاحيات الوصول للنشر أو التثبيت في مؤسسة CrewAI AMP
+
+## تثبيت الأدوات
+
+لتثبيت أداة:
+
+```bash
+crewai tool install <tool-name>
+```
+
+يثبّت هذا الأداة ويضيفها إلى `pyproject.toml`.
+
+يمكنك استخدام الأداة باستيرادها وإضافتها إلى وكلائك:
+
+```python
+from your_tool.tool import YourTool
+
+custom_tool = YourTool()
+
+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=[custom_tool],
+    verbose=True
+)
+```
+
+## إضافة حزم أخرى بعد تثبيت أداة
+
+بعد تثبيت أداة من مستودع أدوات CrewAI AMP، تحتاج لاستخدام أمر `crewai uv` لإضافة حزم أخرى لمشروعك.
+استخدام أوامر `uv` المباشرة سيفشل لأن المصادقة لمستودع الأدوات يتم التعامل معها عبر CLI. باستخدام أمر `crewai uv`، يمكنك إضافة حزم أخرى لمشروعك دون القلق بشأن المصادقة.
+يمكن استخدام أي أمر `uv` مع أمر `crewai uv`، مما يجعله أداة قوية لإدارة اعتماديات مشروعك دون عناء إدارة المصادقة عبر متغيرات البيئة أو طرق أخرى.
+
+لنفرض أنك ثبّت أداة مخصصة من مستودع أدوات CrewAI AMP تسمى "my-tool":
+
+```bash
+crewai tool install my-tool
+```
+
+والآن تريد إضافة حزمة أخرى لمشروعك، يمكنك استخدام الأمر التالي:
+
+```bash
+crewai uv add requests
+```
+
+أوامر أخرى مثل `uv sync` أو `uv remove` يمكن أيضاً استخدامها مع أمر `crewai uv`:
+
+```bash
+crewai uv sync
+```
+
+```bash
+crewai uv remove requests
+```
+
+سيضيف هذا الحزمة لمشروعك ويحدّث `pyproject.toml` وفقاً لذلك.
+
+## إنشاء ونشر الأدوات
+
+لإنشاء مشروع أداة جديد:
+
+```bash
+crewai tool create <tool-name>
+```
+
+يولّد هذا مشروع أداة مُهيكل محلياً.
+
+بعد إجراء التغييرات، أنشئ مستودع Git وارفع الكود:
+
+```bash
+git init
+git add .
+git commit -m "Initial version"
+```
+
+لنشر الأداة:
+
+```bash
+crewai tool publish
+```
+
+افتراضياً، تُنشر الأدوات كخاصة. لجعل الأداة عامة:
+
+```bash
+crewai tool publish --public
+```
+
+لمزيد من التفاصيل حول بناء الأدوات، راجع [إنشاء أدواتك الخاصة](/ar/concepts/tools#creating-your-own-tools).
+
+## تحديث الأدوات
+
+لتحديث أداة منشورة:
+
+1. عدّل الأداة محلياً
+2. حدّث الإصدار في `pyproject.toml` (مثل من `0.1.0` إلى `0.1.1`)
+3. ارفع التغييرات وانشر
+
+```bash
+git commit -m "Update version to 0.1.1"
+crewai tool publish
+```
+
+## حذف الأدوات
+
+لحذف أداة:
+
+1. انتقل إلى [CrewAI AMP](https://app.crewai.com)
+2. انتقل إلى **Tools**
+3. اختر الأداة
+4. انقر على **Delete**
+
+<Warning>
+  الحذف نهائي. لا يمكن استعادة أو إعادة تثبيت الأدوات المحذوفة.
+</Warning>
+
+## فحوصات الأمان
+
+كل إصدار منشور يخضع لفحوصات أمان آلية، ولا يكون متاحاً للتثبيت إلا بعد اجتيازها.
+
+يمكنك التحقق من حالة فحص الأمان للأداة في:
+
+`CrewAI AMP > Tools > Your Tool > Versions`
+
+<Card title="تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+  تواصل مع فريق الدعم للمساعدة في تكامل API أو
+  استكشاف الأخطاء.
+</Card>
@@ -0,0 +1,132 @@
+---
+title: "تدريب الطواقم"
+description: "قم بتدريب طواقمك المنشورة مباشرة من منصة CrewAI AMP لتحسين أداء الوكلاء بمرور الوقت"
+icon: "dumbbell"
+mode: "wide"
+---
+
+يتيح لك التدريب تحسين أداء الطاقم من خلال تشغيل جلسات تدريب تكرارية مباشرة من علامة تبويب **Training** في CrewAI AMP. تستخدم المنصة **وضع التدريب التلقائي** — حيث تتولى العملية التكرارية تلقائياً، على عكس تدريب CLI الذي يتطلب ملاحظات بشرية تفاعلية لكل تكرار.
+
+بعد اكتمال التدريب، يقوم CrewAI بتقييم مخرجات الوكلاء ودمج الملاحظات في اقتراحات قابلة للتنفيذ لكل وكيل. يتم بعد ذلك تطبيق هذه الاقتراحات على تشغيلات الطاقم المستقبلية لتحسين جودة المخرجات.
+
+<Tip>
+  للحصول على تفاصيل حول كيفية عمل تدريب CrewAI، راجع صفحة [مفاهيم التدريب](/ar/concepts/training).
+</Tip>
+
+## المتطلبات الأساسية
+
+<CardGroup cols={2}>
+  <Card title="نشر نشط" icon="rocket">
+    تحتاج إلى حساب CrewAI AMP مع نشر نشط في حالة **Ready** (نوع Crew).
+  </Card>
+  <Card title="صلاحية التشغيل" icon="key">
+    يجب أن يكون لحسابك صلاحية تشغيل للنشر الذي تريد تدريبه.
+  </Card>
+</CardGroup>
+
+## كيفية تدريب طاقم
+
+<Steps>
+  <Step title="افتح علامة تبويب Training">
+    انتقل إلى **Deployments**، انقر على نشرك، ثم اختر علامة تبويب **Training**.
+  </Step>
+
+  <Step title="أدخل اسم التدريب">
+    قدم **Training Name** — سيصبح هذا اسم ملف `.pkl` المستخدم لتخزين نتائج التدريب. على سبيل المثال، "Expert Mode Training" ينتج `expert_mode_training.pkl`.
+  </Step>
+
+  <Step title="املأ مدخلات الطاقم">
+    أدخل حقول إدخال الطاقم. هذه هي نفس المدخلات التي ستقدمها للتشغيل العادي — يتم تحميلها ديناميكياً بناءً على تكوين طاقمك.
+  </Step>
+
+  <Step title="ابدأ التدريب">
+    انقر على **Train Crew**. يتغير الزر إلى "Training..." مع مؤشر دوران أثناء تشغيل العملية.
+
+    خلف الكواليس:
+    - يتم إنشاء سجل تدريب للنشر الخاص بك
+    - تستدعي المنصة نقطة نهاية التدريب التلقائي للنشر
+    - يقوم الطاقم بتشغيل تكراراته تلقائياً — لا حاجة لملاحظات يدوية
+  </Step>
+
+  <Step title="راقب التقدم">
+    تعرض لوحة **Current Training Status**:
+    - **Status** — الحالة الحالية لجلسة التدريب
+    - **Nº Iterations** — عدد تكرارات التدريب المُهيأة
+    - **Filename** — ملف `.pkl` الذي يتم إنشاؤه
+    - **Started At** — وقت بدء التدريب
+    - **Training Inputs** — المدخلات التي قدمتها
+  </Step>
+</Steps>
+
+## فهم نتائج التدريب
+
+بمجرد اكتمال التدريب، سترى بطاقات نتائج لكل وكيل تحتوي على المعلومات التالية:
+
+- **Agent Role** — اسم/دور الوكيل في طاقمك
+- **Final Quality** — درجة من 0 إلى 10 تقيّم جودة مخرجات الوكيل
+- **Final Summary** — ملخص لأداء الوكيل أثناء التدريب
+- **Suggestions** — توصيات قابلة للتنفيذ لتحسين سلوك الوكيل
+
+### تحرير الاقتراحات
+
+يمكنك تحسين الاقتراحات لأي وكيل:
+
+<Steps>
+  <Step title="انقر على Edit">
+    في بطاقة نتائج أي وكيل، انقر على زر **Edit** بجوار الاقتراحات.
+  </Step>
+
+  <Step title="عدّل الاقتراحات">
+    حدّث نص الاقتراحات ليعكس التحسينات التي تريدها بشكل أفضل.
+  </Step>
+
+  <Step title="احفظ التغييرات">
+    انقر على **Save**. تتم مزامنة الاقتراحات المُعدّلة مع النشر وتُستخدم في جميع التشغيلات المستقبلية.
+  </Step>
+</Steps>
+
+## استخدام بيانات التدريب
+
+لتطبيق نتائج التدريب على طاقمك:
+
+1. لاحظ **Training Filename** (ملف `.pkl`) من جلسة التدريب المكتملة.
+2. حدد اسم الملف هذا في تكوين kickoff أو التشغيل الخاص بنشرك.
+3. يقوم الطاقم تلقائياً بتحميل ملف التدريب وتطبيق الاقتراحات المخزنة على كل وكيل.
+
+هذا يعني أن الوكلاء يستفيدون من الملاحظات المُنشأة أثناء التدريب في كل تشغيل لاحق.
+
+## التدريبات السابقة
+
+يعرض الجزء السفلي من علامة تبويب Training **سجل جميع جلسات التدريب السابقة** للنشر. استخدم هذا لمراجعة التدريبات السابقة، ومقارنة النتائج، أو اختيار ملف تدريب مختلف للاستخدام.
+
+## معالجة الأخطاء
+
+إذا فشل تشغيل التدريب، تعرض لوحة الحالة حالة خطأ مع رسالة تصف ما حدث خطأ.
+
+الأسباب الشائعة لفشل التدريب:
+- **لم يتم تحديث وقت تشغيل النشر** — تأكد من أن نشرك يعمل بأحدث إصدار
+- **أخطاء تنفيذ الطاقم** — مشاكل في منطق مهام الطاقم أو تكوين الوكيل
+- **مشاكل الشبكة** — مشاكل الاتصال بين المنصة والنشر
+
+## القيود
+
+<Info>
+  ضع هذه القيود في الاعتبار عند التخطيط لسير عمل التدريب الخاص بك:
+  - **تدريب نشط واحد في كل مرة** لكل نشر — انتظر حتى ينتهي التشغيل الحالي قبل بدء آخر
+  - **وضع التدريب التلقائي فقط** — لا تدعم المنصة الملاحظات التفاعلية لكل تكرار مثل CLI
+  - **بيانات التدريب خاصة بالنشر** — ترتبط نتائج التدريب بمثيل وإصدار النشر المحدد
+</Info>
+
+## الموارد ذات الصلة
+
+<CardGroup cols={3}>
+  <Card title="مفاهيم التدريب" icon="book" href="/ar/concepts/training">
+    تعلم كيف يعمل تدريب CrewAI.
+  </Card>
+  <Card title="تشغيل الطاقم" icon="play" href="/ar/enterprise/guides/kickoff-crew">
+    قم بتشغيل طاقمك المنشور من منصة AMP.
+  </Card>
+  <Card title="النشر على AMP" icon="cloud-arrow-up" href="/ar/enterprise/guides/deploy-to-amp">
+    انشر طاقمك واجعله جاهزاً للتدريب.
+  </Card>
+</CardGroup>
@@ -0,0 +1,91 @@
+---
+title: "تحديث الطاقم"
+description: "تحديث طاقم على CrewAI AMP"
+icon: "pencil"
+mode: "wide"
+---
+
+<Note>
+  بعد نشر طاقمك على CrewAI AMP، قد تحتاج لإجراء تحديثات على
+  الكود أو إعدادات الأمان أو التهيئة. يشرح هذا الدليل كيفية تنفيذ
+  عمليات التحديث الشائعة.
+</Note>
+
+## لماذا تحديث طاقمك؟
+
+لن يلتقط CrewAI تحديثات GitHub تلقائياً بشكل افتراضي، لذا ستحتاج لتشغيل التحديثات يدوياً، ما لم تكن قد حددت خيار `Auto-update` عند نشر طاقمك.
+
+هناك عدة أسباب قد تدفعك لتحديث نشر طاقمك:
+
+- تريد تحديث الكود بأحدث إيداع دفعته إلى GitHub
+- تريد إعادة تعيين رمز الحامل لأسباب أمنية
+- تريد تحديث متغيرات البيئة
+
+## 1. تحديث كود طاقمك لأحدث إيداع
+
+عندما تدفع إيداعات جديدة إلى مستودع GitHub وتريد تحديث نشرك:
+
+1. انتقل إلى طاقمك في منصة CrewAI AMP
+2. انقر على زر `Re-deploy` في صفحة تفاصيل طاقمك
+
+<Frame>![زر إعادة النشر](/images/enterprise/redeploy-button.png)</Frame>
+
+سيؤدي ذلك إلى تشغيل تحديث يمكنك تتبعه عبر شريط التقدم. سيسحب النظام أحدث كود من مستودعك ويعيد بناء نشرك.
+
+## 2. إعادة تعيين رمز الحامل
+
+إذا كنت تحتاج لإنشاء رمز حامل جديد (مثلاً، إذا كنت تشتبه في أن الرمز الحالي ربما تم اختراقه):
+
+1. انتقل إلى طاقمك في منصة CrewAI AMP
+2. ابحث عن قسم `Bearer Token`
+3. انقر على زر `Reset` بجانب رمزك الحالي
+
+<Frame>![إعادة تعيين الرمز](/images/enterprise/reset-token.png)</Frame>
+
+<Warning>
+  إعادة تعيين رمز الحامل ستبطل الرمز السابق فوراً.
+  تأكد من تحديث أي تطبيقات أو نصوص برمجية تستخدم الرمز القديم.
+</Warning>
+
+## 3. تحديث متغيرات البيئة
+
+لتحديث متغيرات البيئة لطاقمك:
+
+1. أولاً ادخل صفحة النشر بالنقر على اسم طاقمك
+
+<Frame>
+  ![زر متغيرات البيئة](/images/enterprise/env-vars-button.png)
+</Frame>
+
+2. حدد موقع قسم `Environment Variables` (ستحتاج للنقر على أيقونة `Settings` للوصول إليه)
+3. عدّل المتغيرات الحالية أو أضف جديدة في الحقول المتوفرة
+4. انقر على زر `Update` بجانب كل متغير تعدّله
+
+<Frame>
+  ![تحديث متغيرات البيئة](/images/enterprise/update-env-vars.png)
+</Frame>
+
+5. أخيراً، انقر على زر `Update Deployment` في أسفل الصفحة لتطبيق التغييرات
+
+<Note>
+  تحديث متغيرات البيئة سيشغّل نشراً جديداً، لكن هذا سيحدّث
+  فقط تهيئة البيئة وليس الكود نفسه.
+</Note>
+
+## بعد التحديث
+
+بعد إجراء أي تحديث:
+
+1. سيعيد النظام بناء وإعادة نشر طاقمك
+2. يمكنك مراقبة تقدم النشر في الوقت الفعلي
+3. بمجرد الاكتمال، اختبر طاقمك للتأكد من أن التغييرات تعمل كما هو متوقع
+
+<Tip>
+  إذا واجهت أي مشاكل بعد التحديث، يمكنك عرض سجلات النشر في
+  المنصة أو التواصل مع الدعم للمساعدة.
+</Tip>
+
+<Card title="تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+  تواصل مع فريق الدعم للمساعدة في تحديث طاقمك أو
+  استكشاف أخطاء النشر.
+</Card>
@@ -0,0 +1,157 @@
+---
+title: "أتمتة Webhook"
+description: "أتمتة سير عمل CrewAI AMP باستخدام webhooks مع منصات مثل ActivePieces وZapier وMake.com"
+icon: "webhook"
+mode: "wide"
+---
+
+يتيح لك CrewAI AMP أتمتة سير عملك باستخدام webhooks. ستوجهك هذه المقالة خلال عملية إعداد واستخدام webhooks لبدء تنفيذ طاقمك، مع التركيز على التكامل مع ActivePieces، وهي منصة أتمتة سير العمل مشابهة لـ Zapier وMake.com.
+
+## إعداد Webhooks
+
+<Steps>
+    <Step title="الوصول إلى واجهة البدء">
+        - انتقل إلى لوحة تحكم CrewAI AMP
+        - ابحث عن قسم `/kickoff`، الذي يُستخدم لبدء تنفيذ الطاقم
+            <Frame>
+                <img src="/images/enterprise/kickoff-interface.png" alt="واجهة البدء" />
+            </Frame>
+    </Step>
+
+    <Step title="تكوين محتوى JSON">
+        في قسم محتوى JSON، ستحتاج إلى تقديم المعلومات التالية:
+
+        - **inputs**: كائن JSON يحتوي على:
+            - `company`: اسم الشركة (مثال: "tesla")
+            - `product_name`: اسم المنتج (مثال: "crewai")
+            - `form_response`: نوع الاستجابة (مثال: "financial")
+            - `icp_description`: وصف موجز لملف العميل المثالي
+            - `product_description`: وصف قصير للمنتج
+            - `taskWebhookUrl`، `stepWebhookUrl`، `crewWebhookUrl`: عناوين URL لنقاط نهاية webhook المختلفة (ActivePieces أو Zapier أو Make.com أو منصة أخرى متوافقة)
+    </Step>
+
+    <Step title="التكامل مع ActivePieces">
+        في هذا المثال سنستخدم ActivePieces. يمكنك استخدام منصات أخرى مثل Zapier وMake.com
+
+        للتكامل مع ActivePieces:
+
+        1. أنشئ تدفقًا جديدًا في ActivePieces
+        2. أضف مشغلًا (مثال: جدول `Every Day`)
+            <Frame>
+                <img src="/images/enterprise/activepieces-trigger.png" alt="مشغل ActivePieces" />
+            </Frame>
+
+        3. أضف خطوة إجراء HTTP
+            - عيّن الإجراء إلى `Send HTTP request`
+            - استخدم `POST` كطريقة
+            - عيّن عنوان URL إلى نقطة نهاية بدء CrewAI AMP
+            - أضف الترويسات اللازمة (مثال: `Bearer Token`)
+                <Frame>
+                    <img src="/images/enterprise/activepieces-headers.png" alt="ترويسات ActivePieces" />
+                </Frame>
+
+            - في النص، ضمّن محتوى JSON كما تم تكوينه في الخطوة 2
+                <Frame>
+                    <img src="/images/enterprise/activepieces-body.png" alt="نص ActivePieces" />
+                </Frame>
+
+            - سيبدأ الطاقم بعد ذلك في الوقت المحدد مسبقًا.
+    </Step>
+
+    <Step title="إعداد Webhook">
+        1. أنشئ تدفقًا جديدًا في ActivePieces وسمّه
+            <Frame>
+                <img src="/images/enterprise/activepieces-flow.png" alt="تدفق ActivePieces" />
+            </Frame>
+
+        2. أضف خطوة webhook كمشغل:
+            - اختر `Catch Webhook` كنوع المشغل
+            - سيولّد هذا عنوان URL فريدًا سيستقبل طلبات HTTP ويشغل تدفقك
+                <Frame>
+                    <img src="/images/enterprise/activepieces-webhook.png" alt="Webhook ActivePieces" />
+                </Frame>
+
+            - كوّن البريد الإلكتروني لاستخدام نص جسم webhook الخاص بالطاقم
+                <Frame>
+                    <img src="/images/enterprise/activepieces-email.png" alt="بريد ActivePieces الإلكتروني" />
+                </Frame>
+    </Step>
+
+</Steps>
+
+## أمثلة مخرجات Webhook
+
+**ملاحظة:** أي كائن `meta` مُقدم في طلب البدء الخاص بك سيتم تضمينه في جميع حمولات webhook، مما يتيح لك تتبع الطلبات والحفاظ على السياق عبر دورة حياة تنفيذ الطاقم بالكامل.
+
+<Tabs>
+    <Tab title="Step Webhook">
+        `stepWebhookUrl` - رد نداء يتم تنفيذه عند كل فكرة داخلية للوكيل
+
+        ```json
+        {
+            "prompt": "Research the financial industry for potential AI solutions",
+            "thought": "I need to conduct preliminary research on the financial industry",
+            "tool": "research_tool",
+            "tool_input": "financial industry AI solutions",
+            "result": "**Preliminary Research Report on the Financial Industry for crewai Enterprise Solution**\n1. Industry Overview and Trends\nThe financial industry in ....\nConclusion:\nThe financial industry presents a fertile ground for implementing AI solutions like crewai, particularly in areas such as digital customer engagement, risk management, and regulatory compliance. Further engagement with the lead is recommended to better tailor the crewai solution to their specific needs and scale.",
+            "kickoff_id": "97eba64f-958c-40a0-b61c-625fe635a3c0",
+            "meta": {
+                "requestId": "travel-req-123",
+                "source": "web-app"
+            }
+        }
+        ```
+    </Tab>
+    <Tab title="Task Webhook">
+        `taskWebhookUrl` - رد نداء يتم تنفيذه عند انتهاء كل مهمة
+
+        ```json
+        {
+            "description": "Using the information gathered from the lead's data, conduct preliminary research on the lead's industry, company background, and potential use cases for crewai. Focus on finding relevant data that can aid in scoring the lead and planning a strategy to pitch them crewai.",
+            "name": "Industry Research Task",
+            "expected_output": "Detailed research report on the financial industry",
+            "summary": "The financial industry presents a fertile ground for implementing AI solutions like crewai, particularly in areas such as digital customer engagement, risk management, and regulatory compliance. Further engagement with the lead is recommended to better tailor the crewai solution to their specific needs and scale.",
+            "agent": "Research Agent",
+            "output": "**Preliminary Research Report on the Financial Industry for crewai Enterprise Solution**\n1. Industry Overview and Trends\nThe financial industry in ....\nConclusion:\nThe financial industry presents a fertile ground for implementing AI solutions like crewai, particularly in areas such as digital customer engagement, risk management, and regulatory compliance.",
+            "output_json": {
+                "industry": "financial",
+                "key_opportunities": ["digital customer engagement", "risk management", "regulatory compliance"]
+            },
+            "kickoff_id": "97eba64f-958c-40a0-b61c-625fe635a3c0",
+            "meta": {
+                "requestId": "travel-req-123",
+                "source": "web-app"
+            }
+        }
+        ```
+    </Tab>
+    <Tab title="Crew Webhook">
+        `crewWebhookUrl` - رد نداء يتم تنفيذه عند انتهاء تنفيذ الطاقم
+
+        ```json
+        {
+            "kickoff_id": "97eba64f-958c-40a0-b61c-625fe635a3c0",
+            "result": "**Final Analysis Report**\n\nLead Score: Customer service enhancement and compliance are particularly relevant.\n\nTalking Points:\n- Highlight how crewai's AI solutions can transform customer service\n- Discuss crewai's potential for sustainability goals\n- Emphasize compliance capabilities\n- Stress adaptability for various operation scales",
+            "result_json": {
+                "lead_score": "Customer service enhancement, and compliance are particularly relevant.",
+                "talking_points": [
+                    "Highlight how crewai's AI solutions can transform customer service with automated, personalized experiences and 24/7 support, improving both customer satisfaction and operational efficiency.",
+                    "Discuss crewai's potential to help the institution achieve its sustainability goals through better data analysis and decision-making, contributing to responsible investing and green initiatives.",
+                    "Emphasize crewai's ability to enhance compliance with evolving regulations through efficient data processing and reporting, reducing the risk of non-compliance penalties.",
+                    "Stress the adaptability of crewai to support both extensive multinational operations and smaller, targeted projects, ensuring the solution grows with the institution's needs."
+                ]
+            },
+            "token_usage": {
+                "total_tokens": 1250,
+                "prompt_tokens": 800,
+                "completion_tokens": 450
+            },
+            "meta": {
+                "requestId": "travel-req-123",
+                "source": "web-app"
+            }
+        }
+        ```
+    </Tab>
+
+</Tabs>
@@ -0,0 +1,105 @@
+---
+title: "مشغل Zapier"
+description: "تشغيل أطقم CrewAI من سير عمل Zapier لأتمتة سير العمل عبر التطبيقات"
+icon: "bolt"
+mode: "wide"
+---
+
+سيرشدك هذا الدليل خلال عملية إعداد مشغلات Zapier لـ CrewAI AMP، مما يتيح لك أتمتة سير العمل بين CrewAI AMP والتطبيقات الأخرى.
+
+## المتطلبات الأساسية
+
+- حساب CrewAI AMP
+- حساب Zapier
+- حساب Slack (لهذا المثال المحدد)
+
+## الإعداد خطوة بخطوة
+
+<Steps>
+    <Step title="إعداد مشغل Slack">
+        - في Zapier، أنشئ Zap جديدًا.
+
+        <Frame>
+            <img src="/images/enterprise/zapier-1.png" alt="Zapier 1" />
+        </Frame>
+    </Step>
+
+    <Step title="اختر Slack كتطبيق المشغل">
+        <Frame>
+            <img src="/images/enterprise/zapier-2.png" alt="Zapier 2" />
+        </Frame>
+        - اختر `New Pushed Message` كحدث المشغل.
+        - اربط حساب Slack الخاص بك إذا لم تفعل ذلك بالفعل.
+    </Step>
+
+    <Step title="تكوين إجراء CrewAI AMP">
+        - أضف خطوة إجراء جديدة إلى Zap الخاص بك.
+        - اختر CrewAI+ كتطبيق الإجراء وKickoff كحدث الإجراء
+
+        <Frame>
+            <img src="/images/enterprise/zapier-3.png" alt="Zapier 5" />
+        </Frame>
+    </Step>
+
+    <Step title="ربط حساب CrewAI AMP">
+        - اربط حساب CrewAI AMP الخاص بك.
+        - اختر الطاقم المناسب لسير عملك.
+
+        <Frame>
+            <img src="/images/enterprise/zapier-4.png" alt="Zapier 6" />
+        </Frame>
+        - كوّن مدخلات الطاقم باستخدام البيانات من رسالة Slack.
+    </Step>
+
+    <Step title="تنسيق مخرجات CrewAI AMP">
+        - أضف خطوة إجراء أخرى لتنسيق مخرجات النص من CrewAI AMP.
+        - استخدم أدوات التنسيق في Zapier لتحويل مخرجات Markdown إلى HTML.
+
+        <Frame>
+            <img src="/images/enterprise/zapier-5.png" alt="Zapier 8" />
+        </Frame>
+        <Frame>
+            <img src="/images/enterprise/zapier-6.png" alt="Zapier 9" />
+        </Frame>
+    </Step>
+
+    <Step title="إرسال المخرجات عبر البريد الإلكتروني">
+        - أضف خطوة إجراء نهائية لإرسال المخرجات المنسقة عبر البريد الإلكتروني.
+        - اختر خدمة البريد الإلكتروني المفضلة لديك (مثال: Gmail، Outlook).
+        - كوّن تفاصيل البريد الإلكتروني، بما في ذلك المستلم والموضوع والنص.
+        - أدرج مخرجات CrewAI AMP المنسقة في نص البريد الإلكتروني.
+
+        <Frame>
+            <img src="/images/enterprise/zapier-7.png" alt="Zapier 7" />
+        </Frame>
+    </Step>
+
+    <Step title="بدء تشغيل الطاقم من Slack">
+        - أدخل النص في قناة Slack الخاصة بك
+
+        <Frame>
+            <img src="/images/enterprise/zapier-7b.png" alt="Zapier 10" />
+        </Frame>
+
+        - اختر زر النقاط الثلاث ثم اختر Push to Zapier
+
+        <Frame>
+            <img src="/images/enterprise/zapier-8.png" alt="Zapier 11" />
+        </Frame>
+    </Step>
+
+    <Step title="اختر الطاقم ثم اضغط Push للبدء">
+        <Frame>
+            <img src="/images/enterprise/zapier-9.png" alt="Zapier 12" />
+        </Frame>
+    </Step>
+
+</Steps>
+
+## نصائح للنجاح
+
+- تأكد من أن مدخلات CrewAI AMP مربوطة بشكل صحيح من رسالة Slack.
+- اختبر Zap الخاص بك جيدًا قبل تفعيله لاكتشاف أي مشاكل محتملة.
+- فكر في إضافة خطوات معالجة الأخطاء لإدارة حالات الفشل المحتملة في سير العمل.
+
+باتباع هذه الخطوات، ستكون قد أعددت بنجاح مشغلات Zapier لـ CrewAI AMP، مما يتيح سير عمل آلي يتم تشغيله بواسطة رسائل Slack وينتج عنه إشعارات بالبريد الإلكتروني مع مخرجات CrewAI AMP.
@@ -0,0 +1,271 @@
+---
+title: تكامل Asana
+description: "تنسيق مهام الفريق والمشاريع مع تكامل Asana لـ CrewAI."
+icon: "circle"
+mode: "wide"
+---
+
+## نظرة عامة
+
+مكّن وكلاءك من إدارة المهام والمشاريع وتنسيق الفريق عبر Asana. أنشئ المهام وحدّث حالة المشروع وأدر التعيينات وبسّط سير عمل فريقك مع الأتمتة المدعومة بالذكاء الاصطناعي.
+
+## المتطلبات الأساسية
+
+قبل استخدام تكامل Asana، تأكد من أن لديك:
+
+- حساب [CrewAI AMP](https://app.crewai.com) مع اشتراك نشط
+- حساب Asana مع الأذونات المناسبة
+- ربط حساب Asana الخاص بك عبر [صفحة التكاملات](https://app.crewai.com/crewai_plus/connectors)
+
+## إعداد تكامل Asana
+
+### 1. ربط حساب Asana الخاص بك
+
+1. انتقل إلى [تكاملات CrewAI AMP](https://app.crewai.com/crewai_plus/connectors)
+2. ابحث عن **Asana** في قسم تكاملات المصادقة
+3. انقر على **ربط** وأكمل تدفق OAuth
+4. امنح الأذونات اللازمة لإدارة المهام والمشاريع
+5. انسخ رمز Enterprise الخاص بك من [إعدادات التكامل](https://app.crewai.com/crewai_plus/settings/integrations)
+
+### 2. تثبيت الحزمة المطلوبة
+
+```bash
+uv add crewai-tools
+```
+
+### 3. إعداد متغير البيئة
+
+<Note>
+  لاستخدام التكاملات مع `Agent(apps=[])`, يجب تعيين متغير البيئة
+  `CREWAI_PLATFORM_INTEGRATION_TOKEN` برمز Enterprise الخاص بك.
+</Note>
+
+```bash
+export CREWAI_PLATFORM_INTEGRATION_TOKEN="your_enterprise_token"
+```
+
+أو أضفه إلى ملف `.env`:
+
+```
+CREWAI_PLATFORM_INTEGRATION_TOKEN=your_enterprise_token
+```
+
+## الإجراءات المتاحة
+
+<AccordionGroup>
+  <Accordion title="asana/create_comment">
+    **الوصف:** إنشاء تعليق في Asana.
+
+    **المعاملات:**
+    - `task` (string, مطلوب): معرف المهمة - معرف المهمة التي سيُضاف إليها التعليق. سيُنسب التعليق للمستخدم المصادق عليه حاليًا.
+    - `text` (string, مطلوب): النص (مثال: "This is a comment.").
+
+  </Accordion>
+
+  <Accordion title="asana/create_project">
+    **الوصف:** إنشاء مشروع في Asana.
+
+    **المعاملات:**
+    - `name` (string, مطلوب): الاسم (مثال: "Stuff to buy").
+    - `workspace` (string, مطلوب): مساحة العمل - استخدم إعدادات سير عمل بوابة الاتصال للسماح للمستخدمين باختيار مساحة العمل لإنشاء المشاريع فيها. الافتراضي هو أول مساحة عمل للمستخدم إذا تُرك فارغًا.
+    - `team` (string, اختياري): الفريق - استخدم إعدادات سير عمل بوابة الاتصال للسماح للمستخدمين باختيار الفريق لمشاركة هذا المشروع معه. الافتراضي هو أول فريق للمستخدم إذا تُرك فارغًا.
+    - `notes` (string, اختياري): ملاحظات (مثال: "These are things we need to purchase.").
+
+  </Accordion>
+
+  <Accordion title="asana/get_projects">
+    **الوصف:** الحصول على قائمة المشاريع في Asana.
+
+    **المعاملات:**
+    - `archived` (string, اختياري): مؤرشف - اختر "true" لعرض المشاريع المؤرشفة، "false" لعرض المشاريع النشطة فقط، أو "default" لعرض كليهما.
+      - الخيارات: `default`, `true`, `false`
+
+  </Accordion>
+
+  <Accordion title="asana/get_project_by_id">
+    **الوصف:** الحصول على مشروع بواسطة المعرف في Asana.
+
+    **المعاملات:**
+    - `projectFilterId` (string, مطلوب): معرف المشروع.
+
+  </Accordion>
+
+  <Accordion title="asana/create_task">
+    **الوصف:** إنشاء مهمة في Asana.
+
+    **المعاملات:**
+    - `name` (string, مطلوب): الاسم (مثال: "Task Name").
+    - `workspace` (string, اختياري): مساحة العمل - استخدم إعدادات سير عمل بوابة الاتصال للسماح للمستخدمين باختيار مساحة العمل لإنشاء المهام فيها. الافتراضي هو أول مساحة عمل للمستخدم إذا تُرك فارغًا.
+    - `project` (string, اختياري): المشروع - استخدم إعدادات سير عمل بوابة الاتصال للسماح للمستخدمين باختيار المشروع لإنشاء هذه المهمة فيه.
+    - `notes` (string, اختياري): ملاحظات.
+    - `dueOnDate` (string, اختياري): تاريخ الاستحقاق - التاريخ الذي تستحق فيه هذه المهمة. لا يمكن استخدامه مع Due At. (مثال: "YYYY-MM-DD").
+    - `dueAtDate` (string, اختياري): الاستحقاق في - التاريخ والوقت (طابع زمني ISO) الذي تستحق فيه هذه المهمة. لا يمكن استخدامه مع Due On. (مثال: "2019-09-15T02:06:58.147Z").
+    - `assignee` (string, اختياري): المُكلف - معرف مستخدم Asana الذي سيتم تعيين هذه المهمة له. استخدم إعدادات سير عمل بوابة الاتصال للسماح للمستخدمين باختيار المُكلف.
+    - `gid` (string, اختياري): معرف خارجي - معرف من تطبيقك لربط هذه المهمة به. يمكنك استخدام هذا المعرف لمزامنة التحديثات لهذه المهمة لاحقًا.
+
+  </Accordion>
+
+  <Accordion title="asana/update_task">
+    **الوصف:** تحديث مهمة في Asana.
+
+    **المعاملات:**
+    - `taskId` (string, مطلوب): معرف المهمة - معرف المهمة التي سيتم تحديثها.
+    - `completeStatus` (string, اختياري): حالة الإكمال.
+      - الخيارات: `true`, `false`
+    - `name` (string, اختياري): الاسم (مثال: "Task Name").
+    - `notes` (string, اختياري): ملاحظات.
+    - `dueOnDate` (string, اختياري): تاريخ الاستحقاق - التاريخ الذي تستحق فيه هذه المهمة. لا يمكن استخدامه مع Due At. (مثال: "YYYY-MM-DD").
+    - `dueAtDate` (string, اختياري): الاستحقاق في - التاريخ والوقت (طابع زمني ISO) الذي تستحق فيه هذه المهمة. لا يمكن استخدامه مع Due On. (مثال: "2019-09-15T02:06:58.147Z").
+    - `assignee` (string, اختياري): المُكلف - معرف مستخدم Asana الذي سيتم تعيين هذه المهمة له.
+    - `gid` (string, اختياري): معرف خارجي - معرف من تطبيقك لربط هذه المهمة به.
+
+  </Accordion>
+
+  <Accordion title="asana/get_tasks">
+    **الوصف:** الحصول على قائمة المهام في Asana.
+
+    **المعاملات:**
+    - `workspace` (string, اختياري): مساحة العمل - معرف مساحة العمل لتصفية المهام عليها.
+    - `project` (string, اختياري): المشروع - معرف المشروع لتصفية المهام عليه.
+    - `assignee` (string, اختياري): المُكلف - معرف المُكلف لتصفية المهام عليه.
+    - `completedSince` (string, اختياري): مكتملة منذ - إرجاع المهام غير المكتملة فقط أو التي اكتملت منذ هذا الوقت (طابع زمني ISO أو Unix). (مثال: "2014-04-25T16:15:47-04:00").
+
+  </Accordion>
+
+  <Accordion title="asana/get_tasks_by_id">
+    **الوصف:** الحصول على قائمة المهام بواسطة المعرف في Asana.
+
+    **المعاملات:**
+    - `taskId` (string, مطلوب): معرف المهمة.
+
+  </Accordion>
+
+  <Accordion title="asana/get_task_by_external_id">
+    **الوصف:** الحصول على مهمة بواسطة المعرف الخارجي في Asana.
+
+    **المعاملات:**
+    - `gid` (string, مطلوب): المعرف الخارجي - المعرف الذي ترتبط أو تتزامن به هذه المهمة، من تطبيقك.
+
+  </Accordion>
+
+  <Accordion title="asana/add_task_to_section">
+    **الوصف:** إضافة مهمة إلى قسم في Asana.
+
+    **المعاملات:**
+    - `sectionId` (string, مطلوب): معرف القسم - معرف القسم لإضافة هذه المهمة إليه.
+    - `taskId` (string, مطلوب): معرف المهمة - معرف المهمة. (مثال: "1204619611402340").
+    - `beforeTaskId` (string, اختياري): معرف المهمة السابقة - معرف مهمة في هذا القسم سيتم إدراج هذه المهمة قبلها. لا يمكن استخدامه مع After Task ID. (مثال: "1204619611402340").
+    - `afterTaskId` (string, اختياري): معرف المهمة التالية - معرف مهمة في هذا القسم سيتم إدراج هذه المهمة بعدها. لا يمكن استخدامه مع Before Task ID. (مثال: "1204619611402340").
+
+  </Accordion>
+
+  <Accordion title="asana/get_teams">
+    **الوصف:** الحصول على قائمة الفرق في Asana.
+
+    **المعاملات:**
+    - `workspace` (string, مطلوب): مساحة العمل - إرجاع الفرق في مساحة العمل هذه المرئية للمستخدم المصرح له.
+
+  </Accordion>
+
+  <Accordion title="asana/get_workspaces">
+    **الوصف:** الحصول على قائمة مساحات العمل في Asana.
+
+    **المعاملات:** لا توجد معاملات مطلوبة.
+
+  </Accordion>
+</AccordionGroup>
+
+## أمثلة الاستخدام
+
+### إعداد وكيل Asana الأساسي
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create an agent with Asana capabilities
+asana_agent = Agent(
+    role="Project Manager",
+    goal="Manage tasks and projects in Asana efficiently",
+    backstory="An AI assistant specialized in project management and task coordination.",
+    apps=['asana']  # All Asana actions will be available
+)
+
+# Task to create a new project
+create_project_task = Task(
+    description="Create a new project called 'Q1 Marketing Campaign' in the Marketing workspace",
+    agent=asana_agent,
+    expected_output="Confirmation that the project was created successfully with project ID"
+)
+
+# Run the task
+crew = Crew(
+    agents=[asana_agent],
+    tasks=[create_project_task]
+)
+
+crew.kickoff()
+```
+
+### تصفية أدوات Asana محددة
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create agent with specific Asana actions only
+task_manager_agent = Agent(
+    role="Task Manager",
+    goal="Create and manage tasks efficiently",
+    backstory="An AI assistant that focuses on task creation and management.",
+    apps=[
+        'asana/create_task',
+        'asana/update_task',
+        'asana/get_tasks'
+    ]  # Specific Asana actions
+)
+
+# Task to create and assign a task
+task_management = Task(
+    description="Create a task called 'Review quarterly reports' and assign it to the appropriate team member",
+    agent=task_manager_agent,
+    expected_output="Task created and assigned successfully"
+)
+
+crew = Crew(
+    agents=[task_manager_agent],
+    tasks=[task_management]
+)
+
+crew.kickoff()
+```
+
+### إدارة المشاريع المتقدمة
+
+```python
+from crewai import Agent, Task, Crew
+
+project_coordinator = Agent(
+    role="Project Coordinator",
+    goal="Coordinate project activities and track progress",
+    backstory="An experienced project coordinator who ensures projects run smoothly.",
+    apps=['asana']
+)
+
+# Complex task involving multiple Asana operations
+coordination_task = Task(
+    description="""
+    1. Get all active projects in the workspace
+    2. For each project, get the list of incomplete tasks
+    3. Create a summary report task in the 'Management Reports' project
+    4. Add comments to overdue tasks to request status updates
+    """,
+    agent=project_coordinator,
+    expected_output="Summary report created and status update requests sent for overdue tasks"
+)
+
+crew = Crew(
+    agents=[project_coordinator],
+    tasks=[coordination_task]
+)
+
+crew.kickoff()
+```
@@ -0,0 +1,280 @@
+---
+title: تكامل Box
+description: "تخزين الملفات وإدارة المستندات مع تكامل Box لـ CrewAI."
+icon: "box"
+mode: "wide"
+---
+
+## نظرة عامة
+
+مكّن وكلاءك من إدارة الملفات والمجلدات والمستندات عبر Box. ارفع الملفات، ونظّم هياكل المجلدات، وابحث في المحتوى، وبسّط إدارة مستندات فريقك باستخدام الأتمتة المدعومة بالذكاء الاصطناعي.
+
+## المتطلبات الأساسية
+
+قبل استخدام تكامل Box، تأكد من توفر ما يلي:
+
+- حساب [CrewAI AMP](https://app.crewai.com) مع اشتراك فعّال
+- حساب Box بالصلاحيات المناسبة
+- ربط حساب Box الخاص بك عبر [صفحة التكاملات](https://app.crewai.com/crewai_plus/connectors)
+
+## إعداد تكامل Box
+
+### 1. ربط حساب Box الخاص بك
+
+1. انتقل إلى [تكاملات CrewAI AMP](https://app.crewai.com/crewai_plus/connectors)
+2. ابحث عن **Box** في قسم تكاملات المصادقة
+3. انقر على **Connect** وأكمل عملية OAuth
+4. امنح الصلاحيات اللازمة لإدارة الملفات والمجلدات
+5. انسخ رمز المؤسسة من [إعدادات التكامل](https://app.crewai.com/crewai_plus/settings/integrations)
+
+### 2. تثبيت الحزمة المطلوبة
+
+```bash
+uv add crewai-tools
+```
+
+### 3. إعداد متغير البيئة
+
+<Note>
+  لاستخدام التكاملات مع `Agent(apps=[])`, يجب تعيين متغير البيئة
+  `CREWAI_PLATFORM_INTEGRATION_TOKEN` برمز المؤسسة الخاص بك.
+</Note>
+
+```bash
+export CREWAI_PLATFORM_INTEGRATION_TOKEN="your_enterprise_token"
+```
+
+أو أضفه إلى ملف `.env`:
+
+```
+CREWAI_PLATFORM_INTEGRATION_TOKEN=your_enterprise_token
+```
+
+## الإجراءات المتاحة
+
+<AccordionGroup>
+  <Accordion title="box/save_file">
+    **الوصف:** حفظ ملف من عنوان URL في Box.
+
+    **المعاملات:**
+    - `fileAttributes` (object, مطلوب): السمات - بيانات وصفية للملف تشمل الاسم والمجلد الأصلي والطوابع الزمنية.
+      ```json
+      {
+        "content_created_at": "2012-12-12T10:53:43-08:00",
+        "content_modified_at": "2012-12-12T10:53:43-08:00",
+        "name": "qwerty.png",
+        "parent": { "id": "1234567" }
+      }
+      ```
+    - `file` (string, مطلوب): عنوان URL للملف - يجب أن يكون حجم الملفات أقل من 50 ميجابايت. (مثال: "https://picsum.photos/200/300").
+
+  </Accordion>
+
+  <Accordion title="box/save_file_from_object">
+    **الوصف:** حفظ ملف في Box.
+
+    **المعاملات:**
+    - `file` (string, مطلوب): الملف - يقبل كائن ملف يحتوي على بيانات الملف. يجب أن يكون حجم الملفات أقل من 50 ميجابايت.
+    - `fileName` (string, مطلوب): اسم الملف (مثال: "qwerty.png").
+    - `folder` (string, اختياري): المجلد - استخدم إعدادات سير عمل بوابة الاتصال للسماح للمستخدمين باختيار وجهة مجلد الملف. يستخدم المجلد الجذري افتراضياً إذا تُرك فارغاً.
+
+  </Accordion>
+
+  <Accordion title="box/get_file_by_id">
+    **الوصف:** الحصول على ملف بواسطة المعرّف في Box.
+
+    **المعاملات:**
+    - `fileId` (string, مطلوب): معرّف الملف - المعرّف الفريد الذي يمثل ملفاً. (مثال: "12345").
+
+  </Accordion>
+
+  <Accordion title="box/list_files">
+    **الوصف:** عرض قائمة الملفات في Box.
+
+    **المعاملات:**
+    - `folderId` (string, مطلوب): معرّف المجلد - المعرّف الفريد الذي يمثل مجلداً. (مثال: "0").
+    - `filterFormula` (object, اختياري): فلتر بصيغة التعبير العادي المنفصل - OR لمجموعات AND من شروط فردية.
+      ```json
+      {
+        "operator": "OR",
+        "conditions": [
+          {
+            "operator": "AND",
+            "conditions": [
+              {
+                "field": "direction",
+                "operator": "$stringExactlyMatches",
+                "value": "ASC"
+              }
+            ]
+          }
+        ]
+      }
+      ```
+
+  </Accordion>
+
+  <Accordion title="box/create_folder">
+    **الوصف:** إنشاء مجلد في Box.
+
+    **المعاملات:**
+    - `folderName` (string, مطلوب): الاسم - اسم المجلد الجديد. (مثال: "New Folder").
+    - `folderParent` (object, مطلوب): المجلد الأصلي - المجلد الأصلي الذي سيُنشأ فيه المجلد الجديد.
+      ```json
+      {
+        "id": "123456"
+      }
+      ```
+
+  </Accordion>
+
+  <Accordion title="box/move_folder">
+    **الوصف:** نقل مجلد في Box.
+
+    **المعاملات:**
+    - `folderId` (string, مطلوب): معرّف المجلد - المعرّف الفريد الذي يمثل مجلداً. (مثال: "0").
+    - `folderName` (string, مطلوب): الاسم - اسم المجلد. (مثال: "New Folder").
+    - `folderParent` (object, مطلوب): المجلد الأصلي - وجهة المجلد الأصلي الجديد.
+      ```json
+      {
+        "id": "123456"
+      }
+      ```
+
+  </Accordion>
+
+  <Accordion title="box/get_folder_by_id">
+    **الوصف:** الحصول على مجلد بواسطة المعرّف في Box.
+
+    **المعاملات:**
+    - `folderId` (string, مطلوب): معرّف المجلد - المعرّف الفريد الذي يمثل مجلداً. (مثال: "0").
+
+  </Accordion>
+
+  <Accordion title="box/search_folders">
+    **الوصف:** البحث في المجلدات في Box.
+
+    **المعاملات:**
+    - `folderId` (string, مطلوب): معرّف المجلد - المجلد المراد البحث فيه.
+    - `filterFormula` (object, اختياري): فلتر بصيغة التعبير العادي المنفصل - OR لمجموعات AND من شروط فردية.
+      ```json
+      {
+        "operator": "OR",
+        "conditions": [
+          {
+            "operator": "AND",
+            "conditions": [
+              {
+                "field": "sort",
+                "operator": "$stringExactlyMatches",
+                "value": "name"
+              }
+            ]
+          }
+        ]
+      }
+      ```
+
+  </Accordion>
+
+  <Accordion title="box/delete_folder">
+    **الوصف:** حذف مجلد في Box.
+
+    **المعاملات:**
+    - `folderId` (string, مطلوب): معرّف المجلد - المعرّف الفريد الذي يمثل مجلداً. (مثال: "0").
+    - `recursive` (boolean, اختياري): تكراري - حذف مجلد غير فارغ بحذف المجلد وجميع محتوياته تكرارياً.
+
+  </Accordion>
+</AccordionGroup>
+
+## أمثلة الاستخدام
+
+### إعداد Agent أساسي لـ Box
+
+```python
+from crewai import Agent, Task, Crew
+from crewai import Agent, Task, Crew
+
+# Create an agent with Box capabilities
+box_agent = Agent(
+    role="Document Manager",
+    goal="Manage files and folders in Box efficiently",
+    backstory="An AI assistant specialized in document management and file organization.",
+    apps=['box']  # All Box actions will be available
+)
+
+# Task to create a folder structure
+create_structure_task = Task(
+    description="Create a folder called 'Project Files' in the root directory and upload a document from URL",
+    agent=box_agent,
+    expected_output="Folder created and file uploaded successfully"
+)
+
+# Run the task
+crew = Crew(
+    agents=[box_agent],
+    tasks=[create_structure_task]
+)
+
+crew.kickoff()
+```
+
+### تصفية أدوات Box محددة
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create agent with specific Box actions only
+file_organizer_agent = Agent(
+    role="File Organizer",
+    goal="Organize and manage file storage efficiently",
+    backstory="An AI assistant that focuses on file organization and storage management.",
+    apps=['box/create_folder', 'box/save_file', 'box/list_files']  # Specific Box actions
+)
+
+# Task to organize files
+organization_task = Task(
+    description="Create a folder structure for the marketing team and organize existing files",
+    agent=file_organizer_agent,
+    expected_output="Folder structure created and files organized"
+)
+
+crew = Crew(
+    agents=[file_organizer_agent],
+    tasks=[organization_task]
+)
+
+crew.kickoff()
+```
+
+### إدارة الملفات المتقدمة
+
+```python
+from crewai import Agent, Task, Crew
+
+file_manager = Agent(
+    role="File Manager",
+    goal="Maintain organized file structure and manage document lifecycle",
+    backstory="An experienced file manager who ensures documents are properly organized and accessible.",
+    apps=['box']
+)
+
+# Complex task involving multiple Box operations
+management_task = Task(
+    description="""
+    1. List all files in the root folder
+    2. Create monthly archive folders for the current year
+    3. Move old files to appropriate archive folders
+    4. Generate a summary report of the file organization
+    """,
+    agent=file_manager,
+    expected_output="Files organized into archive structure with summary report"
+)
+
+crew = Crew(
+    agents=[file_manager],
+    tasks=[management_task]
+)
+
+crew.kickoff()
+```
@@ -0,0 +1,301 @@
+---
+title: تكامل ClickUp
+description: "إدارة المهام والإنتاجية مع تكامل ClickUp لـ CrewAI."
+icon: "list-check"
+mode: "wide"
+---
+
+## نظرة عامة
+
+مكّن وكلاءك من إدارة المهام والمشاريع وسير عمل الإنتاجية عبر ClickUp. أنشئ المهام وحدّثها، ونظّم المشاريع، وأدر تعيينات الفريق، وبسّط إدارة إنتاجيتك باستخدام الأتمتة المدعومة بالذكاء الاصطناعي.
+
+## المتطلبات الأساسية
+
+قبل استخدام تكامل ClickUp، تأكد من توفر ما يلي:
+
+- حساب [CrewAI AMP](https://app.crewai.com) مع اشتراك فعّال
+- حساب ClickUp بالصلاحيات المناسبة
+- ربط حساب ClickUp الخاص بك عبر [صفحة التكاملات](https://app.crewai.com/crewai_plus/connectors)
+
+## إعداد تكامل ClickUp
+
+### 1. ربط حساب ClickUp الخاص بك
+
+1. انتقل إلى [تكاملات CrewAI AMP](https://app.crewai.com/crewai_plus/connectors)
+2. ابحث عن **ClickUp** في قسم تكاملات المصادقة
+3. انقر على **Connect** وأكمل عملية OAuth
+4. امنح الصلاحيات اللازمة لإدارة المهام والمشاريع
+5. انسخ رمز المؤسسة من [إعدادات التكامل](https://app.crewai.com/crewai_plus/settings/integrations)
+
+### 2. تثبيت الحزمة المطلوبة
+
+```bash
+uv add crewai-tools
+```
+
+### 3. إعداد متغير البيئة
+
+<Note>
+  لاستخدام التكاملات مع `Agent(apps=[])`, يجب تعيين متغير البيئة
+  `CREWAI_PLATFORM_INTEGRATION_TOKEN` برمز المؤسسة الخاص بك.
+</Note>
+
+```bash
+export CREWAI_PLATFORM_INTEGRATION_TOKEN="your_enterprise_token"
+```
+
+أو أضفه إلى ملف `.env`:
+
+```
+CREWAI_PLATFORM_INTEGRATION_TOKEN=your_enterprise_token
+```
+
+## الإجراءات المتاحة
+
+<AccordionGroup>
+  <Accordion title="clickup/search_tasks">
+    **الوصف:** البحث عن المهام في ClickUp باستخدام فلاتر متقدمة.
+
+    **المعاملات:**
+    - `taskFilterFormula` (object, اختياري): فلتر بصيغة التعبير العادي المنفصل - OR لمجموعات AND من شروط فردية.
+      ```json
+      {
+        "operator": "OR",
+        "conditions": [
+          {
+            "operator": "AND",
+            "conditions": [
+              {
+                "field": "statuses%5B%5D",
+                "operator": "$stringExactlyMatches",
+                "value": "open"
+              }
+            ]
+          }
+        ]
+      }
+      ```
+      الحقول المتاحة: `space_ids%5B%5D`, `project_ids%5B%5D`, `list_ids%5B%5D`, `statuses%5B%5D`, `include_closed`, `assignees%5B%5D`, `tags%5B%5D`, `due_date_gt`, `due_date_lt`, `date_created_gt`, `date_created_lt`, `date_updated_gt`, `date_updated_lt`
+
+  </Accordion>
+
+  <Accordion title="clickup/get_task_in_list">
+    **الوصف:** الحصول على المهام في قائمة محددة في ClickUp.
+
+    **المعاملات:**
+    - `listId` (string, مطلوب): القائمة - اختر قائمة للحصول على المهام منها. استخدم إعدادات المستخدم في بوابة الاتصال للسماح للمستخدمين باختيار قائمة ClickUp.
+    - `taskFilterFormula` (string, اختياري): البحث عن المهام التي تطابق الفلاتر المحددة. مثال: name=task1.
+
+  </Accordion>
+
+  <Accordion title="clickup/create_task">
+    **الوصف:** إنشاء مهمة في ClickUp.
+
+    **المعاملات:**
+    - `listId` (string, مطلوب): القائمة - اختر قائمة لإنشاء هذه المهمة فيها.
+    - `name` (string, مطلوب): الاسم - اسم المهمة.
+    - `description` (string, اختياري): الوصف - وصف المهمة.
+    - `status` (string, اختياري): الحالة - اختر حالة لهذه المهمة.
+    - `assignees` (string, اختياري): المكلّفون - اختر عضواً (أو مصفوفة من معرّفات الأعضاء) ليتم تعيينهم لهذه المهمة.
+    - `dueDate` (string, اختياري): تاريخ الاستحقاق - حدد تاريخ استحقاق لهذه المهمة.
+    - `additionalFields` (string, اختياري): حقول إضافية - حدد حقولاً إضافية لتضمينها في هذه المهمة بصيغة JSON.
+
+  </Accordion>
+
+  <Accordion title="clickup/update_task">
+    **الوصف:** تحديث مهمة في ClickUp.
+
+    **المعاملات:**
+    - `taskId` (string, مطلوب): معرّف المهمة - معرّف المهمة المراد تحديثها.
+    - `listId` (string, مطلوب): القائمة - اختر قائمة لإنشاء هذه المهمة فيها.
+    - `name` (string, اختياري): الاسم - اسم المهمة.
+    - `description` (string, اختياري): الوصف - وصف المهمة.
+    - `status` (string, اختياري): الحالة - اختر حالة لهذه المهمة.
+    - `assignees` (string, اختياري): المكلّفون - اختر عضواً (أو مصفوفة من معرّفات الأعضاء) ليتم تعيينهم لهذه المهمة.
+    - `dueDate` (string, اختياري): تاريخ الاستحقاق - حدد تاريخ استحقاق لهذه المهمة.
+    - `additionalFields` (string, اختياري): حقول إضافية - حدد حقولاً إضافية لتضمينها في هذه المهمة بصيغة JSON.
+
+  </Accordion>
+
+  <Accordion title="clickup/delete_task">
+    **الوصف:** حذف مهمة في ClickUp.
+
+    **المعاملات:**
+    - `taskId` (string, مطلوب): معرّف المهمة - معرّف المهمة المراد حذفها.
+
+  </Accordion>
+
+  <Accordion title="clickup/get_list">
+    **الوصف:** الحصول على معلومات القائمة في ClickUp.
+
+    **المعاملات:**
+    - `spaceId` (string, مطلوب): معرّف المساحة - معرّف المساحة التي تحتوي على القوائم.
+
+  </Accordion>
+
+  <Accordion title="clickup/get_custom_fields_in_list">
+    **الوصف:** الحصول على الحقول المخصصة في قائمة في ClickUp.
+
+    **المعاملات:**
+    - `listId` (string, مطلوب): معرّف القائمة - معرّف القائمة للحصول على الحقول المخصصة منها.
+
+  </Accordion>
+
+  <Accordion title="clickup/get_all_fields_in_list">
+    **الوصف:** الحصول على جميع الحقول في قائمة في ClickUp.
+
+    **المعاملات:**
+    - `listId` (string, مطلوب): معرّف القائمة - معرّف القائمة للحصول على جميع الحقول منها.
+
+  </Accordion>
+
+  <Accordion title="clickup/get_space">
+    **الوصف:** الحصول على معلومات المساحة في ClickUp.
+
+    **المعاملات:**
+    - `spaceId` (string, اختياري): معرّف المساحة - معرّف المساحة المراد استرجاعها.
+
+  </Accordion>
+
+  <Accordion title="clickup/get_folders">
+    **الوصف:** الحصول على المجلدات في ClickUp.
+
+    **المعاملات:**
+    - `spaceId` (string, مطلوب): معرّف المساحة - معرّف المساحة التي تحتوي على المجلدات.
+
+  </Accordion>
+
+  <Accordion title="clickup/get_member">
+    **الوصف:** الحصول على معلومات العضو في ClickUp.
+
+    **المعاملات:** لا توجد معاملات مطلوبة.
+
+  </Accordion>
+</AccordionGroup>
+
+## أمثلة الاستخدام
+
+### إعداد Agent أساسي لـ ClickUp
+
+```python
+from crewai import Agent, Task, Crew
+from crewai import Agent, Task, Crew
+
+# Create an agent with Clickup capabilities
+clickup_agent = Agent(
+    role="Task Manager",
+    goal="Manage tasks and projects in ClickUp efficiently",
+    backstory="An AI assistant specialized in task management and productivity coordination.",
+    apps=['clickup']  # All Clickup actions will be available
+)
+
+# Task to create a new task
+create_task = Task(
+    description="Create a task called 'Review Q1 Reports' in the Marketing list with high priority",
+    agent=clickup_agent,
+    expected_output="Task created successfully with task ID"
+)
+
+# Run the task
+crew = Crew(
+    agents=[clickup_agent],
+    tasks=[create_task]
+)
+
+crew.kickoff()
+```
+
+### تصفية أدوات ClickUp محددة
+
+```python
+
+task_coordinator = Agent(
+    role="Task Coordinator",
+    goal="Create and manage tasks efficiently",
+    backstory="An AI assistant that focuses on task creation and status management.",
+    apps=['clickup/create_task']
+)
+
+# Task to manage task workflow
+task_workflow = Task(
+    description="Create a task for project planning and assign it to the development team",
+    agent=task_coordinator,
+    expected_output="Task created and assigned successfully"
+)
+
+crew = Crew(
+    agents=[task_coordinator],
+    tasks=[task_workflow]
+)
+
+crew.kickoff()
+```
+
+### إدارة المشاريع المتقدمة
+
+```python
+from crewai import Agent, Task, Crew
+
+project_manager = Agent(
+    role="Project Manager",
+    goal="Coordinate project activities and track team productivity",
+    backstory="An experienced project manager who ensures projects are delivered on time.",
+    apps=['clickup']
+)
+
+# Complex task involving multiple ClickUp operations
+project_coordination = Task(
+    description="""
+    1. Get all open tasks in the current space
+    2. Identify overdue tasks and update their status
+    3. Create a weekly report task summarizing project progress
+    4. Assign the report task to the team lead
+    """,
+    agent=project_manager,
+    expected_output="Project status updated and weekly report task created and assigned"
+)
+
+crew = Crew(
+    agents=[project_manager],
+    tasks=[project_coordination]
+)
+
+crew.kickoff()
+```
+
+### البحث في المهام وإدارتها
+
+```python
+from crewai import Agent, Task, Crew
+
+task_analyst = Agent(
+    role="Task Analyst",
+    goal="Analyze task patterns and optimize team productivity",
+    backstory="An AI assistant that analyzes task data to improve team efficiency.",
+    apps=['clickup']
+)
+
+# Task to analyze and optimize task distribution
+task_analysis = Task(
+    description="""
+    Search for all tasks assigned to team members in the last 30 days,
+    analyze completion patterns, and create optimization recommendations
+    """,
+    agent=task_analyst,
+    expected_output="Task analysis report with optimization recommendations"
+)
+
+crew = Crew(
+    agents=[task_analyst],
+    tasks=[task_analysis]
+)
+
+crew.kickoff()
+```
+
+### الحصول على المساعدة
+
+<Card title="تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+  تواصل مع فريق الدعم للحصول على المساعدة في إعداد تكامل ClickUp أو
+  استكشاف الأخطاء وإصلاحها.
+</Card>
@@ -0,0 +1,330 @@
+---
+title: تكامل GitHub
+description: "إدارة المستودعات والمشكلات مع تكامل GitHub لـ CrewAI."
+icon: "github"
+mode: "wide"
+---
+
+## نظرة عامة
+
+مكّن وكلاءك من إدارة المستودعات والمشكلات والإصدارات عبر GitHub. أنشئ المشكلات وحدّثها، وأدر الإصدارات، وتتبع تطور المشاريع، وبسّط سير عمل تطوير البرمجيات باستخدام الأتمتة المدعومة بالذكاء الاصطناعي.
+
+## المتطلبات الأساسية
+
+قبل استخدام تكامل GitHub، تأكد من توفر ما يلي:
+
+- حساب [CrewAI AMP](https://app.crewai.com) مع اشتراك فعّال
+- حساب GitHub بصلاحيات المستودع المناسبة
+- ربط حساب GitHub الخاص بك عبر [صفحة التكاملات](https://app.crewai.com/crewai_plus/connectors)
+
+## إعداد تكامل GitHub
+
+### 1. ربط حساب GitHub الخاص بك
+
+1. انتقل إلى [تكاملات CrewAI AMP](https://app.crewai.com/crewai_plus/connectors)
+2. ابحث عن **GitHub** في قسم تكاملات المصادقة
+3. انقر على **Connect** وأكمل عملية OAuth
+4. امنح الصلاحيات اللازمة لإدارة المستودعات والمشكلات
+5. انسخ رمز المؤسسة من [إعدادات التكامل](https://app.crewai.com/crewai_plus/settings/integrations)
+
+### 2. تثبيت الحزمة المطلوبة
+
+```bash
+uv add crewai-tools
+```
+
+### 3. إعداد متغير البيئة
+
+<Note>
+  لاستخدام التكاملات مع `Agent(apps=[])`, يجب تعيين متغير البيئة
+  `CREWAI_PLATFORM_INTEGRATION_TOKEN` برمز المؤسسة الخاص بك.
+</Note>
+
+```bash
+export CREWAI_PLATFORM_INTEGRATION_TOKEN="your_enterprise_token"
+```
+
+أو أضفه إلى ملف `.env`:
+
+```
+CREWAI_PLATFORM_INTEGRATION_TOKEN=your_enterprise_token
+```
+
+## الإجراءات المتاحة
+
+<AccordionGroup>
+  <Accordion title="github/create_issue">
+    **الوصف:** إنشاء مشكلة في GitHub.
+
+    **المعاملات:**
+    - `owner` (string, مطلوب): المالك - حدد اسم مالك الحساب للمستودع المرتبط بهذه المشكلة. (مثال: "abc").
+    - `repo` (string, مطلوب): المستودع - حدد اسم المستودع المرتبط بهذه المشكلة.
+    - `title` (string, مطلوب): عنوان المشكلة - حدد عنوان المشكلة المراد إنشاؤها.
+    - `body` (string, اختياري): محتوى المشكلة - حدد محتوى نص المشكلة المراد إنشاؤها.
+    - `assignees` (string, اختياري): المكلّفون - حدد اسم (أسماء) تسجيل الدخول في GitHub للمكلّفين كمصفوفة من السلاسل النصية لهذه المشكلة. (مثال: `["octocat"]`).
+
+  </Accordion>
+
+  <Accordion title="github/update_issue">
+    **الوصف:** تحديث مشكلة في GitHub.
+
+    **المعاملات:**
+    - `owner` (string, مطلوب): المالك - حدد اسم مالك الحساب للمستودع المرتبط بهذه المشكلة. (مثال: "abc").
+    - `repo` (string, مطلوب): المستودع - حدد اسم المستودع المرتبط بهذه المشكلة.
+    - `issue_number` (string, مطلوب): رقم المشكلة - حدد رقم المشكلة المراد تحديثها.
+    - `title` (string, مطلوب): عنوان المشكلة - حدد عنوان المشكلة المراد تحديثها.
+    - `body` (string, اختياري): محتوى المشكلة - حدد محتوى نص المشكلة المراد تحديثها.
+    - `assignees` (string, اختياري): المكلّفون - حدد اسم (أسماء) تسجيل الدخول في GitHub للمكلّفين كمصفوفة من السلاسل النصية لهذه المشكلة. (مثال: `["octocat"]`).
+    - `state` (string, اختياري): الحالة - حدد الحالة المحدّثة للمشكلة.
+      - الخيارات: `open`, `closed`
+
+  </Accordion>
+
+  <Accordion title="github/get_issue_by_number">
+    **الوصف:** الحصول على مشكلة بواسطة الرقم في GitHub.
+
+    **المعاملات:**
+    - `owner` (string, مطلوب): المالك - حدد اسم مالك الحساب للمستودع المرتبط بهذه المشكلة. (مثال: "abc").
+    - `repo` (string, مطلوب): المستودع - حدد اسم المستودع المرتبط بهذه المشكلة.
+    - `issue_number` (string, مطلوب): رقم المشكلة - حدد رقم المشكلة المراد جلبها.
+
+  </Accordion>
+
+  <Accordion title="github/lock_issue">
+    **الوصف:** قفل مشكلة في GitHub.
+
+    **المعاملات:**
+    - `owner` (string, مطلوب): المالك - حدد اسم مالك الحساب للمستودع المرتبط بهذه المشكلة. (مثال: "abc").
+    - `repo` (string, مطلوب): المستودع - حدد اسم المستودع المرتبط بهذه المشكلة.
+    - `issue_number` (string, مطلوب): رقم المشكلة - حدد رقم المشكلة المراد قفلها.
+    - `lock_reason` (string, مطلوب): سبب القفل - حدد سبب قفل محادثة المشكلة أو طلب السحب.
+      - الخيارات: `off-topic`, `too heated`, `resolved`, `spam`
+
+  </Accordion>
+
+  <Accordion title="github/search_issue">
+    **الوصف:** البحث عن المشكلات في GitHub.
+
+    **المعاملات:**
+    - `owner` (string, مطلوب): المالك - حدد اسم مالك الحساب للمستودع المرتبط بهذه المشكلة. (مثال: "abc").
+    - `repo` (string, مطلوب): المستودع - حدد اسم المستودع المرتبط بهذه المشكلة.
+    - `filter` (object, مطلوب): فلتر بصيغة التعبير العادي المنفصل - OR لمجموعات AND من شروط فردية.
+      ```json
+      {
+        "operator": "OR",
+        "conditions": [
+          {
+            "operator": "AND",
+            "conditions": [
+              {
+                "field": "assignee",
+                "operator": "$stringExactlyMatches",
+                "value": "octocat"
+              }
+            ]
+          }
+        ]
+      }
+      ```
+      الحقول المتاحة: `assignee`, `creator`, `mentioned`, `labels`
+
+  </Accordion>
+
+  <Accordion title="github/create_release">
+    **الوصف:** إنشاء إصدار في GitHub.
+
+    **المعاملات:**
+    - `owner` (string, مطلوب): المالك - حدد اسم مالك الحساب للمستودع المرتبط بهذا الإصدار. (مثال: "abc").
+    - `repo` (string, مطلوب): المستودع - حدد اسم المستودع المرتبط بهذا الإصدار.
+    - `tag_name` (string, مطلوب): الاسم - حدد اسم وسم الإصدار المراد إنشاؤه. (مثال: "v1.0.0").
+    - `target_commitish` (string, اختياري): الهدف - حدد هدف الإصدار. يمكن أن يكون اسم فرع أو SHA لعملية إيداع. الافتراضي هو الفرع الرئيسي. (مثال: "master").
+    - `body` (string, اختياري): المحتوى - حدد وصفاً لهذا الإصدار.
+    - `draft` (string, اختياري): مسودة - حدد ما إذا كان الإصدار المُنشأ يجب أن يكون مسودة (غير منشور).
+      - الخيارات: `true`, `false`
+    - `prerelease` (string, اختياري): إصدار تجريبي - حدد ما إذا كان الإصدار المُنشأ يجب أن يكون إصداراً تجريبياً.
+      - الخيارات: `true`, `false`
+    - `discussion_category_name` (string, اختياري): اسم فئة المناقشة - إذا حُدد، يتم إنشاء مناقشة من الفئة المحددة وربطها بالإصدار.
+    - `generate_release_notes` (string, اختياري): ملاحظات الإصدار - حدد ما إذا كان يجب إنشاء ملاحظات الإصدار تلقائياً.
+      - الخيارات: `true`, `false`
+
+  </Accordion>
+
+  <Accordion title="github/update_release">
+    **الوصف:** تحديث إصدار في GitHub.
+
+    **المعاملات:**
+    - `owner` (string, مطلوب): المالك - حدد اسم مالك الحساب للمستودع المرتبط بهذا الإصدار. (مثال: "abc").
+    - `repo` (string, مطلوب): المستودع - حدد اسم المستودع المرتبط بهذا الإصدار.
+    - `id` (string, مطلوب): معرّف الإصدار - حدد معرّف الإصدار المراد تحديثه.
+    - `tag_name` (string, اختياري): الاسم - حدد اسم وسم الإصدار المراد تحديثه. (مثال: "v1.0.0").
+    - `target_commitish` (string, اختياري): الهدف - حدد هدف الإصدار. يمكن أن يكون اسم فرع أو SHA لعملية إيداع. الافتراضي هو الفرع الرئيسي. (مثال: "master").
+    - `body` (string, اختياري): المحتوى - حدد وصفاً لهذا الإصدار.
+    - `draft` (string, اختياري): مسودة - حدد ما إذا كان الإصدار يجب أن يكون مسودة (غير منشور).
+      - الخيارات: `true`, `false`
+    - `prerelease` (string, اختياري): إصدار تجريبي - حدد ما إذا كان الإصدار يجب أن يكون إصداراً تجريبياً.
+      - الخيارات: `true`, `false`
+    - `discussion_category_name` (string, اختياري): اسم فئة المناقشة - إذا حُدد، يتم إنشاء مناقشة من الفئة المحددة وربطها بالإصدار.
+    - `generate_release_notes` (string, اختياري): ملاحظات الإصدار - حدد ما إذا كان يجب إنشاء ملاحظات الإصدار تلقائياً.
+      - الخيارات: `true`, `false`
+
+  </Accordion>
+
+  <Accordion title="github/get_release_by_id">
+    **الوصف:** الحصول على إصدار بواسطة المعرّف في GitHub.
+
+    **المعاملات:**
+    - `owner` (string, مطلوب): المالك - حدد اسم مالك الحساب للمستودع المرتبط بهذا الإصدار. (مثال: "abc").
+    - `repo` (string, مطلوب): المستودع - حدد اسم المستودع المرتبط بهذا الإصدار.
+    - `id` (string, مطلوب): معرّف الإصدار - حدد معرّف الإصدار المراد جلبه.
+
+  </Accordion>
+
+  <Accordion title="github/get_release_by_tag_name">
+    **الوصف:** الحصول على إصدار بواسطة اسم الوسم في GitHub.
+
+    **المعاملات:**
+    - `owner` (string, مطلوب): المالك - حدد اسم مالك الحساب للمستودع المرتبط بهذا الإصدار. (مثال: "abc").
+    - `repo` (string, مطلوب): المستودع - حدد اسم المستودع المرتبط بهذا الإصدار.
+    - `tag_name` (string, مطلوب): الاسم - حدد وسم الإصدار المراد جلبه. (مثال: "v1.0.0").
+
+  </Accordion>
+
+  <Accordion title="github/delete_release">
+    **الوصف:** حذف إصدار في GitHub.
+
+    **المعاملات:**
+    - `owner` (string, مطلوب): المالك - حدد اسم مالك الحساب للمستودع المرتبط بهذا الإصدار. (مثال: "abc").
+    - `repo` (string, مطلوب): المستودع - حدد اسم المستودع المرتبط بهذا الإصدار.
+    - `id` (string, مطلوب): معرّف الإصدار - حدد معرّف الإصدار المراد حذفه.
+
+  </Accordion>
+</AccordionGroup>
+
+## أمثلة الاستخدام
+
+### إعداد Agent أساسي لـ GitHub
+
+```python
+from crewai import Agent, Task, Crew
+from crewai import Agent, Task, Crew
+
+# Create an agent with Github capabilities
+github_agent = Agent(
+    role="Repository Manager",
+    goal="Manage GitHub repositories, issues, and releases efficiently",
+    backstory="An AI assistant specialized in repository management and issue tracking.",
+    apps=['github']  # All Github actions will be available
+)
+
+# Task to create a new issue
+create_issue_task = Task(
+    description="Create a bug report issue for the login functionality in the main repository",
+    agent=github_agent,
+    expected_output="Issue created successfully with issue number"
+)
+
+# Run the task
+crew = Crew(
+    agents=[github_agent],
+    tasks=[create_issue_task]
+)
+
+crew.kickoff()
+```
+
+### تصفية أدوات GitHub محددة
+
+```python
+
+issue_manager = Agent(
+    role="Issue Manager",
+    goal="Create and manage GitHub issues efficiently",
+    backstory="An AI assistant that focuses on issue tracking and management.",
+    apps=['github/create_issue']
+)
+
+# Task to manage issue workflow
+issue_workflow = Task(
+    description="Create a feature request issue and assign it to the development team",
+    agent=issue_manager,
+    expected_output="Feature request issue created and assigned successfully"
+)
+
+crew = Crew(
+    agents=[issue_manager],
+    tasks=[issue_workflow]
+)
+
+crew.kickoff()
+```
+
+### إدارة الإصدارات
+
+```python
+from crewai import Agent, Task, Crew
+
+release_manager = Agent(
+    role="Release Manager",
+    goal="Manage software releases and versioning",
+    backstory="An experienced release manager who handles version control and release processes.",
+    apps=['github']
+)
+
+# Task to create a new release
+release_task = Task(
+    description="""
+    Create a new release v2.1.0 for the project with:
+    - Auto-generated release notes
+    - Target the main branch
+    - Include a description of new features and bug fixes
+    """,
+    agent=release_manager,
+    expected_output="Release v2.1.0 created successfully with release notes"
+)
+
+crew = Crew(
+    agents=[release_manager],
+    tasks=[release_task]
+)
+
+crew.kickoff()
+```
+
+### تتبع المشكلات وإدارتها
+
+```python
+from crewai import Agent, Task, Crew
+
+project_coordinator = Agent(
+    role="Project Coordinator",
+    goal="Track and coordinate project issues and development progress",
+    backstory="An AI assistant that helps coordinate development work and track project progress.",
+    apps=['github']
+)
+
+# Complex task involving multiple GitHub operations
+coordination_task = Task(
+    description="""
+    1. Search for all open issues assigned to the current milestone
+    2. Identify overdue issues and update their priority labels
+    3. Create a weekly progress report issue
+    4. Lock resolved issues that have been inactive for 30 days
+    """,
+    agent=project_coordinator,
+    expected_output="Project coordination completed with progress report and issue management"
+)
+
+crew = Crew(
+    agents=[project_coordinator],
+    tasks=[coordination_task]
+)
+
+crew.kickoff()
+```
+
+### الحصول على المساعدة
+
+<Card title="تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+  تواصل مع فريق الدعم للحصول على المساعدة في إعداد تكامل GitHub أو
+  استكشاف الأخطاء وإصلاحها.
+</Card>
@@ -0,0 +1,302 @@
+---
+title: تكامل Gmail
+description: "إدارة البريد الإلكتروني وجهات الاتصال مع تكامل Gmail لـ CrewAI."
+icon: "envelope"
+mode: "wide"
+---
+
+## نظرة عامة
+
+مكّن وكلاءك من إدارة رسائل البريد الإلكتروني وجهات الاتصال والمسودات عبر Gmail. أرسل رسائل البريد الإلكتروني، وابحث في الرسائل، وأدر جهات الاتصال، وأنشئ المسودات، وبسّط اتصالات البريد الإلكتروني باستخدام الأتمتة المدعومة بالذكاء الاصطناعي.
+
+## المتطلبات الأساسية
+
+قبل استخدام تكامل Gmail، تأكد من توفر ما يلي:
+
+- حساب [CrewAI AMP](https://app.crewai.com) مع اشتراك فعّال
+- حساب Gmail بالصلاحيات المناسبة
+- ربط حساب Gmail الخاص بك عبر [صفحة التكاملات](https://app.crewai.com/crewai_plus/connectors)
+
+## إعداد تكامل Gmail
+
+### 1. ربط حساب Gmail الخاص بك
+
+1. انتقل إلى [تكاملات CrewAI AMP](https://app.crewai.com/crewai_plus/connectors)
+2. ابحث عن **Gmail** في قسم تكاملات المصادقة
+3. انقر على **Connect** وأكمل عملية OAuth
+4. امنح الصلاحيات اللازمة لإدارة البريد الإلكتروني وجهات الاتصال
+5. انسخ رمز المؤسسة من [إعدادات التكامل](https://app.crewai.com/crewai_plus/settings/integrations)
+
+### 2. تثبيت الحزمة المطلوبة
+
+```bash
+uv add crewai-tools
+```
+
+### 3. إعداد متغير البيئة
+
+<Note>
+  لاستخدام التكاملات مع `Agent(apps=[])`, يجب تعيين متغير البيئة
+  `CREWAI_PLATFORM_INTEGRATION_TOKEN` برمز المؤسسة الخاص بك.
+</Note>
+
+```bash
+export CREWAI_PLATFORM_INTEGRATION_TOKEN="your_enterprise_token"
+```
+
+أو أضفه إلى ملف `.env`:
+
+```
+CREWAI_PLATFORM_INTEGRATION_TOKEN=your_enterprise_token
+```
+
+## الإجراءات المتاحة
+
+<AccordionGroup>
+  <Accordion title="gmail/fetch_emails">
+    **الوصف:** استرجاع قائمة بالرسائل.
+
+    **المعاملات:**
+    - `userId` (string, مطلوب): عنوان البريد الإلكتروني للمستخدم أو 'me' للمستخدم المصادق عليه. (الافتراضي: "me")
+    - `q` (string, اختياري): استعلام بحث لتصفية الرسائل (مثال: 'from:someone@example.com is:unread').
+    - `maxResults` (integer, اختياري): الحد الأقصى لعدد الرسائل المُرجعة (1-500). (الافتراضي: 100)
+    - `pageToken` (string, اختياري): رمز الصفحة لاسترجاع صفحة محددة من النتائج.
+    - `labelIds` (array, اختياري): إرجاع الرسائل ذات التصنيفات التي تطابق جميع معرّفات التصنيف المحددة فقط.
+    - `includeSpamTrash` (boolean, اختياري): تضمين رسائل البريد العشوائي والمحذوفات في النتائج. (الافتراضي: false)
+
+  </Accordion>
+
+  <Accordion title="gmail/send_email">
+    **الوصف:** إرسال بريد إلكتروني.
+
+    **المعاملات:**
+    - `to` (string, مطلوب): عنوان البريد الإلكتروني للمستلم.
+    - `subject` (string, مطلوب): سطر موضوع البريد الإلكتروني.
+    - `body` (string, مطلوب): محتوى رسالة البريد الإلكتروني.
+    - `userId` (string, اختياري): عنوان البريد الإلكتروني للمستخدم أو 'me' للمستخدم المصادق عليه. (الافتراضي: "me")
+    - `cc` (string, اختياري): عناوين نسخة كربونية (مفصولة بفواصل).
+    - `bcc` (string, اختياري): عناوين نسخة كربونية مخفية (مفصولة بفواصل).
+    - `from` (string, اختياري): عنوان المرسل (إذا كان مختلفاً عن المستخدم المصادق عليه).
+    - `replyTo` (string, اختياري): عنوان الرد.
+    - `threadId` (string, اختياري): معرّف السلسلة إذا كان الرد على محادثة موجودة.
+
+  </Accordion>
+
+  <Accordion title="gmail/delete_email">
+    **الوصف:** حذف بريد إلكتروني بواسطة المعرّف.
+
+    **المعاملات:**
+    - `userId` (string, مطلوب): عنوان البريد الإلكتروني للمستخدم أو 'me' للمستخدم المصادق عليه.
+    - `id` (string, مطلوب): معرّف الرسالة المراد حذفها.
+
+  </Accordion>
+
+  <Accordion title="gmail/create_draft">
+    **الوصف:** إنشاء مسودة بريد إلكتروني جديدة.
+
+    **المعاملات:**
+    - `userId` (string, مطلوب): عنوان البريد الإلكتروني للمستخدم أو 'me' للمستخدم المصادق عليه.
+    - `message` (object, مطلوب): كائن الرسالة الذي يحتوي على محتوى المسودة.
+      - `raw` (string, مطلوب): رسالة البريد الإلكتروني بترميز base64url.
+
+  </Accordion>
+
+  <Accordion title="gmail/get_message">
+    **الوصف:** استرجاع رسالة محددة بواسطة المعرّف.
+
+    **المعاملات:**
+    - `userId` (string, مطلوب): عنوان البريد الإلكتروني للمستخدم أو 'me' للمستخدم المصادق عليه. (الافتراضي: "me")
+    - `id` (string, مطلوب): معرّف الرسالة المراد استرجاعها.
+    - `format` (string, اختياري): صيغة إرجاع الرسالة. الخيارات: "full", "metadata", "minimal", "raw". (الافتراضي: "full")
+    - `metadataHeaders` (array, اختياري): عند التحديد وكانت الصيغة METADATA، يتم تضمين الترويسات المحددة فقط.
+
+  </Accordion>
+
+  <Accordion title="gmail/get_attachment">
+    **الوصف:** استرجاع مرفق رسالة.
+
+    **المعاملات:**
+    - `userId` (string, مطلوب): عنوان البريد الإلكتروني للمستخدم أو 'me' للمستخدم المصادق عليه. (الافتراضي: "me")
+    - `messageId` (string, مطلوب): معرّف الرسالة التي تحتوي على المرفق.
+    - `id` (string, مطلوب): معرّف المرفق المراد استرجاعه.
+
+  </Accordion>
+
+  <Accordion title="gmail/fetch_thread">
+    **الوصف:** استرجاع سلسلة بريد إلكتروني محددة بواسطة المعرّف.
+
+    **المعاملات:**
+    - `userId` (string, مطلوب): عنوان البريد الإلكتروني للمستخدم أو 'me' للمستخدم المصادق عليه. (الافتراضي: "me")
+    - `id` (string, مطلوب): معرّف السلسلة المراد استرجاعها.
+    - `format` (string, اختياري): صيغة إرجاع الرسائل. الخيارات: "full", "metadata", "minimal". (الافتراضي: "full")
+    - `metadataHeaders` (array, اختياري): عند التحديد وكانت الصيغة METADATA، يتم تضمين الترويسات المحددة فقط.
+
+  </Accordion>
+
+  <Accordion title="gmail/modify_thread">
+    **الوصف:** تعديل التصنيفات المُطبقة على سلسلة.
+
+    **المعاملات:**
+    - `userId` (string, مطلوب): عنوان البريد الإلكتروني للمستخدم أو 'me' للمستخدم المصادق عليه. (الافتراضي: "me")
+    - `id` (string, مطلوب): معرّف السلسلة المراد تعديلها.
+    - `addLabelIds` (array, اختياري): قائمة بمعرّفات التصنيفات المراد إضافتها لهذه السلسلة.
+    - `removeLabelIds` (array, اختياري): قائمة بمعرّفات التصنيفات المراد إزالتها من هذه السلسلة.
+
+  </Accordion>
+
+  <Accordion title="gmail/trash_thread">
+    **الوصف:** نقل سلسلة إلى سلة المحذوفات.
+
+    **المعاملات:**
+    - `userId` (string, مطلوب): عنوان البريد الإلكتروني للمستخدم أو 'me' للمستخدم المصادق عليه. (الافتراضي: "me")
+    - `id` (string, مطلوب): معرّف السلسلة المراد حذفها.
+
+  </Accordion>
+
+  <Accordion title="gmail/untrash_thread">
+    **الوصف:** إزالة سلسلة من سلة المحذوفات.
+
+    **المعاملات:**
+    - `userId` (string, مطلوب): عنوان البريد الإلكتروني للمستخدم أو 'me' للمستخدم المصادق عليه. (الافتراضي: "me")
+    - `id` (string, مطلوب): معرّف السلسلة المراد استعادتها.
+
+  </Accordion>
+</AccordionGroup>
+
+## أمثلة الاستخدام
+
+### إعداد Agent أساسي لـ Gmail
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create an agent with Gmail capabilities
+gmail_agent = Agent(
+    role="Email Manager",
+    goal="Manage email communications and messages efficiently",
+    backstory="An AI assistant specialized in email management and communication.",
+    apps=['gmail']  # All Gmail actions will be available
+)
+
+# Task to send a follow-up email
+send_email_task = Task(
+    description="Send a follow-up email to john@example.com about the project update meeting",
+    agent=gmail_agent,
+    expected_output="Email sent successfully with confirmation"
+)
+
+# Run the task
+crew = Crew(
+    agents=[gmail_agent],
+    tasks=[send_email_task]
+)
+
+crew.kickoff()
+```
+
+### تصفية أدوات Gmail محددة
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create agent with specific Gmail actions only
+email_coordinator = Agent(
+    role="Email Coordinator",
+    goal="Coordinate email communications and manage drafts",
+    backstory="An AI assistant that focuses on email coordination and draft management.",
+    apps=[
+        'gmail/send_email',
+        'gmail/fetch_emails',
+        'gmail/create_draft'
+    ]
+)
+
+# Task to prepare and send emails
+email_coordination = Task(
+    description="Search for emails from the marketing team, create a summary draft, and send it to stakeholders",
+    agent=email_coordinator,
+    expected_output="Summary email sent to stakeholders"
+)
+
+crew = Crew(
+    agents=[email_coordinator],
+    tasks=[email_coordination]
+)
+
+crew.kickoff()
+```
+
+### البحث في البريد الإلكتروني وتحليله
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create agent with Gmail search and analysis capabilities
+email_analyst = Agent(
+    role="Email Analyst",
+    goal="Analyze email patterns and provide insights",
+    backstory="An AI assistant that analyzes email data to provide actionable insights.",
+    apps=['gmail/fetch_emails', 'gmail/get_message']  # Specific actions for email analysis
+)
+
+# Task to analyze email patterns
+analysis_task = Task(
+    description="""
+    Search for all unread emails from the last 7 days,
+    categorize them by sender domain,
+    and create a summary report of communication patterns
+    """,
+    agent=email_analyst,
+    expected_output="Email analysis report with communication patterns and recommendations"
+)
+
+crew = Crew(
+    agents=[email_analyst],
+    tasks=[analysis_task]
+)
+
+crew.kickoff()
+```
+
+### إدارة السلاسل
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create agent with Gmail thread management capabilities
+thread_manager = Agent(
+    role="Thread Manager",
+    goal="Organize and manage email threads efficiently",
+    backstory="An AI assistant that specializes in email thread organization and management.",
+    apps=[
+        'gmail/fetch_thread',
+        'gmail/modify_thread',
+        'gmail/trash_thread'
+    ]
+)
+
+# Task to organize email threads
+thread_task = Task(
+    description="""
+    1. Fetch all threads from the last month
+    2. Apply appropriate labels to organize threads by project
+    3. Archive or trash threads that are no longer relevant
+    """,
+    agent=thread_manager,
+    expected_output="Email threads organized with appropriate labels and cleanup completed"
+)
+
+crew = Crew(
+    agents=[thread_manager],
+    tasks=[thread_task]
+)
+
+crew.kickoff()
+```
+
+### الحصول على المساعدة
+
+<Card title="تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+  تواصل مع فريق الدعم للحصول على المساعدة في إعداد تكامل Gmail أو
+  استكشاف الأخطاء وإصلاحها.
+</Card>
@@ -0,0 +1,366 @@
+---
+title: تكامل Google Calendar
+description: "إدارة الأحداث والجداول الزمنية مع تكامل Google Calendar لـ CrewAI."
+icon: "calendar"
+mode: "wide"
+---
+
+## نظرة عامة
+
+مكّن وكلاءك من إدارة أحداث التقويم والجداول الزمنية والتوفر عبر Google Calendar. أنشئ الأحداث وحدّثها، وأدر الحضور، وتحقق من التوفر، وبسّط سير عمل الجدولة باستخدام الأتمتة المدعومة بالذكاء الاصطناعي.
+
+## المتطلبات الأساسية
+
+قبل استخدام تكامل Google Calendar، تأكد من توفر ما يلي:
+
+- حساب [CrewAI AMP](https://app.crewai.com) مع اشتراك فعّال
+- حساب Google مع إمكانية الوصول إلى Google Calendar
+- ربط حساب Google الخاص بك عبر [صفحة التكاملات](https://app.crewai.com/crewai_plus/connectors)
+
+## إعداد تكامل Google Calendar
+
+### 1. ربط حساب Google الخاص بك
+
+1. انتقل إلى [تكاملات CrewAI AMP](https://app.crewai.com/crewai_plus/connectors)
+2. ابحث عن **Google Calendar** في قسم تكاملات المصادقة
+3. انقر على **Connect** وأكمل عملية OAuth
+4. امنح الصلاحيات اللازمة للوصول إلى التقويم
+5. انسخ رمز المؤسسة من [إعدادات التكامل](https://app.crewai.com/crewai_plus/settings/integrations)
+
+### 2. تثبيت الحزمة المطلوبة
+
+```bash
+uv add crewai-tools
+```
+
+### 3. إعداد متغير البيئة
+
+<Note>
+  لاستخدام التكاملات مع `Agent(apps=[])`, يجب تعيين متغير البيئة
+  `CREWAI_PLATFORM_INTEGRATION_TOKEN` برمز المؤسسة الخاص بك.
+</Note>
+
+```bash
+export CREWAI_PLATFORM_INTEGRATION_TOKEN="your_enterprise_token"
+```
+
+أو أضفه إلى ملف `.env`:
+
+```
+CREWAI_PLATFORM_INTEGRATION_TOKEN=your_enterprise_token
+```
+
+## الإجراءات المتاحة
+
+<AccordionGroup>
+  <Accordion title="google_calendar/get_availability">
+    **الوصف:** الحصول على توفر التقويم (معلومات مشغول/متاح).
+
+    **المعاملات:**
+    - `timeMin` (string, مطلوب): وقت البداية (بصيغة RFC3339)
+    - `timeMax` (string, مطلوب): وقت النهاية (بصيغة RFC3339)
+    - `items` (array, مطلوب): معرّفات التقاويم المراد التحقق منها
+      ```json
+      [
+        {
+          "id": "calendar_id"
+        }
+      ]
+      ```
+    - `timeZone` (string, اختياري): المنطقة الزمنية المستخدمة في الاستجابة. الافتراضي هو UTC.
+    - `groupExpansionMax` (integer, اختياري): الحد الأقصى لعدد معرّفات التقاويم لمجموعة واحدة. الحد الأقصى: 100
+    - `calendarExpansionMax` (integer, اختياري): الحد الأقصى لعدد التقاويم لتقديم معلومات التوفر. الحد الأقصى: 50
+
+  </Accordion>
+
+  <Accordion title="google_calendar/create_event">
+    **الوصف:** إنشاء حدث جديد في التقويم المحدد.
+
+    **المعاملات:**
+    - `calendarId` (string, مطلوب): معرّف التقويم (استخدم 'primary' للتقويم الرئيسي)
+    - `summary` (string, مطلوب): عنوان/ملخص الحدث
+    - `start_dateTime` (string, مطلوب): وقت البداية بصيغة RFC3339 (مثال: 2024-01-20T10:00:00-07:00)
+    - `end_dateTime` (string, مطلوب): وقت النهاية بصيغة RFC3339
+    - `description` (string, اختياري): وصف الحدث
+    - `timeZone` (string, اختياري): المنطقة الزمنية (مثال: America/Los_Angeles)
+    - `location` (string, اختياري): الموقع الجغرافي للحدث كنص حر.
+    - `attendees` (array, اختياري): قائمة الحضور للحدث.
+      ```json
+      [
+        {
+          "email": "attendee@example.com",
+          "displayName": "Attendee Name",
+          "optional": false
+        }
+      ]
+      ```
+    - `reminders` (object, اختياري): معلومات حول تذكيرات الحدث.
+      ```json
+      {
+        "useDefault": true,
+        "overrides": [
+          {
+            "method": "email",
+            "minutes": 15
+          }
+        ]
+      }
+      ```
+    - `conferenceData` (object, اختياري): المعلومات المتعلقة بالمؤتمر، مثل تفاصيل مؤتمر Google Meet.
+      ```json
+      {
+        "createRequest": {
+          "requestId": "unique-request-id",
+          "conferenceSolutionKey": {
+            "type": "hangoutsMeet"
+          }
+        }
+      }
+      ```
+    - `visibility` (string, اختياري): ظهور الحدث. الخيارات: default, public, private, confidential. الافتراضي: default
+    - `transparency` (string, اختياري): ما إذا كان الحدث يحجب الوقت في التقويم. الخيارات: opaque, transparent. الافتراضي: opaque
+
+  </Accordion>
+
+  <Accordion title="google_calendar/view_events">
+    **الوصف:** استرجاع الأحداث للتقويم المحدد.
+
+    **المعاملات:**
+    - `calendarId` (string, مطلوب): معرّف التقويم (استخدم 'primary' للتقويم الرئيسي)
+    - `timeMin` (string, اختياري): الحد الأدنى للأحداث (بصيغة RFC3339)
+    - `timeMax` (string, اختياري): الحد الأعلى للأحداث (بصيغة RFC3339)
+    - `maxResults` (integer, اختياري): الحد الأقصى لعدد الأحداث (الافتراضي 10). الحد الأدنى: 1، الحد الأقصى: 2500
+    - `orderBy` (string, اختياري): ترتيب الأحداث في النتيجة. الخيارات: startTime, updated. الافتراضي: startTime
+    - `singleEvents` (boolean, اختياري): ما إذا كان يجب توسيع الأحداث المتكررة إلى نُسخ فردية. الافتراضي: true
+    - `showDeleted` (boolean, اختياري): ما إذا كان يجب تضمين الأحداث المحذوفة. الافتراضي: false
+    - `showHiddenInvitations` (boolean, اختياري): ما إذا كان يجب تضمين الدعوات المخفية. الافتراضي: false
+    - `q` (string, اختياري): مصطلحات بحث نصية حرة للعثور على الأحداث المطابقة في أي حقل.
+    - `pageToken` (string, اختياري): رمز يحدد صفحة النتائج المراد إرجاعها.
+    - `timeZone` (string, اختياري): المنطقة الزمنية المستخدمة في الاستجابة.
+    - `updatedMin` (string, اختياري): الحد الأدنى لوقت آخر تعديل للحدث (بصيغة RFC3339) للتصفية.
+    - `iCalUID` (string, اختياري): يحدد معرّف حدث بصيغة iCalendar ليتم تقديمه في الاستجابة.
+
+  </Accordion>
+
+  <Accordion title="google_calendar/update_event">
+    **الوصف:** تحديث حدث موجود.
+
+    **المعاملات:**
+    - `calendarId` (string, مطلوب): معرّف التقويم
+    - `eventId` (string, مطلوب): معرّف الحدث المراد تحديثه
+    - `summary` (string, اختياري): عنوان الحدث المحدّث
+    - `description` (string, اختياري): وصف الحدث المحدّث
+    - `start_dateTime` (string, اختياري): وقت البداية المحدّث
+    - `end_dateTime` (string, اختياري): وقت النهاية المحدّث
+
+  </Accordion>
+
+  <Accordion title="google_calendar/delete_event">
+    **الوصف:** حذف حدث محدد.
+
+    **المعاملات:**
+    - `calendarId` (string, مطلوب): معرّف التقويم
+    - `eventId` (string, مطلوب): معرّف الحدث المراد حذفه
+
+  </Accordion>
+
+  <Accordion title="google_calendar/view_calendar_list">
+    **الوصف:** استرجاع قائمة تقاويم المستخدم.
+
+    **المعاملات:**
+    - `maxResults` (integer, اختياري): الحد الأقصى لعدد الإدخالات في صفحة نتائج واحدة. الحد الأدنى: 1
+    - `pageToken` (string, اختياري): رمز يحدد صفحة النتائج المراد إرجاعها.
+    - `showDeleted` (boolean, اختياري): ما إذا كان يجب تضمين إدخالات قائمة التقويم المحذوفة. الافتراضي: false
+    - `showHidden` (boolean, اختياري): ما إذا كان يجب عرض الإدخالات المخفية. الافتراضي: false
+    - `minAccessRole` (string, اختياري): الحد الأدنى لدور الوصول للمستخدم. الخيارات: freeBusyReader, owner, reader, writer
+
+  </Accordion>
+</AccordionGroup>
+
+## أمثلة الاستخدام
+
+### إعداد Agent أساسي للتقويم
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create an agent with Google Calendar capabilities
+calendar_agent = Agent(
+    role="Schedule Manager",
+    goal="Manage calendar events and scheduling efficiently",
+    backstory="An AI assistant specialized in calendar management and scheduling coordination.",
+    apps=['google_calendar']  # All Google Calendar actions will be available
+)
+
+# Task to create a meeting
+create_meeting_task = Task(
+    description="Create a team standup meeting for tomorrow at 9 AM with the development team",
+    agent=calendar_agent,
+    expected_output="Meeting created successfully with Google Meet link"
+)
+
+# Run the task
+crew = Crew(
+    agents=[calendar_agent],
+    tasks=[create_meeting_task]
+)
+
+crew.kickoff()
+```
+
+### تصفية أدوات التقويم المحددة
+
+```python
+meeting_coordinator = Agent(
+    role="Meeting Coordinator",
+    goal="Coordinate meetings and check availability",
+    backstory="An AI assistant that focuses on meeting scheduling and availability management.",
+    apps=['google_calendar/create_event', 'google_calendar/get_availability']
+)
+
+# Task to schedule a meeting with availability check
+schedule_meeting = Task(
+    description="Check availability for next week and schedule a project review meeting with stakeholders",
+    agent=meeting_coordinator,
+    expected_output="Meeting scheduled after checking availability of all participants"
+)
+
+crew = Crew(
+    agents=[meeting_coordinator],
+    tasks=[schedule_meeting]
+)
+
+crew.kickoff()
+```
+
+### إدارة الأحداث وتحديثاتها
+
+```python
+from crewai import Agent, Task, Crew
+
+event_manager = Agent(
+    role="Event Manager",
+    goal="Manage and update calendar events efficiently",
+    backstory="An experienced event manager who handles event logistics and updates.",
+    apps=['google_calendar']
+)
+
+# Task to manage event updates
+event_management = Task(
+    description="""
+    1. List all events for this week
+    2. Update any events that need location changes to include video conference links
+    3. Check availability for upcoming meetings
+    """,
+    agent=event_manager,
+    expected_output="Weekly events updated with proper locations and availability checked"
+)
+
+crew = Crew(
+    agents=[event_manager],
+    tasks=[event_management]
+)
+
+crew.kickoff()
+```
+
+### التوفر وإدارة التقويم
+
+```python
+from crewai import Agent, Task, Crew
+
+availability_coordinator = Agent(
+    role="Availability Coordinator",
+    goal="Coordinate availability and manage calendars for scheduling",
+    backstory="An AI assistant that specializes in availability management and calendar coordination.",
+    apps=['google_calendar']
+)
+
+# Task to coordinate availability
+availability_task = Task(
+    description="""
+    1. Get the list of available calendars
+    2. Check availability for all calendars next Friday afternoon
+    3. Create a team meeting for the first available 2-hour slot
+    4. Include Google Meet link and send invitations
+    """,
+    agent=availability_coordinator,
+    expected_output="Team meeting scheduled based on availability with all team members invited"
+)
+
+crew = Crew(
+    agents=[availability_coordinator],
+    tasks=[availability_task]
+)
+
+crew.kickoff()
+```
+
+### سير عمل الجدولة الآلية
+
+```python
+from crewai import Agent, Task, Crew
+
+scheduling_automator = Agent(
+    role="Scheduling Automator",
+    goal="Automate scheduling workflows and calendar management",
+    backstory="An AI assistant that automates complex scheduling scenarios and calendar workflows.",
+    apps=['google_calendar']
+)
+
+# Complex scheduling automation task
+automation_task = Task(
+    description="""
+    1. List all upcoming events for the next two weeks
+    2. Identify any scheduling conflicts or back-to-back meetings
+    3. Suggest optimal meeting times by checking availability
+    4. Create buffer time between meetings where needed
+    5. Update event descriptions with agenda items and meeting links
+    """,
+    agent=scheduling_automator,
+    expected_output="Calendar optimized with resolved conflicts, buffer times, and updated meeting details"
+)
+
+crew = Crew(
+    agents=[scheduling_automator],
+    tasks=[automation_task]
+)
+
+crew.kickoff()
+```
+
+## استكشاف الأخطاء وإصلاحها
+
+### المشاكل الشائعة
+
+**أخطاء المصادقة**
+
+- تأكد من أن حساب Google الخاص بك لديه الصلاحيات اللازمة للوصول إلى التقويم
+- تحقق من أن اتصال OAuth يتضمن جميع النطاقات المطلوبة لـ Google Calendar API
+- تحقق مما إذا كانت إعدادات مشاركة التقويم تسمح بمستوى الوصول المطلوب
+
+**مشاكل إنشاء الأحداث**
+
+- تحقق من صحة صيغ الوقت (صيغة RFC3339)
+- تأكد من صحة صيغة عناوين البريد الإلكتروني للحضور
+- تحقق من وجود التقويم المستهدف وإمكانية الوصول إليه
+- تحقق من صحة تحديد المناطق الزمنية
+
+**التوفر وتعارضات الوقت**
+
+- استخدم صيغة RFC3339 المناسبة لنطاقات الوقت عند التحقق من التوفر
+- تأكد من اتساق المناطق الزمنية عبر جميع العمليات
+- تحقق من صحة معرّفات التقاويم عند التحقق من تقاويم متعددة
+
+**تحديث الأحداث وحذفها**
+
+- تحقق من صحة معرّفات الأحداث ووجودها
+- تأكد من أن لديك صلاحيات التحرير للأحداث
+- تحقق من أن ملكية التقويم تسمح بالتعديلات
+
+### الحصول على المساعدة
+
+<Card title="تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+  تواصل مع فريق الدعم للحصول على المساعدة في إعداد تكامل Google Calendar
+  أو استكشاف الأخطاء وإصلاحها.
+</Card>
@@ -0,0 +1,493 @@
+---
+title: تكامل Google Contacts
+description: "إدارة جهات الاتصال والدليل مع تكامل Google Contacts لـ CrewAI."
+icon: "address-book"
+mode: "wide"
+---
+
+## نظرة عامة
+
+مكّن وكلاءك من إدارة جهات الاتصال ومعلومات الدليل عبر Google Contacts. يمكنك الوصول إلى جهات الاتصال الشخصية، والبحث في أشخاص الدليل، وإنشاء معلومات الاتصال وتحديثها، وإدارة مجموعات جهات الاتصال باستخدام الأتمتة المدعومة بالذكاء الاصطناعي.
+
+## المتطلبات الأساسية
+
+قبل استخدام تكامل Google Contacts، تأكد من توفر ما يلي:
+
+- حساب [CrewAI AMP](https://app.crewai.com) مع اشتراك فعّال
+- حساب Google مع إمكانية الوصول إلى Google Contacts
+- ربط حساب Google الخاص بك عبر [صفحة التكاملات](https://app.crewai.com/crewai_plus/connectors)
+
+## إعداد تكامل Google Contacts
+
+### 1. ربط حساب Google الخاص بك
+
+1. انتقل إلى [تكاملات CrewAI AMP](https://app.crewai.com/crewai_plus/connectors)
+2. ابحث عن **Google Contacts** في قسم تكاملات المصادقة
+3. انقر على **Connect** وأكمل عملية OAuth
+4. امنح الصلاحيات اللازمة للوصول إلى جهات الاتصال والدليل
+5. انسخ رمز المؤسسة من [إعدادات التكامل](https://app.crewai.com/crewai_plus/settings/integrations)
+
+### 2. تثبيت الحزمة المطلوبة
+
+```bash
+uv add crewai-tools
+```
+
+### 3. إعداد متغير البيئة
+
+<Note>
+  لاستخدام التكاملات مع `Agent(apps=[])`, يجب تعيين متغير البيئة
+  `CREWAI_PLATFORM_INTEGRATION_TOKEN` برمز المؤسسة الخاص بك.
+</Note>
+
+```bash
+export CREWAI_PLATFORM_INTEGRATION_TOKEN="your_enterprise_token"
+```
+
+أو أضفه إلى ملف `.env`:
+
+```
+CREWAI_PLATFORM_INTEGRATION_TOKEN=your_enterprise_token
+```
+
+## الإجراءات المتاحة
+
+<AccordionGroup>
+  <Accordion title="google_contacts/get_contacts">
+    **الوصف:** استرجاع جهات اتصال المستخدم من Google Contacts.
+
+    **المعاملات:**
+    - `pageSize` (integer, اختياري): عدد جهات الاتصال المراد إرجاعها (الحد الأقصى 1000). الحد الأدنى: 1، الحد الأقصى: 1000
+    - `pageToken` (string, اختياري): رمز الصفحة المراد استرجاعها.
+    - `personFields` (string, اختياري): الحقول المراد تضمينها (مثال: 'names,emailAddresses,phoneNumbers'). الافتراضي: names,emailAddresses,phoneNumbers
+    - `requestSyncToken` (boolean, اختياري): ما إذا كان يجب أن تتضمن الاستجابة رمز مزامنة. الافتراضي: false
+    - `sortOrder` (string, اختياري): ترتيب الفرز للاتصالات. الخيارات: LAST_MODIFIED_ASCENDING, LAST_MODIFIED_DESCENDING, FIRST_NAME_ASCENDING, LAST_NAME_ASCENDING
+
+  </Accordion>
+
+  <Accordion title="google_contacts/search_contacts">
+    **الوصف:** البحث عن جهات اتصال باستخدام سلسلة استعلام.
+
+    **المعاملات:**
+    - `query` (string, مطلوب): سلسلة استعلام البحث
+    - `readMask` (string, مطلوب): الحقول المراد قراءتها (مثال: 'names,emailAddresses,phoneNumbers')
+    - `pageSize` (integer, اختياري): عدد النتائج المراد إرجاعها. الحد الأدنى: 1، الحد الأقصى: 30
+    - `pageToken` (string, اختياري): رمز يحدد صفحة النتائج المراد إرجاعها.
+    - `sources` (array, اختياري): المصادر المراد البحث فيها. الخيارات: READ_SOURCE_TYPE_CONTACT, READ_SOURCE_TYPE_PROFILE. الافتراضي: READ_SOURCE_TYPE_CONTACT
+
+  </Accordion>
+
+  <Accordion title="google_contacts/list_directory_people">
+    **الوصف:** عرض قائمة الأشخاص في دليل المستخدم المصادق عليه.
+
+    **المعاملات:**
+    - `sources` (array, مطلوب): مصادر الدليل المراد البحث فيها. الخيارات: DIRECTORY_SOURCE_TYPE_DOMAIN_PROFILE, DIRECTORY_SOURCE_TYPE_DOMAIN_CONTACT. الافتراضي: DIRECTORY_SOURCE_TYPE_DOMAIN_PROFILE
+    - `pageSize` (integer, اختياري): عدد الأشخاص المراد إرجاعهم. الحد الأدنى: 1، الحد الأقصى: 1000
+    - `pageToken` (string, اختياري): رمز يحدد صفحة النتائج المراد إرجاعها.
+    - `readMask` (string, اختياري): الحقول المراد قراءتها (مثال: 'names,emailAddresses')
+    - `requestSyncToken` (boolean, اختياري): ما إذا كان يجب أن تتضمن الاستجابة رمز مزامنة. الافتراضي: false
+    - `mergeSources` (array, اختياري): بيانات إضافية لدمجها في استجابات أشخاص الدليل. الخيارات: CONTACT
+
+  </Accordion>
+
+  <Accordion title="google_contacts/search_directory_people">
+    **الوصف:** البحث عن أشخاص في الدليل.
+
+    **المعاملات:**
+    - `query` (string, مطلوب): استعلام البحث
+    - `sources` (string, مطلوب): مصادر الدليل (استخدم 'DIRECTORY_SOURCE_TYPE_DOMAIN_PROFILE')
+    - `pageSize` (integer, اختياري): عدد النتائج المراد إرجاعها
+    - `readMask` (string, اختياري): الحقول المراد قراءتها
+
+  </Accordion>
+
+  <Accordion title="google_contacts/list_other_contacts">
+    **الوصف:** عرض جهات الاتصال الأخرى (غير الموجودة في جهات الاتصال الشخصية).
+
+    **المعاملات:**
+    - `pageSize` (integer, اختياري): عدد جهات الاتصال المراد إرجاعها. الحد الأدنى: 1، الحد الأقصى: 1000
+    - `pageToken` (string, اختياري): رمز يحدد صفحة النتائج المراد إرجاعها.
+    - `readMask` (string, اختياري): الحقول المراد قراءتها
+    - `requestSyncToken` (boolean, اختياري): ما إذا كان يجب أن تتضمن الاستجابة رمز مزامنة. الافتراضي: false
+
+  </Accordion>
+
+  <Accordion title="google_contacts/search_other_contacts">
+    **الوصف:** البحث في جهات الاتصال الأخرى.
+
+    **المعاملات:**
+    - `query` (string, مطلوب): استعلام البحث
+    - `readMask` (string, مطلوب): الحقول المراد قراءتها (مثال: 'names,emailAddresses')
+    - `pageSize` (integer, اختياري): عدد النتائج
+
+  </Accordion>
+
+  <Accordion title="google_contacts/get_person">
+    **الوصف:** الحصول على معلومات الاتصال لشخص واحد بواسطة اسم المورد.
+
+    **المعاملات:**
+    - `resourceName` (string, مطلوب): اسم المورد للشخص المراد الحصول عليه (مثال: 'people/c123456789')
+    - `personFields` (string, اختياري): الحقول المراد تضمينها (مثال: 'names,emailAddresses,phoneNumbers'). الافتراضي: names,emailAddresses,phoneNumbers
+
+  </Accordion>
+
+  <Accordion title="google_contacts/create_contact">
+    **الوصف:** إنشاء جهة اتصال جديدة في دفتر عناوين المستخدم.
+
+    **المعاملات:**
+    - `names` (array, اختياري): أسماء الشخص
+      ```json
+      [
+        {
+          "givenName": "John",
+          "familyName": "Doe",
+          "displayName": "John Doe"
+        }
+      ]
+      ```
+    - `emailAddresses` (array, اختياري): عناوين البريد الإلكتروني
+      ```json
+      [
+        {
+          "value": "john.doe@example.com",
+          "type": "work"
+        }
+      ]
+      ```
+    - `phoneNumbers` (array, اختياري): أرقام الهاتف
+      ```json
+      [
+        {
+          "value": "+1234567890",
+          "type": "mobile"
+        }
+      ]
+      ```
+    - `addresses` (array, اختياري): العناوين البريدية
+      ```json
+      [
+        {
+          "formattedValue": "123 Main St, City, State 12345",
+          "type": "home"
+        }
+      ]
+      ```
+    - `organizations` (array, اختياري): المؤسسات/الشركات
+      ```json
+      [
+        {
+          "name": "Company Name",
+          "title": "Job Title",
+          "type": "work"
+        }
+      ]
+      ```
+
+  </Accordion>
+
+  <Accordion title="google_contacts/update_contact">
+    **الوصف:** تحديث معلومات جهة اتصال موجودة.
+
+    **المعاملات:**
+    - `resourceName` (string, مطلوب): اسم المورد للشخص المراد تحديثه (مثال: 'people/c123456789')
+    - `updatePersonFields` (string, مطلوب): الحقول المراد تحديثها (مثال: 'names,emailAddresses,phoneNumbers')
+    - `names` (array, اختياري): أسماء الشخص
+    - `emailAddresses` (array, اختياري): عناوين البريد الإلكتروني
+    - `phoneNumbers` (array, اختياري): أرقام الهاتف
+
+  </Accordion>
+
+  <Accordion title="google_contacts/delete_contact">
+    **الوصف:** حذف جهة اتصال من دفتر عناوين المستخدم.
+
+    **المعاملات:**
+    - `resourceName` (string, مطلوب): اسم المورد للشخص المراد حذفه (مثال: 'people/c123456789')
+
+  </Accordion>
+
+  <Accordion title="google_contacts/batch_get_people">
+    **الوصف:** الحصول على معلومات عن عدة أشخاص في طلب واحد.
+
+    **المعاملات:**
+    - `resourceNames` (array, مطلوب): أسماء موارد الأشخاص المراد الحصول عليهم. الحد الأقصى: 200 عنصر
+    - `personFields` (string, اختياري): الحقول المراد تضمينها (مثال: 'names,emailAddresses,phoneNumbers'). الافتراضي: names,emailAddresses,phoneNumbers
+
+  </Accordion>
+
+  <Accordion title="google_contacts/list_contact_groups">
+    **الوصف:** عرض مجموعات جهات اتصال المستخدم (التصنيفات).
+
+    **المعاملات:**
+    - `pageSize` (integer, اختياري): عدد مجموعات جهات الاتصال المراد إرجاعها. الحد الأدنى: 1، الحد الأقصى: 1000
+    - `pageToken` (string, اختياري): رمز يحدد صفحة النتائج المراد إرجاعها.
+    - `groupFields` (string, اختياري): الحقول المراد تضمينها (مثال: 'name,memberCount,clientData'). الافتراضي: name,memberCount
+
+  </Accordion>
+
+  <Accordion title="google_contacts/get_contact_group">
+    **الوصف:** الحصول على مجموعة جهات اتصال محددة بواسطة اسم المورد.
+
+    **المعاملات:**
+    - `resourceName` (string, مطلوب): اسم المورد لمجموعة جهات الاتصال (مثال: 'contactGroups/myContactGroup')
+    - `maxMembers` (integer, اختياري): الحد الأقصى لعدد الأعضاء المراد تضمينهم. الحد الأدنى: 0، الحد الأقصى: 20000
+    - `groupFields` (string, اختياري): الحقول المراد تضمينها (مثال: 'name,memberCount,clientData'). الافتراضي: name,memberCount
+
+  </Accordion>
+
+  <Accordion title="google_contacts/create_contact_group">
+    **الوصف:** إنشاء مجموعة جهات اتصال جديدة (تصنيف).
+
+    **المعاملات:**
+    - `name` (string, مطلوب): اسم مجموعة جهات الاتصال
+    - `clientData` (array, اختياري): بيانات خاصة بالعميل
+      ```json
+      [
+        {
+          "key": "data_key",
+          "value": "data_value"
+        }
+      ]
+      ```
+
+  </Accordion>
+
+  <Accordion title="google_contacts/update_contact_group">
+    **الوصف:** تحديث معلومات مجموعة جهات اتصال.
+
+    **المعاملات:**
+    - `resourceName` (string, مطلوب): اسم المورد لمجموعة جهات الاتصال (مثال: 'contactGroups/myContactGroup')
+    - `name` (string, مطلوب): اسم مجموعة جهات الاتصال
+    - `clientData` (array, اختياري): بيانات خاصة بالعميل
+      ```json
+      [
+        {
+          "key": "data_key",
+          "value": "data_value"
+        }
+      ]
+      ```
+
+  </Accordion>
+
+  <Accordion title="google_contacts/delete_contact_group">
+    **الوصف:** حذف مجموعة جهات اتصال.
+
+    **المعاملات:**
+    - `resourceName` (string, مطلوب): اسم المورد لمجموعة جهات الاتصال المراد حذفها (مثال: 'contactGroups/myContactGroup')
+    - `deleteContacts` (boolean, اختياري): ما إذا كان يجب حذف جهات الاتصال في المجموعة أيضاً. الافتراضي: false
+
+  </Accordion>
+</AccordionGroup>
+
+## أمثلة الاستخدام
+
+### إعداد Agent أساسي لـ Google Contacts
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create an agent with Google Contacts capabilities
+contacts_agent = Agent(
+    role="Contact Manager",
+    goal="Manage contacts and directory information efficiently",
+    backstory="An AI assistant specialized in contact management and directory operations.",
+    apps=['google_contacts']  # All Google Contacts actions will be available
+)
+
+# Task to retrieve and organize contacts
+contact_management_task = Task(
+    description="Retrieve all contacts and organize them by company affiliation",
+    agent=contacts_agent,
+    expected_output="Contacts retrieved and organized by company with summary report"
+)
+
+# Run the task
+crew = Crew(
+    agents=[contacts_agent],
+    tasks=[contact_management_task]
+)
+
+crew.kickoff()
+```
+
+### البحث في الدليل وإدارته
+
+```python
+from crewai import Agent, Task, Crew
+
+directory_manager = Agent(
+    role="Directory Manager",
+    goal="Search and manage directory people and contacts",
+    backstory="An AI assistant that specializes in directory management and people search.",
+    apps=[
+        'google_contacts/search_directory_people',
+        'google_contacts/list_directory_people',
+        'google_contacts/search_contacts'
+    ]
+)
+
+# Task to search and manage directory
+directory_task = Task(
+    description="Search for team members in the company directory and create a team contact list",
+    agent=directory_manager,
+    expected_output="Team directory compiled with contact information"
+)
+
+crew = Crew(
+    agents=[directory_manager],
+    tasks=[directory_task]
+)
+
+crew.kickoff()
+```
+
+### إنشاء جهات الاتصال وتحديثاتها
+
+```python
+from crewai import Agent, Task, Crew
+
+contact_curator = Agent(
+    role="Contact Curator",
+    goal="Create and update contact information systematically",
+    backstory="An AI assistant that maintains accurate and up-to-date contact information.",
+    apps=['google_contacts']
+)
+
+# Task to create and update contacts
+curation_task = Task(
+    description="""
+    1. Search for existing contacts related to new business partners
+    2. Create new contacts for partners not in the system
+    3. Update existing contact information with latest details
+    4. Organize contacts into appropriate groups
+    """,
+    agent=contact_curator,
+    expected_output="Contact database updated with new partners and organized groups"
+)
+
+crew = Crew(
+    agents=[contact_curator],
+    tasks=[curation_task]
+)
+
+crew.kickoff()
+```
+
+### إدارة مجموعات جهات الاتصال
+
+```python
+from crewai import Agent, Task, Crew
+
+group_organizer = Agent(
+    role="Contact Group Organizer",
+    goal="Organize contacts into meaningful groups and categories",
+    backstory="An AI assistant that specializes in contact organization and group management.",
+    apps=['google_contacts']
+)
+
+# Task to organize contact groups
+organization_task = Task(
+    description="""
+    1. List all existing contact groups
+    2. Analyze contact distribution across groups
+    3. Create new groups for better organization
+    4. Move contacts to appropriate groups based on their information
+    """,
+    agent=group_organizer,
+    expected_output="Contacts organized into logical groups with improved structure"
+)
+
+crew = Crew(
+    agents=[group_organizer],
+    tasks=[organization_task]
+)
+
+crew.kickoff()
+```
+
+### إدارة جهات الاتصال الشاملة
+
+```python
+from crewai import Agent, Task, Crew
+
+contact_specialist = Agent(
+    role="Contact Management Specialist",
+    goal="Provide comprehensive contact management across all sources",
+    backstory="An AI assistant that handles all aspects of contact management including personal, directory, and other contacts.",
+    apps=['google_contacts']
+)
+
+# Complex contact management task
+comprehensive_task = Task(
+    description="""
+    1. Retrieve contacts from all sources (personal, directory, other)
+    2. Search for duplicate contacts and merge information
+    3. Update outdated contact information
+    4. Create missing contacts for important stakeholders
+    5. Organize contacts into meaningful groups
+    6. Generate a comprehensive contact report
+    """,
+    agent=contact_specialist,
+    expected_output="Complete contact management performed with unified contact database and detailed report"
+)
+
+crew = Crew(
+    agents=[contact_specialist],
+    tasks=[comprehensive_task]
+)
+
+crew.kickoff()
+```
+
+## استكشاف الأخطاء وإصلاحها
+
+### المشاكل الشائعة
+
+**أخطاء الصلاحيات**
+
+- تأكد من أن حساب Google الخاص بك لديه الصلاحيات المناسبة للوصول إلى جهات الاتصال
+- تحقق من أن اتصال OAuth يتضمن النطاقات المطلوبة لـ Google Contacts API
+- تحقق من منح صلاحيات الوصول للدليل لجهات اتصال المؤسسة
+
+**مشاكل صيغة اسم المورد**
+
+- تأكد من أن أسماء الموارد تتبع الصيغة الصحيحة (مثال: 'people/c123456789' لجهات الاتصال)
+- تحقق من أن أسماء موارد مجموعات جهات الاتصال تستخدم الصيغة 'contactGroups/groupId'
+- تأكد من وجود أسماء الموارد وإمكانية الوصول إليها
+
+**مشاكل البحث والاستعلام**
+
+- تأكد من صحة صيغة استعلامات البحث وعدم كونها فارغة
+- استخدم حقول readMask المناسبة للبيانات التي تحتاجها
+- تحقق من صحة تحديد مصادر البحث (جهات اتصال مقابل ملفات تعريف)
+
+**إنشاء جهات الاتصال وتحديثاتها**
+
+- تأكد من توفير الحقول المطلوبة عند إنشاء جهات الاتصال
+- تحقق من صحة صيغة عناوين البريد الإلكتروني وأرقام الهاتف
+- تأكد من أن معامل updatePersonFields يتضمن جميع الحقول التي يتم تحديثها
+
+**مشاكل الوصول إلى الدليل**
+
+- تأكد من أن لديك الصلاحيات المناسبة للوصول إلى دليل المؤسسة
+- تحقق من صحة تحديد مصادر الدليل
+- تأكد من أن مؤسستك تسمح بالوصول عبر API إلى معلومات الدليل
+
+**الترقيم والحدود**
+
+- انتبه لحدود حجم الصفحة (تختلف حسب نقطة النهاية)
+- استخدم pageToken للترقيم عبر مجموعات النتائج الكبيرة
+- احترم حدود معدل API وطبّق تأخيرات مناسبة
+
+**مجموعات جهات الاتصال والتنظيم**
+
+- تأكد من أن أسماء مجموعات جهات الاتصال فريدة عند إنشاء مجموعات جديدة
+- تحقق من وجود جهات الاتصال قبل إضافتها إلى المجموعات
+- تأكد من أن لديك صلاحيات تعديل مجموعات جهات الاتصال
+
+### الحصول على المساعدة
+
+<Card title="تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+  تواصل مع فريق الدعم للحصول على المساعدة في إعداد تكامل Google Contacts
+  أو استكشاف الأخطاء وإصلاحها.
+</Card>
@@ -0,0 +1,550 @@
+---
+title: تكامل Google Docs
+description: "إنشاء المستندات وتحريرها مع تكامل Google Docs لـ CrewAI."
+icon: "file-lines"
+mode: "wide"
+---
+
+## نظرة عامة
+
+مكّن وكلاءك من إنشاء وتحرير وإدارة مستندات Google Docs مع معالجة النصوص والتنسيق. أتمت إنشاء المستندات، وأدرج النصوص واستبدلها، وأدر نطاقات المحتوى، وبسّط سير عمل المستندات باستخدام الأتمتة المدعومة بالذكاء الاصطناعي.
+
+## المتطلبات الأساسية
+
+قبل استخدام تكامل Google Docs، تأكد من توفر ما يلي:
+
+- حساب [CrewAI AMP](https://app.crewai.com) مع اشتراك فعّال
+- حساب Google مع إمكانية الوصول إلى Google Docs
+- ربط حساب Google الخاص بك عبر [صفحة التكاملات](https://app.crewai.com/crewai_plus/connectors)
+
+## إعداد تكامل Google Docs
+
+### 1. ربط حساب Google الخاص بك
+
+1. انتقل إلى [تكاملات CrewAI AMP](https://app.crewai.com/crewai_plus/connectors)
+2. ابحث عن **Google Docs** في قسم تكاملات المصادقة
+3. انقر على **Connect** وأكمل عملية OAuth
+4. امنح الصلاحيات اللازمة للوصول إلى المستندات
+5. انسخ رمز المؤسسة من [إعدادات التكامل](https://app.crewai.com/crewai_plus/settings/integrations)
+
+### 2. تثبيت الحزمة المطلوبة
+
+```bash
+uv add crewai-tools
+```
+
+### 3. إعداد متغير البيئة
+
+<Note>
+  لاستخدام التكاملات مع `Agent(apps=[])`, يجب تعيين متغير البيئة
+  `CREWAI_PLATFORM_INTEGRATION_TOKEN` برمز المؤسسة الخاص بك.
+</Note>
+
+```bash
+export CREWAI_PLATFORM_INTEGRATION_TOKEN="your_enterprise_token"
+```
+
+أو أضفه إلى ملف `.env`:
+
+```
+CREWAI_PLATFORM_INTEGRATION_TOKEN=your_enterprise_token
+```
+
+## الإجراءات المتاحة
+
+<AccordionGroup>
+  <Accordion title="google_docs/create_document">
+    **الوصف:** إنشاء مستند Google جديد.
+
+    **المعاملات:**
+    - `title` (string, اختياري): عنوان المستند الجديد.
+
+  </Accordion>
+
+  <Accordion title="google_docs/get_document">
+    **الوصف:** الحصول على محتويات وبيانات وصفية لمستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند المراد استرجاعه.
+    - `includeTabsContent` (boolean, اختياري): ما إذا كان يجب تضمين محتوى علامات التبويب. الافتراضي هو `false`.
+    - `suggestionsViewMode` (string, اختياري): وضع عرض الاقتراحات المراد تطبيقه. القيم: `DEFAULT_FOR_CURRENT_ACCESS`, `PREVIEW_SUGGESTIONS_ACCEPTED`, `PREVIEW_WITHOUT_SUGGESTIONS`. الافتراضي: `DEFAULT_FOR_CURRENT_ACCESS`.
+
+  </Accordion>
+
+  <Accordion title="google_docs/batch_update">
+    **الوصف:** تطبيق تحديث واحد أو أكثر على مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند المراد تحديثه.
+    - `requests` (array, مطلوب): قائمة بالتحديثات المراد تطبيقها على المستند.
+    - `writeControl` (object, اختياري): يوفر التحكم في كيفية تنفيذ طلبات الكتابة.
+
+  </Accordion>
+
+  <Accordion title="google_docs/insert_text">
+    **الوصف:** إدراج نص في مستند Google في موقع محدد.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند المراد تحديثه.
+    - `text` (string, مطلوب): النص المراد إدراجه.
+    - `index` (integer, اختياري): الفهرس القائم على الصفر حيث يتم إدراج النص. الافتراضي هو `1`.
+
+  </Accordion>
+
+  <Accordion title="google_docs/replace_text">
+    **الوصف:** استبدال جميع نُسخ النص في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند المراد تحديثه.
+    - `containsText` (string, مطلوب): النص المراد البحث عنه واستبداله.
+    - `replaceText` (string, مطلوب): النص البديل.
+    - `matchCase` (boolean, اختياري): ما إذا كان البحث يجب أن يراعي حالة الأحرف. الافتراضي هو `false`.
+
+  </Accordion>
+
+  <Accordion title="google_docs/delete_content_range">
+    **الوصف:** حذف المحتوى من نطاق محدد في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند المراد تحديثه.
+    - `startIndex` (integer, مطلوب): فهرس بداية النطاق المراد حذفه.
+    - `endIndex` (integer, مطلوب): فهرس نهاية النطاق المراد حذفه.
+
+  </Accordion>
+
+  <Accordion title="google_docs/insert_page_break">
+    **الوصف:** إدراج فاصل صفحة في موقع محدد في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند المراد تحديثه.
+    - `index` (integer, اختياري): الفهرس القائم على الصفر حيث يتم إدراج فاصل الصفحة. الافتراضي هو `1`.
+
+  </Accordion>
+
+  <Accordion title="google_docs/create_named_range">
+    **الوصف:** إنشاء نطاق مسمّى في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند المراد تحديثه.
+    - `name` (string, مطلوب): اسم النطاق المسمّى.
+    - `startIndex` (integer, مطلوب): فهرس بداية النطاق.
+    - `endIndex` (integer, مطلوب): فهرس نهاية النطاق.
+
+  </Accordion>
+
+  <Accordion title="google_docs/create_document_with_content">
+    **الوصف:** إنشاء مستند Google جديد مع محتوى في إجراء واحد.
+
+    **المعاملات:**
+    - `title` (string, مطلوب): عنوان المستند الجديد.
+    - `content` (string, اختياري): المحتوى النصي المراد إدراجه في المستند. استخدم `\n` لفقرات جديدة.
+
+  </Accordion>
+
+  <Accordion title="google_docs/append_text">
+    **الوصف:** إلحاق نص بنهاية مستند Google. يُدرج تلقائياً في نهاية المستند دون الحاجة لتحديد فهرس.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `text` (string, مطلوب): النص المراد إلحاقه بنهاية المستند. استخدم `\n` لفقرات جديدة.
+
+  </Accordion>
+
+  <Accordion title="google_docs/set_text_bold">
+    **الوصف:** جعل النص غامقاً أو إزالة التنسيق الغامق في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `startIndex` (integer, مطلوب): موضع بداية النص المراد تنسيقه.
+    - `endIndex` (integer, مطلوب): موضع نهاية النص المراد تنسيقه (حصري).
+    - `bold` (boolean, مطلوب): عيّن `true` لجعله غامقاً، `false` لإزالة الغامق.
+
+  </Accordion>
+
+  <Accordion title="google_docs/set_text_italic">
+    **الوصف:** جعل النص مائلاً أو إزالة التنسيق المائل في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `startIndex` (integer, مطلوب): موضع بداية النص المراد تنسيقه.
+    - `endIndex` (integer, مطلوب): موضع نهاية النص المراد تنسيقه (حصري).
+    - `italic` (boolean, مطلوب): عيّن `true` لجعله مائلاً، `false` لإزالة المائل.
+
+  </Accordion>
+
+  <Accordion title="google_docs/set_text_underline">
+    **الوصف:** إضافة أو إزالة تنسيق التسطير من النص في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `startIndex` (integer, مطلوب): موضع بداية النص المراد تنسيقه.
+    - `endIndex` (integer, مطلوب): موضع نهاية النص المراد تنسيقه (حصري).
+    - `underline` (boolean, مطلوب): عيّن `true` للتسطير، `false` لإزالة التسطير.
+
+  </Accordion>
+
+  <Accordion title="google_docs/set_text_strikethrough">
+    **الوصف:** إضافة أو إزالة تنسيق يتوسطه خط من النص في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `startIndex` (integer, مطلوب): موضع بداية النص المراد تنسيقه.
+    - `endIndex` (integer, مطلوب): موضع نهاية النص المراد تنسيقه (حصري).
+    - `strikethrough` (boolean, مطلوب): عيّن `true` لإضافة يتوسطه خط، `false` للإزالة.
+
+  </Accordion>
+
+  <Accordion title="google_docs/set_font_size">
+    **الوصف:** تغيير حجم خط النص في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `startIndex` (integer, مطلوب): موضع بداية النص المراد تنسيقه.
+    - `endIndex` (integer, مطلوب): موضع نهاية النص المراد تنسيقه (حصري).
+    - `fontSize` (number, مطلوب): حجم الخط بالنقاط. الأحجام الشائعة: 10, 11, 12, 14, 16, 18, 24, 36.
+
+  </Accordion>
+
+  <Accordion title="google_docs/set_text_color">
+    **الوصف:** تغيير لون النص باستخدام قيم RGB (مقياس 0-1) في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `startIndex` (integer, مطلوب): موضع بداية النص المراد تنسيقه.
+    - `endIndex` (integer, مطلوب): موضع نهاية النص المراد تنسيقه (حصري).
+    - `red` (number, مطلوب): مكوّن الأحمر (0-1). مثال: `1` للأحمر الكامل.
+    - `green` (number, مطلوب): مكوّن الأخضر (0-1). مثال: `0.5` لنصف الأخضر.
+    - `blue` (number, مطلوب): مكوّن الأزرق (0-1). مثال: `0` لعدم وجود أزرق.
+
+  </Accordion>
+
+  <Accordion title="google_docs/create_hyperlink">
+    **الوصف:** تحويل نص موجود إلى رابط قابل للنقر في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `startIndex` (integer, مطلوب): موضع بداية النص المراد تحويله إلى رابط.
+    - `endIndex` (integer, مطلوب): موضع نهاية النص المراد تحويله إلى رابط (حصري).
+    - `url` (string, مطلوب): عنوان URL الذي يجب أن يشير إليه الرابط. مثال: `"https://example.com"`.
+
+  </Accordion>
+
+  <Accordion title="google_docs/apply_heading_style">
+    **الوصف:** تطبيق نمط عنوان أو فقرة على نطاق نصي في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `startIndex` (integer, مطلوب): موضع بداية الفقرة (الفقرات) المراد تنسيقها.
+    - `endIndex` (integer, مطلوب): موضع نهاية الفقرة (الفقرات) المراد تنسيقها.
+    - `style` (string, مطلوب): النمط المراد تطبيقه. القيم: `NORMAL_TEXT`, `TITLE`, `SUBTITLE`, `HEADING_1`, `HEADING_2`, `HEADING_3`, `HEADING_4`, `HEADING_5`, `HEADING_6`.
+
+  </Accordion>
+
+  <Accordion title="google_docs/set_paragraph_alignment">
+    **الوصف:** تعيين محاذاة النص للفقرات في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `startIndex` (integer, مطلوب): موضع بداية الفقرة (الفقرات) المراد محاذاتها.
+    - `endIndex` (integer, مطلوب): موضع نهاية الفقرة (الفقرات) المراد محاذاتها.
+    - `alignment` (string, مطلوب): محاذاة النص. القيم: `START` (يسار), `CENTER`, `END` (يمين), `JUSTIFIED`.
+
+  </Accordion>
+
+  <Accordion title="google_docs/set_line_spacing">
+    **الوصف:** تعيين تباعد الأسطر للفقرات في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `startIndex` (integer, مطلوب): موضع بداية الفقرة (الفقرات).
+    - `endIndex` (integer, مطلوب): موضع نهاية الفقرة (الفقرات).
+    - `lineSpacing` (number, مطلوب): تباعد الأسطر كنسبة مئوية. `100` = مفرد، `115` = 1.15x، `150` = 1.5x، `200` = مزدوج.
+
+  </Accordion>
+
+  <Accordion title="google_docs/create_paragraph_bullets">
+    **الوصف:** تحويل الفقرات إلى قائمة نقطية أو مرقمة في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `startIndex` (integer, مطلوب): موضع بداية الفقرات المراد تحويلها إلى قائمة.
+    - `endIndex` (integer, مطلوب): موضع نهاية الفقرات المراد تحويلها إلى قائمة.
+    - `bulletPreset` (string, مطلوب): نمط النقاط/الترقيم. القيم: `BULLET_DISC_CIRCLE_SQUARE`, `BULLET_DIAMONDX_ARROW3D_SQUARE`, `BULLET_CHECKBOX`, `BULLET_ARROW_DIAMOND_DISC`, `BULLET_STAR_CIRCLE_SQUARE`, `NUMBERED_DECIMAL_ALPHA_ROMAN`, `NUMBERED_DECIMAL_ALPHA_ROMAN_PARENS`, `NUMBERED_DECIMAL_NESTED`, `NUMBERED_UPPERALPHA_ALPHA_ROMAN`, `NUMBERED_UPPERROMAN_UPPERALPHA_DECIMAL`.
+
+  </Accordion>
+
+  <Accordion title="google_docs/delete_paragraph_bullets">
+    **الوصف:** إزالة النقاط أو الترقيم من الفقرات في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `startIndex` (integer, مطلوب): موضع بداية فقرات القائمة.
+    - `endIndex` (integer, مطلوب): موضع نهاية فقرات القائمة.
+
+  </Accordion>
+
+  <Accordion title="google_docs/insert_table_with_content">
+    **الوصف:** إدراج جدول مع محتوى في مستند Google في إجراء واحد. قدم المحتوى كمصفوفة ثنائية الأبعاد.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `rows` (integer, مطلوب): عدد الصفوف في الجدول.
+    - `columns` (integer, مطلوب): عدد الأعمدة في الجدول.
+    - `index` (integer, اختياري): الموضع لإدراج الجدول. إذا لم يُحدد، يُدرج الجدول في نهاية المستند.
+    - `content` (array, مطلوب): محتوى الجدول كمصفوفة ثنائية الأبعاد. كل مصفوفة داخلية هي صف. مثال: `[["Year", "Revenue"], ["2023", "$43B"], ["2024", "$45B"]]`.
+
+  </Accordion>
+
+  <Accordion title="google_docs/insert_table_row">
+    **الوصف:** إدراج صف جديد فوق أو أسفل خلية مرجعية في جدول موجود.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `tableStartIndex` (integer, مطلوب): فهرس بداية الجدول.
+    - `rowIndex` (integer, مطلوب): فهرس الصف (قائم على الصفر) للخلية المرجعية.
+    - `columnIndex` (integer, اختياري): فهرس العمود (قائم على الصفر) للخلية المرجعية. الافتراضي هو `0`.
+    - `insertBelow` (boolean, اختياري): إذا `true`، يُدرج أسفل الصف المرجعي. إذا `false`، يُدرج فوقه. الافتراضي هو `true`.
+
+  </Accordion>
+
+  <Accordion title="google_docs/insert_table_column">
+    **الوصف:** إدراج عمود جديد يساراً أو يميناً لخلية مرجعية في جدول موجود.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `tableStartIndex` (integer, مطلوب): فهرس بداية الجدول.
+    - `rowIndex` (integer, اختياري): فهرس الصف (قائم على الصفر) للخلية المرجعية. الافتراضي هو `0`.
+    - `columnIndex` (integer, مطلوب): فهرس العمود (قائم على الصفر) للخلية المرجعية.
+    - `insertRight` (boolean, اختياري): إذا `true`، يُدرج إلى اليمين. إذا `false`، يُدرج إلى اليسار. الافتراضي هو `true`.
+
+  </Accordion>
+
+  <Accordion title="google_docs/delete_table_row">
+    **الوصف:** حذف صف من جدول موجود في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `tableStartIndex` (integer, مطلوب): فهرس بداية الجدول.
+    - `rowIndex` (integer, مطلوب): فهرس الصف (قائم على الصفر) المراد حذفه.
+    - `columnIndex` (integer, اختياري): فهرس العمود (قائم على الصفر) لأي خلية في الصف. الافتراضي هو `0`.
+
+  </Accordion>
+
+  <Accordion title="google_docs/delete_table_column">
+    **الوصف:** حذف عمود من جدول موجود في مستند Google.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `tableStartIndex` (integer, مطلوب): فهرس بداية الجدول.
+    - `rowIndex` (integer, اختياري): فهرس الصف (قائم على الصفر) لأي خلية في العمود. الافتراضي هو `0`.
+    - `columnIndex` (integer, مطلوب): فهرس العمود (قائم على الصفر) المراد حذفه.
+
+  </Accordion>
+
+  <Accordion title="google_docs/merge_table_cells">
+    **الوصف:** دمج نطاق من خلايا الجدول في خلية واحدة. يتم الاحتفاظ بمحتوى جميع الخلايا.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `tableStartIndex` (integer, مطلوب): فهرس بداية الجدول.
+    - `rowIndex` (integer, مطلوب): فهرس الصف البادئ (قائم على الصفر) للدمج.
+    - `columnIndex` (integer, مطلوب): فهرس العمود البادئ (قائم على الصفر) للدمج.
+    - `rowSpan` (integer, مطلوب): عدد الصفوف المراد دمجها.
+    - `columnSpan` (integer, مطلوب): عدد الأعمدة المراد دمجها.
+
+  </Accordion>
+
+  <Accordion title="google_docs/unmerge_table_cells">
+    **الوصف:** إلغاء دمج خلايا جدول مدمجة سابقاً وإعادتها إلى خلايا فردية.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `tableStartIndex` (integer, مطلوب): فهرس بداية الجدول.
+    - `rowIndex` (integer, مطلوب): فهرس الصف (قائم على الصفر) للخلية المدمجة.
+    - `columnIndex` (integer, مطلوب): فهرس العمود (قائم على الصفر) للخلية المدمجة.
+    - `rowSpan` (integer, مطلوب): عدد الصفوف التي تمتد عليها الخلية المدمجة.
+    - `columnSpan` (integer, مطلوب): عدد الأعمدة التي تمتد عليها الخلية المدمجة.
+
+  </Accordion>
+
+  <Accordion title="google_docs/insert_inline_image">
+    **الوصف:** إدراج صورة من عنوان URL عام في مستند Google. يجب أن تكون الصورة متاحة للعموم، وأقل من 50 ميجابايت، وبصيغة PNG/JPEG/GIF.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `uri` (string, مطلوب): عنوان URL العام للصورة. يجب أن يكون متاحاً بدون مصادقة.
+    - `index` (integer, اختياري): الموضع لإدراج الصورة. إذا لم يُحدد، تُدرج الصورة في نهاية المستند. الافتراضي هو `1`.
+
+  </Accordion>
+
+  <Accordion title="google_docs/insert_section_break">
+    **الوصف:** إدراج فاصل قسم لإنشاء أقسام مستند بتنسيقات مختلفة.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `index` (integer, مطلوب): الموضع لإدراج فاصل القسم.
+    - `sectionType` (string, مطلوب): نوع فاصل القسم. القيم: `CONTINUOUS` (يبقى في نفس الصفحة), `NEXT_PAGE` (يبدأ صفحة جديدة).
+
+  </Accordion>
+
+  <Accordion title="google_docs/create_header">
+    **الوصف:** إنشاء ترويسة للمستند. يُرجع headerId يمكن استخدامه مع insert_text لإضافة محتوى الترويسة.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `type` (string, اختياري): نوع الترويسة. القيم: `DEFAULT`. الافتراضي هو `DEFAULT`.
+
+  </Accordion>
+
+  <Accordion title="google_docs/create_footer">
+    **الوصف:** إنشاء تذييل للمستند. يُرجع footerId يمكن استخدامه مع insert_text لإضافة محتوى التذييل.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `type` (string, اختياري): نوع التذييل. القيم: `DEFAULT`. الافتراضي هو `DEFAULT`.
+
+  </Accordion>
+
+  <Accordion title="google_docs/delete_header">
+    **الوصف:** حذف ترويسة من المستند. استخدم get_document للعثور على headerId.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `headerId` (string, مطلوب): معرّف الترويسة المراد حذفها.
+
+  </Accordion>
+
+  <Accordion title="google_docs/delete_footer">
+    **الوصف:** حذف تذييل من المستند. استخدم get_document للعثور على footerId.
+
+    **المعاملات:**
+    - `documentId` (string, مطلوب): معرّف المستند.
+    - `footerId` (string, مطلوب): معرّف التذييل المراد حذفه.
+
+  </Accordion>
+</AccordionGroup>
+
+## أمثلة الاستخدام
+
+### إعداد Agent أساسي لـ Google Docs
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create an agent with Google Docs capabilities
+docs_agent = Agent(
+    role="Document Creator",
+    goal="Create and manage Google Docs documents efficiently",
+    backstory="An AI assistant specialized in Google Docs document creation and editing.",
+    apps=['google_docs']  # All Google Docs actions will be available
+)
+
+# Task to create a new document
+create_doc_task = Task(
+    description="Create a new Google Document titled 'Project Status Report'",
+    agent=docs_agent,
+    expected_output="New Google Document 'Project Status Report' created successfully"
+)
+
+# Run the task
+crew = Crew(
+    agents=[docs_agent],
+    tasks=[create_doc_task]
+)
+
+crew.kickoff()
+```
+
+### تحرير النصوص وإدارة المحتوى
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create an agent focused on text editing
+text_editor = Agent(
+    role="Document Editor",
+    goal="Edit and update content in Google Docs documents",
+    backstory="An AI assistant skilled in precise text editing and content management.",
+    apps=['google_docs/insert_text', 'google_docs/replace_text', 'google_docs/delete_content_range']
+)
+
+# Task to edit document content
+edit_content_task = Task(
+    description="In document 'your_document_id', insert the text 'Executive Summary: ' at the beginning, then replace all instances of 'TODO' with 'COMPLETED'.",
+    agent=text_editor,
+    expected_output="Document updated with new text inserted and TODO items replaced."
+)
+
+crew = Crew(
+    agents=[text_editor],
+    tasks=[edit_content_task]
+)
+
+crew.kickoff()
+```
+
+### عمليات المستندات المتقدمة
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create an agent for advanced document operations
+document_formatter = Agent(
+    role="Document Formatter",
+    goal="Apply advanced formatting and structure to Google Docs",
+    backstory="An AI assistant that handles complex document formatting and organization.",
+    apps=['google_docs/batch_update', 'google_docs/insert_page_break', 'google_docs/create_named_range']
+)
+
+# Task to format document
+format_doc_task = Task(
+    description="In document 'your_document_id', insert a page break at position 100, create a named range called 'Introduction' for characters 1-50, and apply batch formatting updates.",
+    agent=document_formatter,
+    expected_output="Document formatted with page break, named range, and styling applied."
+)
+
+crew = Crew(
+    agents=[document_formatter],
+    tasks=[format_doc_task]
+)
+
+crew.kickoff()
+```
+
+## استكشاف الأخطاء وإصلاحها
+
+### المشاكل الشائعة
+
+**أخطاء المصادقة**
+
+- تأكد من أن حساب Google الخاص بك لديه الصلاحيات اللازمة للوصول إلى Google Docs.
+- تحقق من أن اتصال OAuth يتضمن جميع النطاقات المطلوبة (`https://www.googleapis.com/auth/documents`).
+
+**مشاكل معرّف المستند**
+
+- تحقق جيداً من صحة معرّفات المستندات.
+- تأكد من وجود المستند وإمكانية الوصول إليه من حسابك.
+- يمكن العثور على معرّفات المستندات في عنوان URL لـ Google Docs.
+
+**عمليات إدراج النص والنطاقات**
+
+- عند استخدام `insert_text` أو `delete_content_range`، تأكد من صحة مواضع الفهرس.
+- تذكر أن Google Docs يستخدم فهرسة قائمة على الصفر.
+- يجب أن يحتوي المستند على محتوى في مواضع الفهرس المحددة.
+
+**تنسيق طلبات التحديث الدفعي**
+
+- عند استخدام `batch_update`، تأكد من صحة تنسيق مصفوفة `requests` وفقاً لتوثيق Google Docs API.
+- تتطلب التحديثات المعقدة هياكل JSON محددة لكل نوع طلب.
+
+**عمليات استبدال النص**
+
+- لـ `replace_text`، تأكد من مطابقة معامل `containsText` تماماً للنص المراد استبداله.
+- استخدم معامل `matchCase` للتحكم في حساسية حالة الأحرف.
+
+### الحصول على المساعدة
+
+<Card title="تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+  تواصل مع فريق الدعم للحصول على المساعدة في إعداد تكامل Google Docs أو
+  استكشاف الأخطاء وإصلاحها.
+</Card>
@@ -0,0 +1,238 @@
+---
+title: تكامل Google Drive
+description: "تخزين الملفات وإدارتها مع تكامل Google Drive لـ CrewAI."
+icon: "google"
+mode: "wide"
+---
+
+## نظرة عامة
+
+مكّن وكلاءك من إدارة الملفات والمجلدات عبر Google Drive. ارفع الملفات وحمّلها ونظّمها وشاركها، وأنشئ المجلدات، وبسّط سير عمل إدارة المستندات باستخدام الأتمتة المدعومة بالذكاء الاصطناعي.
+
+## المتطلبات الأساسية
+
+قبل استخدام تكامل Google Drive، تأكد من توفر ما يلي:
+
+- حساب [CrewAI AMP](https://app.crewai.com) مع اشتراك فعّال
+- حساب Google مع إمكانية الوصول إلى Google Drive
+- ربط حساب Google الخاص بك عبر [صفحة التكاملات](https://app.crewai.com/crewai_plus/connectors)
+
+## إعداد تكامل Google Drive
+
+### 1. ربط حساب Google الخاص بك
+
+1. انتقل إلى [تكاملات CrewAI AMP](https://app.crewai.com/crewai_plus/connectors)
+2. ابحث عن **Google Drive** في قسم تكاملات المصادقة
+3. انقر على **Connect** وأكمل عملية OAuth
+4. امنح الصلاحيات اللازمة لإدارة الملفات والمجلدات
+5. انسخ رمز المؤسسة من [إعدادات التكامل](https://app.crewai.com/crewai_plus/settings/integrations)
+
+### 2. تثبيت الحزمة المطلوبة
+
+```bash
+uv add crewai-tools
+```
+
+### 3. إعداد متغير البيئة
+
+<Note>
+  لاستخدام التكاملات مع `Agent(apps=[])`, يجب تعيين متغير البيئة
+  `CREWAI_PLATFORM_INTEGRATION_TOKEN` برمز المؤسسة الخاص بك.
+</Note>
+
+```bash
+export CREWAI_PLATFORM_INTEGRATION_TOKEN="your_enterprise_token"
+```
+
+أو أضفه إلى ملف `.env`:
+
+```
+CREWAI_PLATFORM_INTEGRATION_TOKEN=your_enterprise_token
+```
+
+## الإجراءات المتاحة
+
+<AccordionGroup>
+  <Accordion title="google_drive/get_file">
+    **الوصف:** الحصول على ملف بواسطة المعرّف من Google Drive.
+
+    **المعاملات:**
+    - `file_id` (string, مطلوب): معرّف الملف المراد استرجاعه.
+
+  </Accordion>
+
+  <Accordion title="google_drive/list_files">
+    **الوصف:** عرض قائمة الملفات في Google Drive.
+
+    **المعاملات:**
+    - `q` (string, اختياري): سلسلة استعلام لتصفية الملفات (مثال: "name contains 'report'").
+    - `page_size` (integer, اختياري): الحد الأقصى لعدد الملفات المُرجعة (الافتراضي: 100، الحد الأقصى: 1000).
+    - `page_token` (string, اختياري): رمز لاسترجاع الصفحة التالية من النتائج.
+    - `order_by` (string, اختياري): ترتيب الفرز (مثال: "name", "createdTime desc", "modifiedTime").
+    - `spaces` (string, اختياري): قائمة مفصولة بفواصل للمساحات المراد الاستعلام عنها (drive, appDataFolder, photos).
+
+  </Accordion>
+
+  <Accordion title="google_drive/upload_file">
+    **الوصف:** رفع ملف إلى Google Drive.
+
+    **المعاملات:**
+    - `name` (string, مطلوب): اسم الملف المراد إنشاؤه.
+    - `content` (string, مطلوب): محتوى الملف المراد رفعه.
+    - `mime_type` (string, اختياري): نوع MIME للملف (مثال: "text/plain", "application/pdf").
+    - `parent_folder_id` (string, اختياري): معرّف المجلد الأصلي حيث يجب إنشاء الملف.
+    - `description` (string, اختياري): وصف الملف.
+
+  </Accordion>
+
+  <Accordion title="google_drive/download_file">
+    **الوصف:** تحميل ملف من Google Drive.
+
+    **المعاملات:**
+    - `file_id` (string, مطلوب): معرّف الملف المراد تحميله.
+    - `mime_type` (string, اختياري): نوع MIME للتصدير (مطلوب لمستندات Google Workspace).
+
+  </Accordion>
+
+  <Accordion title="google_drive/create_folder">
+    **الوصف:** إنشاء مجلد جديد في Google Drive.
+
+    **المعاملات:**
+    - `name` (string, مطلوب): اسم المجلد المراد إنشاؤه.
+    - `parent_folder_id` (string, اختياري): معرّف المجلد الأصلي حيث يجب إنشاء المجلد الجديد.
+    - `description` (string, اختياري): وصف المجلد.
+
+  </Accordion>
+
+  <Accordion title="google_drive/delete_file">
+    **الوصف:** حذف ملف من Google Drive.
+
+    **المعاملات:**
+    - `file_id` (string, مطلوب): معرّف الملف المراد حذفه.
+
+  </Accordion>
+
+  <Accordion title="google_drive/share_file">
+    **الوصف:** مشاركة ملف في Google Drive مع مستخدمين محددين أو جعله عاماً.
+
+    **المعاملات:**
+    - `file_id` (string, مطلوب): معرّف الملف المراد مشاركته.
+    - `role` (string, مطلوب): الدور الممنوح بهذا الإذن (reader, writer, commenter, owner).
+    - `type` (string, مطلوب): نوع المستفيد (user, group, domain, anyone).
+    - `email_address` (string, اختياري): عنوان البريد الإلكتروني للمستخدم أو المجموعة المراد المشاركة معهم (مطلوب لأنواع user/group).
+    - `domain` (string, اختياري): النطاق المراد المشاركة معه (مطلوب لنوع domain).
+    - `send_notification_email` (boolean, اختياري): ما إذا كان يجب إرسال بريد إلكتروني إشعاري (الافتراضي: true).
+    - `email_message` (string, اختياري): رسالة نصية مخصصة لتضمينها في البريد الإلكتروني الإشعاري.
+
+  </Accordion>
+
+  <Accordion title="google_drive/update_file">
+    **الوصف:** تحديث ملف موجود في Google Drive.
+
+    **المعاملات:**
+    - `file_id` (string, مطلوب): معرّف الملف المراد تحديثه.
+    - `name` (string, اختياري): الاسم الجديد للملف.
+    - `content` (string, اختياري): المحتوى الجديد للملف.
+    - `mime_type` (string, اختياري): نوع MIME الجديد للملف.
+    - `description` (string, اختياري): الوصف الجديد للملف.
+    - `add_parents` (string, اختياري): قائمة مفصولة بفواصل لمعرّفات المجلدات الأصلية المراد إضافتها.
+    - `remove_parents` (string, اختياري): قائمة مفصولة بفواصل لمعرّفات المجلدات الأصلية المراد إزالتها.
+
+  </Accordion>
+</AccordionGroup>
+
+## أمثلة الاستخدام
+
+### إعداد Agent أساسي لـ Google Drive
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create an agent with Google Drive capabilities
+drive_agent = Agent(
+    role="File Manager",
+    goal="Manage files and folders in Google Drive efficiently",
+    backstory="An AI assistant specialized in document and file management.",
+    apps=['google_drive']  # All Google Drive actions will be available
+)
+
+# Task to organize files
+organize_files_task = Task(
+    description="List all files in the root directory and organize them into appropriate folders",
+    agent=drive_agent,
+    expected_output="Summary of files organized with folder structure"
+)
+
+# Run the task
+crew = Crew(
+    agents=[drive_agent],
+    tasks=[organize_files_task]
+)
+
+crew.kickoff()
+```
+
+### تصفية أدوات Google Drive المحددة
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create agent with specific Google Drive actions only
+file_manager_agent = Agent(
+    role="Document Manager",
+    goal="Upload and manage documents efficiently",
+    backstory="An AI assistant that focuses on document upload and organization.",
+    apps=[
+        'google_drive/upload_file',
+        'google_drive/create_folder',
+        'google_drive/share_file'
+    ]  # Specific Google Drive actions
+)
+
+# Task to upload and share documents
+document_task = Task(
+    description="Upload the quarterly report and share it with the finance team",
+    agent=file_manager_agent,
+    expected_output="Document uploaded and sharing permissions configured"
+)
+
+crew = Crew(
+    agents=[file_manager_agent],
+    tasks=[document_task]
+)
+
+crew.kickoff()
+```
+
+### إدارة الملفات المتقدمة
+
+```python
+from crewai import Agent, Task, Crew
+
+file_organizer = Agent(
+    role="File Organizer",
+    goal="Maintain organized file structure and manage permissions",
+    backstory="An experienced file manager who ensures proper organization and access control.",
+    apps=['google_drive']
+)
+
+# Complex task involving multiple Google Drive operations
+organization_task = Task(
+    description="""
+    1. List all files in the shared folder
+    2. Create folders for different document types (Reports, Presentations, Spreadsheets)
+    3. Move files to appropriate folders based on their type
+    4. Set appropriate sharing permissions for each folder
+    5. Create a summary document of the organization changes
+    """,
+    agent=file_organizer,
+    expected_output="Files organized into categorized folders with proper permissions and summary report"
+)
+
+crew = Crew(
+    agents=[file_organizer],
+    tasks=[organization_task]
+)
+
+crew.kickoff()
+```
@@ -0,0 +1,254 @@
+---
+title: تكامل Google Sheets
+description: "مزامنة بيانات جداول البيانات مع تكامل Google Sheets لـ CrewAI."
+icon: "google"
+mode: "wide"
+---
+
+## نظرة عامة
+
+مكّن وكلاءك من إدارة بيانات جداول البيانات عبر Google Sheets. اقرأ الصفوف، وأنشئ إدخالات جديدة، وحدّث البيانات الموجودة، وبسّط سير عمل إدارة البيانات باستخدام الأتمتة المدعومة بالذكاء الاصطناعي. مثالي لتتبع البيانات وإعداد التقارير وإدارة البيانات التعاونية.
+
+## المتطلبات الأساسية
+
+قبل استخدام تكامل Google Sheets، تأكد من توفر ما يلي:
+
+- حساب [CrewAI AMP](https://app.crewai.com) مع اشتراك فعّال
+- حساب Google مع إمكانية الوصول إلى Google Sheets
+- ربط حساب Google الخاص بك عبر [صفحة التكاملات](https://app.crewai.com/crewai_plus/connectors)
+- جداول بيانات بترويسات أعمدة مناسبة لعمليات البيانات
+
+## إعداد تكامل Google Sheets
+
+### 1. ربط حساب Google الخاص بك
+
+1. انتقل إلى [تكاملات CrewAI AMP](https://app.crewai.com/crewai_plus/connectors)
+2. ابحث عن **Google Sheets** في قسم تكاملات المصادقة
+3. انقر على **Connect** وأكمل عملية OAuth
+4. امنح الصلاحيات اللازمة للوصول إلى جداول البيانات
+5. انسخ رمز المؤسسة من [إعدادات التكامل](https://app.crewai.com/crewai_plus/settings/integrations)
+
+### 2. تثبيت الحزمة المطلوبة
+
+```bash
+uv add crewai-tools
+```
+
+### 3. إعداد متغير البيئة
+
+<Note>
+  لاستخدام التكاملات مع `Agent(apps=[])`, يجب تعيين متغير البيئة
+  `CREWAI_PLATFORM_INTEGRATION_TOKEN` برمز المؤسسة الخاص بك.
+</Note>
+
+```bash
+export CREWAI_PLATFORM_INTEGRATION_TOKEN="your_enterprise_token"
+```
+
+أو أضفه إلى ملف `.env`:
+
+```
+CREWAI_PLATFORM_INTEGRATION_TOKEN=your_enterprise_token
+```
+
+## الإجراءات المتاحة
+
+<AccordionGroup>
+  <Accordion title="google_sheets/get_spreadsheet">
+    **الوصف:** استرجاع خصائص وبيانات جدول البيانات.
+
+    **المعاملات:**
+    - `spreadsheetId` (string, مطلوب): معرّف جدول البيانات المراد استرجاعه.
+    - `ranges` (array, اختياري): النطاقات المراد استرجاعها من جدول البيانات.
+    - `includeGridData` (boolean, اختياري): true إذا كان يجب إرجاع بيانات الشبكة. الافتراضي: false
+    - `fields` (string, اختياري): الحقول المراد تضمينها في الاستجابة.
+
+  </Accordion>
+
+  <Accordion title="google_sheets/get_values">
+    **الوصف:** إرجاع نطاق من القيم من جدول البيانات.
+
+    **المعاملات:**
+    - `spreadsheetId` (string, مطلوب): معرّف جدول البيانات المراد استرجاع البيانات منه.
+    - `range` (string, مطلوب): ترميز A1 أو R1C1 للنطاق المراد استرجاع القيم منه.
+    - `valueRenderOption` (string, اختياري): كيفية تمثيل القيم في الإخراج. الخيارات: FORMATTED_VALUE, UNFORMATTED_VALUE, FORMULA. الافتراضي: FORMATTED_VALUE
+    - `dateTimeRenderOption` (string, اختياري): كيفية تمثيل التواريخ والأوقات في الإخراج. الخيارات: SERIAL_NUMBER, FORMATTED_STRING. الافتراضي: SERIAL_NUMBER
+    - `majorDimension` (string, اختياري): البُعد الرئيسي للنتائج. الخيارات: ROWS, COLUMNS. الافتراضي: ROWS
+
+  </Accordion>
+
+  <Accordion title="google_sheets/update_values">
+    **الوصف:** تعيين القيم في نطاق من جدول البيانات.
+
+    **المعاملات:**
+    - `spreadsheetId` (string, مطلوب): معرّف جدول البيانات المراد تحديثه.
+    - `range` (string, مطلوب): ترميز A1 للنطاق المراد تحديثه.
+    - `values` (array, مطلوب): البيانات المراد كتابتها. كل مصفوفة تمثل صفاً.
+      ```json
+      [
+        ["Value1", "Value2", "Value3"],
+        ["Value4", "Value5", "Value6"]
+      ]
+      ```
+    - `valueInputOption` (string, اختياري): كيفية تفسير بيانات الإدخال. الخيارات: RAW, USER_ENTERED. الافتراضي: USER_ENTERED
+
+  </Accordion>
+
+  <Accordion title="google_sheets/append_values">
+    **الوصف:** إلحاق قيم بجدول البيانات.
+
+    **المعاملات:**
+    - `spreadsheetId` (string, مطلوب): معرّف جدول البيانات المراد تحديثه.
+    - `range` (string, مطلوب): ترميز A1 لنطاق البحث عن جدول بيانات منطقي.
+    - `values` (array, مطلوب): البيانات المراد إلحاقها. كل مصفوفة تمثل صفاً.
+      ```json
+      [
+        ["Value1", "Value2", "Value3"],
+        ["Value4", "Value5", "Value6"]
+      ]
+      ```
+    - `valueInputOption` (string, اختياري): كيفية تفسير بيانات الإدخال. الخيارات: RAW, USER_ENTERED. الافتراضي: USER_ENTERED
+    - `insertDataOption` (string, اختياري): كيفية إدراج بيانات الإدخال. الخيارات: OVERWRITE, INSERT_ROWS. الافتراضي: INSERT_ROWS
+
+  </Accordion>
+
+  <Accordion title="google_sheets/create_spreadsheet">
+    **الوصف:** إنشاء جدول بيانات جديد.
+
+    **المعاملات:**
+    - `title` (string, مطلوب): عنوان جدول البيانات الجديد.
+    - `sheets` (array, اختياري): الأوراق التي تشكل جزءاً من جدول البيانات.
+      ```json
+      [
+        {
+          "properties": {
+            "title": "Sheet1"
+          }
+        }
+      ]
+      ```
+
+  </Accordion>
+</AccordionGroup>
+
+## أمثلة الاستخدام
+
+### إعداد Agent أساسي لـ Google Sheets
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create an agent with Google Sheets capabilities
+sheets_agent = Agent(
+    role="Data Manager",
+    goal="Manage spreadsheet data and track information efficiently",
+    backstory="An AI assistant specialized in data management and spreadsheet operations.",
+    apps=['google_sheets']
+)
+
+# Task to add new data to a spreadsheet
+data_entry_task = Task(
+    description="Add a new customer record to the customer database spreadsheet with name, email, and signup date",
+    agent=sheets_agent,
+    expected_output="New customer record added successfully to the spreadsheet"
+)
+
+# Run the task
+crew = Crew(
+    agents=[sheets_agent],
+    tasks=[data_entry_task]
+)
+
+crew.kickoff()
+```
+
+### تصفية أدوات Google Sheets المحددة
+
+```python
+from crewai import Agent, Task, Crew
+
+# Create agent with specific Google Sheets actions only
+data_collector = Agent(
+    role="Data Collector",
+    goal="Collect and organize data in spreadsheets",
+    backstory="An AI assistant that focuses on data collection and organization.",
+    apps=[
+        'google_sheets/get_values',
+        'google_sheets/update_values'
+    ]
+)
+
+# Task to collect and organize data
+data_collection = Task(
+    description="Retrieve current inventory data and add new product entries to the inventory spreadsheet",
+    agent=data_collector,
+    expected_output="Inventory data retrieved and new products added successfully"
+)
+
+crew = Crew(
+    agents=[data_collector],
+    tasks=[data_collection]
+)
+
+crew.kickoff()
+```
+
+### تحليل البيانات وإعداد التقارير
+
+```python
+from crewai import Agent, Task, Crew
+
+data_analyst = Agent(
+    role="Data Analyst",
+    goal="Analyze spreadsheet data and generate insights",
+    backstory="An experienced data analyst who extracts insights from spreadsheet data.",
+    apps=['google_sheets']
+)
+
+# Task to analyze data and create reports
+analysis_task = Task(
+    description="""
+    1. Retrieve all sales data from the current month's spreadsheet
+    2. Analyze the data for trends and patterns
+    3. Create a summary report in a new row with key metrics
+    """,
+    agent=data_analyst,
+    expected_output="Sales data analyzed and summary report created with key insights"
+)
+
+crew = Crew(
+    agents=[data_analyst],
+    tasks=[analysis_task]
+)
+
+crew.kickoff()
+```
+
+## استكشاف الأخطاء وإصلاحها
+
+### المشاكل الشائعة
+
+**أخطاء الصلاحيات**
+
+- تأكد من أن حساب Google الخاص بك لديه صلاحية التحرير على جداول البيانات المستهدفة
+- تحقق من أن اتصال OAuth يتضمن النطاقات المطلوبة لـ Google Sheets API
+- تأكد من مشاركة جداول البيانات مع الحساب المصادق عليه
+
+**مشاكل هيكل جدول البيانات**
+
+- تأكد من أن أوراق العمل تحتوي على ترويسات أعمدة مناسبة قبل إنشاء الصفوف أو تحديثها
+- تحقق من صحة ترميز النطاق (صيغة A1) للخلايا المستهدفة
+- تأكد من وجود معرّف جدول البيانات المحدد وإمكانية الوصول إليه
+
+**مشاكل نوع البيانات والصيغة**
+
+- تأكد من تطابق قيم البيانات مع الصيغة المتوقعة لكل عمود
+- استخدم صيغ التاريخ المناسبة لأعمدة التاريخ (يُنصح بصيغة ISO)
+- تحقق من صحة تنسيق القيم الرقمية لأعمدة الأرقام
+
+### الحصول على المساعدة
+
+<Card title="تحتاج مساعدة؟" icon="headset" href="mailto:support@crewai.com">
+  تواصل مع فريق الدعم للحصول على المساعدة في إعداد تكامل Google Sheets
+  أو استكشاف الأخطاء وإصلاحها.
+</Card>