set tracing if user enables it

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

@@ -33,7 +33,7 @@ jobs:
       - name: Install dependencies and populate cache
         run: |
           echo "Building global UV cache for Python ${{ matrix.python-version }}..."
-          uv sync --all-groups --all-extras
+          uv sync --all-groups --all-extras --no-install-project
           echo "Cache populated successfully"
 
       - name: Save uv caches

.github/workflows/linter.yml

@@ -38,7 +38,7 @@ jobs:
           enable-cache: false
 
       - name: Install dependencies
-        run: uv sync --all-packages --all-extras --no-install-project
+        run: uv sync --all-groups --all-extras --no-install-project
 
       - name: Get Changed Python Files
         id: changed-files

.github/workflows/tests.yml

@@ -25,17 +25,17 @@ jobs:
         with:
           fetch-depth: 0  # Fetch all history for proper diff
 
-      # - name: Restore global uv cache
-      #   id: cache-restore
-      #   uses: actions/cache/restore@v4
-      #   with:
-      #     path: |
-      #       ~/.cache/uv
-      #       ~/.local/share/uv
-      #       .venv
-      #     key: uv-main-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}
-      #     restore-keys: |
-      #       uv-main-py${{ matrix.python-version }}-
+      - name: Restore global uv cache
+        id: cache-restore
+        uses: actions/cache/restore@v4
+        with:
+          path: |
+            ~/.cache/uv
+            ~/.local/share/uv
+            .venv
+          key: uv-main-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}
+          restore-keys: |
+            uv-main-py${{ matrix.python-version }}-
 
       - name: Install uv
         uses: astral-sh/setup-uv@v6
@@ -45,24 +45,24 @@ jobs:
           enable-cache: false
 
       - name: Install the project
-        run: uv sync --all-packages --all-extras
+        run: uv sync --all-groups --all-extras
 
-      # - name: Restore test durations
-      #   uses: actions/cache/restore@v4
-      #   with:
-      #     path: .test_durations_py*
-      #     key: test-durations-py${{ matrix.python-version }}
+      - name: Restore test durations
+        uses: actions/cache/restore@v4
+        with:
+          path: .test_durations_py*
+          key: test-durations-py${{ matrix.python-version }}
 
       - name: Run tests (group ${{ matrix.group }} of 8)
         run: |
           PYTHON_VERSION_SAFE=$(echo "${{ matrix.python-version }}" | tr '.' '_')
           DURATION_FILE=".test_durations_py${PYTHON_VERSION_SAFE}"
-
+          
           # Temporarily always skip cached durations to fix test splitting
           # When durations don't match, pytest-split runs duplicate tests instead of splitting
           echo "Using even test splitting (duration cache disabled until fix merged)"
           DURATIONS_ARG=""
-
+          
           # Original logic (disabled temporarily):
           # if [ ! -f "$DURATION_FILE" ]; then
           #   echo "No cached durations found, tests will be split evenly"
@@ -74,8 +74,8 @@ jobs:
           #   echo "No test changes detected, using cached test durations for optimal splitting"
           #   DURATIONS_ARG="--durations-path=${DURATION_FILE}"
           # fi
-
-          uv run pytest lib/crewai \
+          
+          uv run pytest \
             --block-network \
             --timeout=30 \
             -vv \
@@ -84,15 +84,14 @@ jobs:
             $DURATIONS_ARG \
             --durations=10 \
             -n auto \
-            --maxfail=3 \
-            -m "not requires_local_services"
+            --maxfail=3
 
-      # - 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-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}
+      - 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-py${{ matrix.python-version }}-${{ hashFiles('uv.lock') }}

.github/workflows/type-checker.yml

@@ -40,7 +40,7 @@ jobs:
           enable-cache: false
 
       - name: Install dependencies
-        run: uv sync --all-packages --all-extras
+        run: uv sync --all-groups --all-extras
 
       - name: Get changed Python files
         id: changed-files

.gitignore

@@ -2,6 +2,7 @@
 .pytest_cache
 __pycache__
 dist/
+lib/
 .env
 assets/*
 .idea

.pre-commit-config.yaml

@@ -6,19 +6,14 @@ repos:
         entry: uv run ruff check
         language: system
         types: [python]
-        files: ^lib/crewai/src/
-        exclude: ^lib/crewai/
       - id: ruff-format
         name: ruff-format
         entry: uv run ruff format
         language: system
         types: [python]
-        files: ^lib/crewai/src/
-        exclude: ^lib/crewai/
       - id: mypy
         name: mypy
         entry: uv run mypy
         language: system
         types: [python]
-        files: ^lib/crewai/src/
-        exclude: ^lib/crewai/
+        exclude: ^tests/

docs/en/changelog.mdx

@@ -5,82 +5,6 @@ icon: "clock"
 mode: "wide"
 ---
 
-<Update label="Sep 20, 2025">
-  ## v0.193.2
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.193.2)
-
-  ## What's Changed
-
-  - Updated pyproject templates to use the right version
-
-</Update>
-
-<Update label="Sep 20, 2025">
-  ## v0.193.1
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.193.1)
-
-  ## What's Changed
-
-  - Series of minor fixes and linter improvements
-
-</Update>
-
-<Update label="Sep 19, 2025">
-  ## v0.193.0
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.193.0)
-
-  ## Core Improvements & Fixes
-  
-  - Fixed handling of the `model` parameter during OpenAI adapter initialization  
-  - Resolved test duration cache issues in CI workflows  
-  - Fixed flaky test related to repeated tool usage by agents  
-  - Added missing event exports to `__init__.py` for consistent module behavior  
-  - Dropped message storage from metadata in Mem0 to reduce bloat  
-  - Fixed L2 distance metric support for backward compatibility in vector search  
-
-  ## New Features & Enhancements
-  
-  - Introduced thread-safe platform context management  
-  - Added test duration caching for optimized `pytest-split` runs  
-  - Added ephemeral trace improvements for better trace control  
-  - Made search parameters for RAG, knowledge, and memory fully configurable  
-  - Enabled ChromaDB to use OpenAI API for embedding functions  
-  - Added deeper observability tools for user-level insights  
-  - Unified RAG storage system with instance-specific client support  
-
-  ## Documentation & Guides
-  
-  - Updated `RagTool` references to reflect CrewAI native RAG implementation  
-  - Improved internal docs for `langgraph` and `openai` agent adapters with type annotations and docstrings  
-
-</Update>
-
-<Update label="Sep 11, 2025">
-  ## v0.186.1
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.186.1)
-
-  ## What's Changed
-
-  - Fixed version not being found and silently failing reversion  
-  - Bumped CrewAI version to 0.186.1 and updated dependencies in the CLI  
-
-</Update>
-
-<Update label="Sep 10, 2025">
-  ## v0.186.0
-
-  [View release on GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.186.0)
-
-  ## What's Changed
-
-  - Refer to the GitHub release notes for detailed changes
-
-</Update>
-
 <Update label="Sep 04, 2025">
   ## v0.177.0
 

docs/en/concepts/cli.mdx

@@ -404,10 +404,6 @@ crewai config reset
 After resetting configuration, re-run `crewai login` to authenticate again.
 </Tip>
 
-<Tip>
-CrewAI CLI handles authentication to the Tool Repository automatically when adding packages to your project. Just append `crewai` before any `uv` command to use it. E.g. `crewai uv add requests`. For more information, see [Tool Repository](https://docs.crewai.com/enterprise/features/tool-repository) docs.
-</Tip>
-
 <Note>
 Configuration settings are stored in `~/.config/crewai/settings.json`. Some settings like organization name and UUID are read-only and managed through authentication and organization commands. Tool repository related settings are hidden and cannot be set directly by users.
 </Note>

docs/en/enterprise/features/tool-repository.mdx

@@ -52,36 +52,6 @@ researcher = Agent(
 )
 ```
 
-## Adding other packages after installing a tool
-
-After installing a tool from the CrewAI Enterprise Tool Repository, you need to use the `crewai uv` command to add other packages to your project.
-Using pure `uv` commands will fail due to authentication to tool repository being handled by the CLI. By using the `crewai uv` command, you can add other packages to your project without having to worry about authentication.
-Any `uv` command can be used with the `crewai uv` command, making it a powerful tool for managing your project's dependencies without the hassle of managing authentication through environment variables or other methods.
-
-Say that you have installed a custom tool from the CrewAI Enterprise Tool Repository called "my-tool":
-
-```bash
-crewai tool install my-tool
-```
-
-And now you want to add another package to your project, you can use the following command:
-
-```bash
-crewai uv add requests
-```
-
-Other commands like `uv sync` or `uv remove` can also be used with the `crewai uv` command:
-
-```bash
-crewai uv sync
-```
-
-```bash
-crewai uv remove requests
-```
-
-This will add the package to your project and update `pyproject.toml` accordingly.
-
 ## Creating and Publishing Tools
 
 To create a new tool project:

docs/en/quickstart.mdx

@@ -27,7 +27,7 @@ Follow the steps below to get Crewing! 🚣‍♂️
   <Step title="Navigate to your new crew project">
     <CodeGroup>
       ```shell Terminal
-      cd latest_ai_development
+      cd latest-ai-development
       ```
     </CodeGroup>
   </Step>

docs/en/tools/ai-ml/ragtool.mdx

@@ -9,7 +9,7 @@ mode: "wide"
 
 ## Description
 
-The `RagTool` is designed to answer questions by leveraging the power of Retrieval-Augmented Generation (RAG) through CrewAI's native RAG system.
+The `RagTool` is designed to answer questions by leveraging the power of Retrieval-Augmented Generation (RAG) through EmbedChain.
 It provides a dynamic knowledge base that can be queried to retrieve relevant information from various data sources.
 This tool is particularly useful for applications that require access to a vast array of information and need to provide contextually relevant answers.
 
@@ -76,8 +76,8 @@ The `RagTool` can be used with a wide variety of data sources, including:
 The `RagTool` accepts the following parameters:
 
 - **summarize**: Optional. Whether to summarize the retrieved content. Default is `False`.
-- **adapter**: Optional. A custom adapter for the knowledge base. If not provided, a CrewAIRagAdapter will be used.
-- **config**: Optional. Configuration for the underlying CrewAI RAG system.
+- **adapter**: Optional. A custom adapter for the knowledge base. If not provided, an EmbedchainAdapter will be used.
+- **config**: Optional. Configuration for the underlying EmbedChain App.
 
 ## Adding Content
 
@@ -130,23 +130,44 @@ from crewai_tools import RagTool
 
 # Create a RAG tool with custom configuration
 config = {
-    "vectordb": {
-        "provider": "qdrant",
+    "app": {
+        "name": "custom_app",
+    },
+    "llm": {
+        "provider": "openai",
         "config": {
-            "collection_name": "my-collection"
+            "model": "gpt-4",
         }
     },
     "embedding_model": {
         "provider": "openai",
         "config": {
-            "model": "text-embedding-3-small"
+            "model": "text-embedding-ada-002"
         }
+    },
+    "vectordb": {
+        "provider": "elasticsearch",
+        "config": {
+            "collection_name": "my-collection",
+            "cloud_id": "deployment-name:xxxx",
+            "api_key": "your-key",
+            "verify_certs": False
+        }
+    },
+    "chunker": {
+        "chunk_size": 400,
+        "chunk_overlap": 100,
+        "length_function": "len",
+        "min_chunk_size": 0
     }
 }
 
 rag_tool = RagTool(config=config, summarize=True)
 ```
 
+The internal RAG tool utilizes the Embedchain adapter, allowing you to pass any configuration options that are supported by Embedchain.
+You can refer to the [Embedchain documentation](https://docs.embedchain.ai/components/introduction) for details.
+Make sure to review the configuration options available in the .yaml file.
 
 ## Conclusion
 The `RagTool` provides a powerful way to create and query knowledge bases from various data sources. By leveraging Retrieval-Augmented Generation, it enables agents to access and retrieve relevant information efficiently, enhancing their ability to provide accurate and contextually appropriate responses.

docs/ko/changelog.mdx

@@ -5,82 +5,6 @@ icon: "clock"
 mode: "wide"
 ---
 
-<Update label="2025년 9월 20일">
-  ## v0.193.2
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/0.193.2)
-
-  ## 변경 사항
-  
-  - 올바른 버전을 사용하도록 pyproject 템플릿 업데이트
-
-</Update>
-
-<Update label="2025년 9월 20일">
-  ## v0.193.1
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/0.193.1)
-
-  ## 변경 사항
-  
-  - 일련의 사소한 수정 및 린터 개선
-
-</Update>
-
-<Update label="2025년 9월 19일">
-  ## v0.193.0
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/0.193.0)
-
-  ## 핵심 개선 사항 및 수정 사항
-  
-  - OpenAI 어댑터 초기화 중 `model` 매개변수 처리 수정  
-  - CI 워크플로에서 테스트 소요 시간 캐시 문제 해결  
-  - 에이전트의 반복 도구 사용과 관련된 불안정한 테스트 수정  
-  - 일관된 모듈 동작을 위해 누락된 이벤트 내보내기를 `__init__.py`에 추가  
-  - 메타데이터 부하를 줄이기 위해 Mem0에서 메시지 저장 제거  
-  - 벡터 검색의 하위 호환성을 위해 L2 거리 메트릭 지원 수정  
-
-  ## 새로운 기능 및 향상 사항
-  
-  - 스레드 안전한 플랫폼 컨텍스트 관리 도입  
-  - `pytest-split` 실행 최적화를 위한 테스트 소요 시간 캐싱 추가  
-  - 더 나은 추적 제어를 위한 일시적(trace) 개선  
-  - RAG, 지식, 메모리 검색 매개변수를 완전 구성 가능하게 변경  
-  - ChromaDB가 임베딩 함수에 OpenAI API를 사용할 수 있도록 지원  
-  - 사용자 수준 인사이트를 위한 심화된 관찰 가능성 도구 추가  
-  - 인스턴스별 클라이언트를 지원하는 통합 RAG 스토리지 시스템  
-
-  ## 문서 및 가이드
-  
-  - CrewAI 네이티브 RAG 구현을 반영하도록 `RagTool` 참조 업데이트  
-  - 타입 주석과 도크스트링을 포함해 `langgraph` 및 `openai` 에이전트 어댑터 내부 문서 개선  
-
-</Update>
-
-<Update label="2025년 9월 11일">
-  ## v0.186.1
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/0.186.1)
-
-  ## 변경 사항
-  
-  - 버전을 찾지 못해 조용히 되돌리는(reversion) 문제 수정  
-  - CLI에서 CrewAI 버전을 0.186.1로 올리고 의존성 업데이트  
-
-</Update>
-
-<Update label="2025년 9월 10일">
-  ## v0.186.0
-
-  [GitHub 릴리스 보기](https://github.com/crewAIInc/crewAI/releases/tag/0.186.0)
-
-  ## 변경 사항
-  
-  - 자세한 변경 사항은 GitHub 릴리스 노트를 참조하세요
-
-</Update>
-
 <Update label="2025년 9월 4일">
   ## v0.177.0
 

docs/ko/quickstart.mdx

@@ -27,7 +27,7 @@ mode: "wide"
   <Step title="새로운 crew 프로젝트로 이동하기">
     <CodeGroup>
       ```shell Terminal
-      cd latest_ai_development
+      cd latest-ai-development
       ```
     </CodeGroup>
   </Step>

docs/pt-BR/changelog.mdx

@@ -5,82 +5,6 @@ icon: "clock"
 mode: "wide"
 ---
 
-<Update label="20 set 2025">
-  ## v0.193.2
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.193.2)
-
-  ## O que Mudou
-
-  - Atualizados templates do pyproject para usar a versão correta
-
-</Update>
-
-<Update label="20 set 2025">
-  ## v0.193.1
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.193.1)
-
-  ## O que Mudou
-
-  - Série de pequenas correções e melhorias de linter
-
-</Update>
-
-<Update label="19 set 2025">
-  ## v0.193.0
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.193.0)
-
-  ## Melhorias e Correções Principais
-  
-  - Corrigido manuseio do parâmetro `model` durante a inicialização do adaptador OpenAI  
-  - Resolvidos problemas de cache da duração de testes nos fluxos de CI  
-  - Corrigido teste instável relacionado ao uso repetido de ferramentas pelos agentes  
-  - Adicionadas exportações de eventos ausentes no `__init__.py` para comportamento consistente do módulo  
-  - Removido armazenamento de mensagem dos metadados no Mem0 para reduzir inchaço  
-  - Corrigido suporte à métrica de distância L2 para compatibilidade retroativa na busca vetorial  
-
-  ## Novos Recursos e Melhorias
-  
-  - Introduzida gestão de contexto de plataforma com segurança de threads  
-  - Adicionado cache da duração de testes para execuções otimizadas do `pytest-split`  
-  - Melhorias de traces efêmeros para melhor controle de rastreamento  
-  - Parâmetros de busca para RAG, conhecimento e memória totalmente configuráveis  
-  - Habilitado ChromaDB para usar a OpenAI API para funções de embedding  
-  - Adicionadas ferramentas de observabilidade mais profundas para insights ao nível do usuário  
-  - Sistema de armazenamento RAG unificado com suporte a cliente específico por instância  
-
-  ## Documentação e Guias
-  
-  - Atualizadas referências do `RagTool` para refletir a implementação nativa de RAG do CrewAI  
-  - Melhorada documentação interna para adaptadores de agente `langgraph` e `openai` com anotações de tipo e docstrings  
-
-</Update>
-
-<Update label="11 set 2025">
-  ## v0.186.1
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.186.1)
-
-  ## O que Mudou
-
-  - Corrigida falha silenciosa de reversão quando a versão não era encontrada  
-  - Versão do CrewAI atualizada para 0.186.1 e dependências do CLI atualizadas  
-
-</Update>
-
-<Update label="10 set 2025">
-  ## v0.186.0
-
-  [Ver release no GitHub](https://github.com/crewAIInc/crewAI/releases/tag/0.186.0)
-
-  ## O que Mudou
-
-  - Consulte as notas de lançamento no GitHub para detalhes completos
-
-</Update>
-
 <Update label="04 set 2025">
   ## v0.177.0
 

docs/pt-BR/quickstart.mdx

@@ -27,7 +27,7 @@ Siga os passos abaixo para começar a tripular! 🚣‍♂️
   <Step title="Navegue até o novo projeto da sua tripulação">
     <CodeGroup>
       ```shell Terminal
-      cd latest_ai_development
+      cd latest-ai-development
       ```
     </CodeGroup>
   </Step>

lib/crewai/.python-version

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

lib/crewai/pyproject.toml

@@ -1,124 +0,0 @@
-[project]
-name = "crewai"
-dynamic = ["version"]
-description = ""
-readme = "README.md"
-authors = [
-    { name = "Greyson Lalonde", email = "greyson.r.lalonde@gmail.com" }
-]
-keywords = [
-    "crewai",
-    "ai",
-    "agents",
-    "framework",
-    "orchestration",
-    "llm",
-    "core",
-    "typed",
-]
-classifiers = [
-    "Development Status :: 3 - Alpha",
-    "Intended Audience :: Developers",
-    "Operating System :: OS Independent",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
-    "Topic :: Software Development :: Libraries :: Python Modules",
-    "Typing :: Typed",
-]
-requires-python = ">=3.10, <3.14"
-dependencies = [
-    # Core Dependencies
-    "crewai",
-    "pydantic>=2.11.9",
-    "openai>=1.13.3",
-    "litellm==1.74.9",
-    "instructor>=1.3.3",
-    # Text Processing
-    "pdfplumber>=0.11.4",
-    "regex>=2024.9.11",
-    # Telemetry and Monitoring
-    "opentelemetry-api>=1.30.0",
-    "opentelemetry-sdk>=1.30.0",
-    "opentelemetry-exporter-otlp-proto-http>=1.30.0",
-    "tokenizers>=0.20.3",
-    "openpyxl>=3.1.5",
-    "pyvis>=0.3.2",
-    # Authentication and Security
-    "python-dotenv>=1.1.1",
-    "pyjwt>=2.9.0",
-    # Configuration and Utils
-    "click>=8.1.7",
-    "appdirs>=1.4.4",
-    "jsonref>=1.1.0",
-    "json-repair==0.25.2",
-    "tomli-w>=1.1.0",
-    "tomli>=2.0.2",
-    "blinker>=1.9.0",
-    "json5>=0.10.0",
-    "portalocker==2.7.0",
-    "chromadb~=1.1.0",
-    "pydantic-settings>=2.10.1",
-    "uv>=0.4.25",
-]
-
-[project.optional-dependencies]
-tools = [
-    "crewai-tools",
-]
-embeddings = [
-    "tiktoken~=0.8.0"
-]
-pdfplumber = [
-    "pdfplumber>=0.11.4",
-]
-pandas = [
-    "pandas>=2.2.3",
-]
-openpyxl = [
-    "openpyxl>=3.1.5",
-]
-mem0 = ["mem0ai>=0.1.94"]
-docling = [
-    "docling>=2.12.0",
-]
-aisuite = [
-    "aisuite>=0.1.10",
-]
-qdrant = [
-    "qdrant-client[fastembed]>=1.14.3",
-]
-aws = [
-    "boto3>=1.40.38",
-]
-watson = [
-    "ibm-watsonx-ai>=1.3.39",
-]
-voyageai = [
-    "voyageai>=0.3.5",
-]
-
-[project.scripts]
-crewai = "crewai.cli.cli:crewai"
-
-[project.urls]
-Homepage = "https://crewai.com"
-Documentation = "https://docs.crewai.com"
-Repository = "https://github.com/crewAIInc/crewAI"
-
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-asyncio_mode = "strict"
-asyncio_default_fixture_loop_scope = "function"
-
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.version]
-path = "src/crewai/__init__.py"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/crewai"]

lib/crewai/src/crewai/agents/__init__.py

@@ -1,12 +0,0 @@
-from crewai.agents.cache.cache_handler import CacheHandler
-from crewai.agents.parser import AgentAction, AgentFinish, OutputParserError, parse
-from crewai.agents.tools_handler import ToolsHandler
-
-__all__ = [
-    "AgentAction",
-    "AgentFinish",
-    "CacheHandler",
-    "OutputParserError",
-    "ToolsHandler",
-    "parse",
-]

lib/crewai/src/crewai/experimental/evaluation/experiment/__init__.py

@@ -1,7 +0,0 @@
-from crewai.experimental.evaluation.experiment.result import (
-    ExperimentResult,
-    ExperimentResults,
-)
-from crewai.experimental.evaluation.experiment.runner import ExperimentRunner
-
-__all__ = ["ExperimentResult", "ExperimentResults", "ExperimentRunner"]

lib/crewai/src/crewai/flow/__init__.py

@@ -1,4 +0,0 @@
-from crewai.flow.flow import Flow, and_, listen, or_, router, start
-from crewai.flow.persistence import persist
-
-__all__ = ["Flow", "and_", "listen", "or_", "persist", "router", "start"]

lib/crewai/src/crewai/rag/config/optional_imports/__init__.py

@@ -1 +0,0 @@
-"""Optional imports for RAG configuration providers."""

lib/crewai/src/crewai/rag/core/base_embeddings_callable.py

@@ -1,149 +0,0 @@
-"""Base embeddings callable utilities for RAG systems."""
-
-from typing import Protocol, TypeVar, runtime_checkable
-
-import numpy as np
-
-from crewai.rag.core.types import (
-    Embeddable,
-    Embedding,
-    Embeddings,
-    PyEmbedding,
-)
-
-T = TypeVar("T")
-D = TypeVar("D", bound=Embeddable, contravariant=True)
-
-
-def normalize_embeddings(
-    target: Embedding | list[Embedding] | PyEmbedding | list[PyEmbedding],
-) -> Embeddings | None:
-    """Normalize various embedding formats to a standard list of numpy arrays.
-
-    Args:
-        target: Input embeddings in various formats (list of floats, list of lists,
-                numpy array, or list of numpy arrays).
-
-    Returns:
-        Normalized embeddings as a list of numpy arrays, or None if input is None.
-
-    Raises:
-        ValueError: If embeddings are empty or in an unsupported format.
-    """
-    if isinstance(target, np.ndarray):
-        if target.ndim == 1:
-            return [target.astype(np.float32)]
-        if target.ndim == 2:
-            return [row.astype(np.float32) for row in target]
-        raise ValueError(f"Unsupported numpy array shape: {target.shape}")
-
-    first = target[0]
-    if isinstance(first, (int, float)) and not isinstance(first, bool):
-        return [np.array(target, dtype=np.float32)]
-    if isinstance(first, list):
-        return [np.array(emb, dtype=np.float32) for emb in target]
-    if isinstance(first, np.ndarray):
-        return [emb.astype(np.float32) for emb in target]  # type: ignore[union-attr]
-
-    raise ValueError(f"Unsupported embeddings format: {type(first)}")
-
-
-def maybe_cast_one_to_many(target: T | list[T] | None) -> list[T] | None:
-    """Cast a single item to a list if needed.
-
-    Args:
-        target: A single item or list of items.
-
-    Returns:
-        A list of items or None if input is None.
-    """
-    if target is None:
-        return None
-    return target if isinstance(target, list) else [target]
-
-
-def validate_embeddings(embeddings: Embeddings) -> Embeddings:
-    """Validate embeddings format and content.
-
-    Args:
-        embeddings: List of numpy arrays to validate.
-
-    Returns:
-        Validated embeddings.
-
-    Raises:
-        ValueError: If embeddings format or content is invalid.
-    """
-    if not isinstance(embeddings, list):
-        raise ValueError(
-            f"Expected embeddings to be a list, got {type(embeddings).__name__}"
-        )
-    if len(embeddings) == 0:
-        raise ValueError(
-            f"Expected embeddings to be a list with at least one item, got {len(embeddings)} embeddings"
-        )
-    if not all(isinstance(e, np.ndarray) for e in embeddings):
-        raise ValueError(
-            "Expected each embedding in the embeddings to be a numpy array"
-        )
-    for i, embedding in enumerate(embeddings):
-        if embedding.ndim == 0:
-            raise ValueError(
-                f"Expected a 1-dimensional array, got a 0-dimensional array {embedding}"
-            )
-        if embedding.size == 0:
-            raise ValueError(
-                f"Expected each embedding to be a 1-dimensional numpy array with at least 1 value. "
-                f"Got an array with no values at position {i}"
-            )
-        if not all(
-            isinstance(value, (np.integer, float, np.floating))
-            and not isinstance(value, bool)
-            for value in embedding
-        ):
-            raise ValueError(
-                f"Expected embedding to contain numeric values, got non-numeric values at position {i}"
-            )
-    return embeddings
-
-
-@runtime_checkable
-class EmbeddingFunction(Protocol[D]):
-    """Protocol for embedding functions.
-
-    Embedding functions convert input data (documents or images) into vector embeddings.
-    """
-
-    def __call__(self, input: D) -> Embeddings:
-        """Convert input data to embeddings.
-
-        Args:
-            input: Input data to embed (documents or images).
-
-        Returns:
-            List of numpy arrays representing the embeddings.
-        """
-        ...
-
-    def __init_subclass__(cls) -> None:
-        """Wrap __call__ method to normalize and validate embeddings."""
-        super().__init_subclass__()
-        original_call = cls.__call__
-
-        def wrapped_call(self: EmbeddingFunction[D], input: D) -> Embeddings:
-            result = original_call(self, input)
-            if result is None:
-                raise ValueError("Embedding function returned None")
-            normalized = normalize_embeddings(result)
-            if normalized is None:
-                raise ValueError("Normalization returned None for non-None input")
-            return validate_embeddings(normalized)
-
-        cls.__call__ = wrapped_call  # type: ignore[method-assign]
-
-    def embed_query(self, input: D) -> Embeddings:
-        """
-        Get the embeddings for a query input.
-        This method is optional, and if not implemented, the default behavior is to call __call__.
-        """
-        return self.__call__(input=input)

lib/crewai/src/crewai/rag/core/base_embeddings_provider.py

@@ -1,23 +0,0 @@
-"""Base class for embedding providers."""
-
-from typing import Generic, TypeVar
-
-from pydantic import Field
-from pydantic_settings import BaseSettings, SettingsConfigDict
-
-from crewai.rag.core.base_embeddings_callable import EmbeddingFunction
-
-T = TypeVar("T", bound=EmbeddingFunction)
-
-
-class BaseEmbeddingsProvider(BaseSettings, Generic[T]):
-    """Abstract base class for embedding providers.
-
-    This class provides a common interface for dynamically loading and building
-    embedding functions from various providers.
-    """
-
-    model_config = SettingsConfigDict(extra="allow", populate_by_name=True)
-    embedding_callable: type[T] = Field(
-        ..., description="The embedding function class to use"
-    )

lib/crewai/src/crewai/rag/core/types.py

@@ -1,28 +0,0 @@
-"""Core type definitions for RAG systems."""
-
-from collections.abc import Sequence
-from typing import TypeVar
-
-import numpy as np
-from numpy import floating, integer, number
-from numpy.typing import NDArray
-
-T = TypeVar("T")
-
-PyEmbedding = Sequence[float] | Sequence[int]
-PyEmbeddings = list[PyEmbedding]
-Embedding = NDArray[np.int32 | np.float32]
-Embeddings = list[Embedding]
-
-Documents = list[str]
-Images = list[np.ndarray]
-Embeddable = Documents | Images
-
-ScalarType = TypeVar("ScalarType", bound=np.generic)
-IntegerType = TypeVar("IntegerType", bound=integer)
-FloatingType = TypeVar("FloatingType", bound=floating)
-NumberType = TypeVar("NumberType", bound=number)
-
-DType32 = TypeVar("DType32", np.int32, np.float32)
-DType64 = TypeVar("DType64", np.int64, np.float64)
-DTypeCommon = TypeVar("DTypeCommon", np.int32, np.int64, np.float32, np.float64)

lib/crewai/src/crewai/rag/embeddings/__init__.py

@@ -1 +0,0 @@
-"""Embedding components for RAG infrastructure."""

lib/crewai/src/crewai/rag/embeddings/factory.py

@@ -1,392 +0,0 @@
-"""Factory functions for creating embedding providers and functions."""
-
-from __future__ import annotations
-
-import warnings
-from typing import TYPE_CHECKING, TypeVar, overload
-
-from typing_extensions import deprecated
-
-from crewai.rag.core.base_embeddings_callable import EmbeddingFunction
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-from crewai.utilities.import_utils import import_and_validate_definition
-
-if TYPE_CHECKING:
-    from chromadb.utils.embedding_functions.amazon_bedrock_embedding_function import (
-        AmazonBedrockEmbeddingFunction,
-    )
-    from chromadb.utils.embedding_functions.cohere_embedding_function import (
-        CohereEmbeddingFunction,
-    )
-    from chromadb.utils.embedding_functions.google_embedding_function import (
-        GoogleGenerativeAiEmbeddingFunction,
-        GoogleVertexEmbeddingFunction,
-    )
-    from chromadb.utils.embedding_functions.huggingface_embedding_function import (
-        HuggingFaceEmbeddingFunction,
-    )
-    from chromadb.utils.embedding_functions.instructor_embedding_function import (
-        InstructorEmbeddingFunction,
-    )
-    from chromadb.utils.embedding_functions.jina_embedding_function import (
-        JinaEmbeddingFunction,
-    )
-    from chromadb.utils.embedding_functions.ollama_embedding_function import (
-        OllamaEmbeddingFunction,
-    )
-    from chromadb.utils.embedding_functions.onnx_mini_lm_l6_v2 import ONNXMiniLM_L6_V2
-    from chromadb.utils.embedding_functions.open_clip_embedding_function import (
-        OpenCLIPEmbeddingFunction,
-    )
-    from chromadb.utils.embedding_functions.openai_embedding_function import (
-        OpenAIEmbeddingFunction,
-    )
-    from chromadb.utils.embedding_functions.roboflow_embedding_function import (
-        RoboflowEmbeddingFunction,
-    )
-    from chromadb.utils.embedding_functions.sentence_transformer_embedding_function import (
-        SentenceTransformerEmbeddingFunction,
-    )
-    from chromadb.utils.embedding_functions.text2vec_embedding_function import (
-        Text2VecEmbeddingFunction,
-    )
-
-    from crewai.rag.embeddings.providers.aws.types import BedrockProviderSpec
-    from crewai.rag.embeddings.providers.cohere.types import CohereProviderSpec
-    from crewai.rag.embeddings.providers.custom.types import CustomProviderSpec
-    from crewai.rag.embeddings.providers.google.types import (
-        GenerativeAiProviderSpec,
-        VertexAIProviderSpec,
-    )
-    from crewai.rag.embeddings.providers.huggingface.types import (
-        HuggingFaceProviderSpec,
-    )
-    from crewai.rag.embeddings.providers.ibm.embedding_callable import (
-        WatsonXEmbeddingFunction,
-    )
-    from crewai.rag.embeddings.providers.ibm.types import (
-        WatsonProviderSpec,
-        WatsonXProviderSpec,
-    )
-    from crewai.rag.embeddings.providers.instructor.types import InstructorProviderSpec
-    from crewai.rag.embeddings.providers.jina.types import JinaProviderSpec
-    from crewai.rag.embeddings.providers.microsoft.types import AzureProviderSpec
-    from crewai.rag.embeddings.providers.ollama.types import OllamaProviderSpec
-    from crewai.rag.embeddings.providers.onnx.types import ONNXProviderSpec
-    from crewai.rag.embeddings.providers.openai.types import OpenAIProviderSpec
-    from crewai.rag.embeddings.providers.openclip.types import OpenCLIPProviderSpec
-    from crewai.rag.embeddings.providers.roboflow.types import RoboflowProviderSpec
-    from crewai.rag.embeddings.providers.sentence_transformer.types import (
-        SentenceTransformerProviderSpec,
-    )
-    from crewai.rag.embeddings.providers.text2vec.types import Text2VecProviderSpec
-    from crewai.rag.embeddings.providers.voyageai.embedding_callable import (
-        VoyageAIEmbeddingFunction,
-    )
-    from crewai.rag.embeddings.providers.voyageai.types import VoyageAIProviderSpec
-
-T = TypeVar("T", bound=EmbeddingFunction)
-
-
-PROVIDER_PATHS = {
-    "azure": "crewai.rag.embeddings.providers.microsoft.azure.AzureProvider",
-    "amazon-bedrock": "crewai.rag.embeddings.providers.aws.bedrock.BedrockProvider",
-    "cohere": "crewai.rag.embeddings.providers.cohere.cohere_provider.CohereProvider",
-    "custom": "crewai.rag.embeddings.providers.custom.custom_provider.CustomProvider",
-    "google-generativeai": "crewai.rag.embeddings.providers.google.generative_ai.GenerativeAiProvider",
-    "google-vertex": "crewai.rag.embeddings.providers.google.vertex.VertexAIProvider",
-    "huggingface": "crewai.rag.embeddings.providers.huggingface.huggingface_provider.HuggingFaceProvider",
-    "instructor": "crewai.rag.embeddings.providers.instructor.instructor_provider.InstructorProvider",
-    "jina": "crewai.rag.embeddings.providers.jina.jina_provider.JinaProvider",
-    "ollama": "crewai.rag.embeddings.providers.ollama.ollama_provider.OllamaProvider",
-    "onnx": "crewai.rag.embeddings.providers.onnx.onnx_provider.ONNXProvider",
-    "openai": "crewai.rag.embeddings.providers.openai.openai_provider.OpenAIProvider",
-    "openclip": "crewai.rag.embeddings.providers.openclip.openclip_provider.OpenCLIPProvider",
-    "roboflow": "crewai.rag.embeddings.providers.roboflow.roboflow_provider.RoboflowProvider",
-    "sentence-transformer": "crewai.rag.embeddings.providers.sentence_transformer.sentence_transformer_provider.SentenceTransformerProvider",
-    "text2vec": "crewai.rag.embeddings.providers.text2vec.text2vec_provider.Text2VecProvider",
-    "voyageai": "crewai.rag.embeddings.providers.voyageai.voyageai_provider.VoyageAIProvider",
-    "watson": "crewai.rag.embeddings.providers.ibm.watsonx.WatsonXProvider",  # Deprecated alias
-    "watsonx": "crewai.rag.embeddings.providers.ibm.watsonx.WatsonXProvider",
-}
-
-
-def build_embedder_from_provider(provider: BaseEmbeddingsProvider[T]) -> T:
-    """Build an embedding function instance from a provider.
-
-    Args:
-        provider: The embedding provider configuration.
-
-    Returns:
-        An instance of the specified embedding function type.
-    """
-    return provider.embedding_callable(
-        **provider.model_dump(exclude={"embedding_callable"})
-    )
-
-
-@overload
-def build_embedder_from_dict(spec: AzureProviderSpec) -> OpenAIEmbeddingFunction: ...
-
-
-@overload
-def build_embedder_from_dict(
-    spec: BedrockProviderSpec,
-) -> AmazonBedrockEmbeddingFunction: ...
-
-
-@overload
-def build_embedder_from_dict(spec: CohereProviderSpec) -> CohereEmbeddingFunction: ...
-
-
-@overload
-def build_embedder_from_dict(spec: CustomProviderSpec) -> EmbeddingFunction: ...
-
-
-@overload
-def build_embedder_from_dict(
-    spec: GenerativeAiProviderSpec,
-) -> GoogleGenerativeAiEmbeddingFunction: ...
-
-
-@overload
-def build_embedder_from_dict(
-    spec: HuggingFaceProviderSpec,
-) -> HuggingFaceEmbeddingFunction: ...
-
-
-@overload
-def build_embedder_from_dict(spec: OllamaProviderSpec) -> OllamaEmbeddingFunction: ...
-
-
-@overload
-def build_embedder_from_dict(spec: OpenAIProviderSpec) -> OpenAIEmbeddingFunction: ...
-
-
-@overload
-def build_embedder_from_dict(
-    spec: VertexAIProviderSpec,
-) -> GoogleVertexEmbeddingFunction: ...
-
-
-@overload
-def build_embedder_from_dict(
-    spec: VoyageAIProviderSpec,
-) -> VoyageAIEmbeddingFunction: ...
-
-
-@overload
-def build_embedder_from_dict(spec: WatsonXProviderSpec) -> WatsonXEmbeddingFunction: ...
-
-
-@overload
-@deprecated(
-    'The "WatsonProviderSpec" provider spec is deprecated and will be removed in v1.0.0. Use "WatsonXProviderSpec" instead.'
-)
-def build_embedder_from_dict(spec: WatsonProviderSpec) -> WatsonXEmbeddingFunction: ...
-
-
-@overload
-def build_embedder_from_dict(
-    spec: SentenceTransformerProviderSpec,
-) -> SentenceTransformerEmbeddingFunction: ...
-
-
-@overload
-def build_embedder_from_dict(
-    spec: InstructorProviderSpec,
-) -> InstructorEmbeddingFunction: ...
-
-
-@overload
-def build_embedder_from_dict(spec: JinaProviderSpec) -> JinaEmbeddingFunction: ...
-
-
-@overload
-def build_embedder_from_dict(
-    spec: RoboflowProviderSpec,
-) -> RoboflowEmbeddingFunction: ...
-
-
-@overload
-def build_embedder_from_dict(
-    spec: OpenCLIPProviderSpec,
-) -> OpenCLIPEmbeddingFunction: ...
-
-
-@overload
-def build_embedder_from_dict(
-    spec: Text2VecProviderSpec,
-) -> Text2VecEmbeddingFunction: ...
-
-
-@overload
-def build_embedder_from_dict(spec: ONNXProviderSpec) -> ONNXMiniLM_L6_V2: ...
-
-
-def build_embedder_from_dict(spec):
-    """Build an embedding function instance from a dictionary specification.
-
-    Args:
-        spec: A dictionary with 'provider' and 'config' keys.
-              Example: {
-                  "provider": "openai",
-                  "config": {
-                      "api_key": "sk-...",
-                      "model_name": "text-embedding-3-small"
-                  }
-              }
-
-    Returns:
-        An instance of the appropriate embedding function.
-
-    Raises:
-        ValueError: If the provider is not recognized.
-    """
-    provider_name = spec["provider"]
-    if not provider_name:
-        raise ValueError("Missing 'provider' key in specification")
-
-    if provider_name == "watson":
-        warnings.warn(
-            'The "watson" provider key is deprecated and will be removed in v1.0.0. '
-            'Use "watsonx" instead.',
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-    if provider_name not in PROVIDER_PATHS:
-        raise ValueError(
-            f"Unknown provider: {provider_name}. Available providers: {list(PROVIDER_PATHS.keys())}"
-        )
-
-    provider_path = PROVIDER_PATHS[provider_name]
-    try:
-        provider_class = import_and_validate_definition(provider_path)
-    except (ImportError, AttributeError, ValueError) as e:
-        raise ImportError(f"Failed to import provider {provider_name}: {e}") from e
-
-    provider_config = spec.get("config", {})
-
-    if provider_name == "custom" and "embedding_callable" not in provider_config:
-        raise ValueError("Custom provider requires 'embedding_callable' in config")
-
-    provider = provider_class(**provider_config)
-    return build_embedder_from_provider(provider)
-
-
-@overload
-def build_embedder(spec: BaseEmbeddingsProvider[T]) -> T: ...
-
-
-@overload
-def build_embedder(spec: AzureProviderSpec) -> OpenAIEmbeddingFunction: ...
-
-
-@overload
-def build_embedder(spec: BedrockProviderSpec) -> AmazonBedrockEmbeddingFunction: ...
-
-
-@overload
-def build_embedder(spec: CohereProviderSpec) -> CohereEmbeddingFunction: ...
-
-
-@overload
-def build_embedder(spec: CustomProviderSpec) -> EmbeddingFunction: ...
-
-
-@overload
-def build_embedder(
-    spec: GenerativeAiProviderSpec,
-) -> GoogleGenerativeAiEmbeddingFunction: ...
-
-
-@overload
-def build_embedder(spec: HuggingFaceProviderSpec) -> HuggingFaceEmbeddingFunction: ...
-
-
-@overload
-def build_embedder(spec: OllamaProviderSpec) -> OllamaEmbeddingFunction: ...
-
-
-@overload
-def build_embedder(spec: OpenAIProviderSpec) -> OpenAIEmbeddingFunction: ...
-
-
-@overload
-def build_embedder(spec: VertexAIProviderSpec) -> GoogleVertexEmbeddingFunction: ...
-
-
-@overload
-def build_embedder(spec: VoyageAIProviderSpec) -> VoyageAIEmbeddingFunction: ...
-
-
-@overload
-def build_embedder(spec: WatsonXProviderSpec) -> WatsonXEmbeddingFunction: ...
-
-
-@overload
-@deprecated(
-    'The "WatsonProviderSpec" provider spec is deprecated and will be removed in v1.0.0. Use "WatsonXProviderSpec" instead.'
-)
-def build_embedder(spec: WatsonProviderSpec) -> WatsonXEmbeddingFunction: ...
-
-
-@overload
-def build_embedder(
-    spec: SentenceTransformerProviderSpec,
-) -> SentenceTransformerEmbeddingFunction: ...
-
-
-@overload
-def build_embedder(spec: InstructorProviderSpec) -> InstructorEmbeddingFunction: ...
-
-
-@overload
-def build_embedder(spec: JinaProviderSpec) -> JinaEmbeddingFunction: ...
-
-
-@overload
-def build_embedder(spec: RoboflowProviderSpec) -> RoboflowEmbeddingFunction: ...
-
-
-@overload
-def build_embedder(spec: OpenCLIPProviderSpec) -> OpenCLIPEmbeddingFunction: ...
-
-
-@overload
-def build_embedder(spec: Text2VecProviderSpec) -> Text2VecEmbeddingFunction: ...
-
-
-@overload
-def build_embedder(spec: ONNXProviderSpec) -> ONNXMiniLM_L6_V2: ...
-
-
-def build_embedder(spec):
-    """Build an embedding function from either a provider spec or a provider instance.
-
-    Args:
-        spec: Either a provider specification dictionary or a provider instance.
-
-    Returns:
-        An embedding function instance. If a typed provider is passed, returns
-        the specific embedding function type.
-
-    Examples:
-        # From dictionary specification
-        embedder = build_embedder({
-            "provider": "openai",
-            "config": {"api_key": "sk-..."}
-        })
-
-        # From provider instance
-        provider = OpenAIProvider(api_key="sk-...")
-        embedder = build_embedder(provider)
-    """
-    if isinstance(spec, BaseEmbeddingsProvider):
-        return build_embedder_from_provider(spec)
-    return build_embedder_from_dict(spec)
-
-
-# Backward compatibility alias
-get_embedding_function = build_embedder

lib/crewai/src/crewai/rag/embeddings/providers/__init__.py

@@ -1 +0,0 @@
-"""Embedding provider implementations."""

lib/crewai/src/crewai/rag/embeddings/providers/aws/__init__.py

@@ -1,13 +0,0 @@
-"""AWS embedding providers."""
-
-from crewai.rag.embeddings.providers.aws.bedrock import BedrockProvider
-from crewai.rag.embeddings.providers.aws.types import (
-    BedrockProviderConfig,
-    BedrockProviderSpec,
-)
-
-__all__ = [
-    "BedrockProvider",
-    "BedrockProviderConfig",
-    "BedrockProviderSpec",
-]

lib/crewai/src/crewai/rag/embeddings/providers/aws/bedrock.py

@@ -1,53 +0,0 @@
-"""Amazon Bedrock embeddings provider."""
-
-from typing import Any
-
-from chromadb.utils.embedding_functions.amazon_bedrock_embedding_function import (
-    AmazonBedrockEmbeddingFunction,
-)
-from pydantic import Field
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-
-
-def create_aws_session() -> Any:
-    """Create an AWS session for Bedrock.
-
-    Returns:
-        boto3.Session: AWS session object
-
-    Raises:
-        ImportError: If boto3 is not installed
-        ValueError: If AWS session creation fails
-    """
-    try:
-        import boto3  # type: ignore[import]
-
-        return boto3.Session()
-    except ImportError as e:
-        raise ImportError(
-            "boto3 is required for amazon-bedrock embeddings. "
-            "Install it with: uv add boto3"
-        ) from e
-    except Exception as e:
-        raise ValueError(
-            f"Failed to create AWS session for amazon-bedrock. "
-            f"Ensure AWS credentials are configured. Error: {e}"
-        ) from e
-
-
-class BedrockProvider(BaseEmbeddingsProvider[AmazonBedrockEmbeddingFunction]):
-    """Amazon Bedrock embeddings provider."""
-
-    embedding_callable: type[AmazonBedrockEmbeddingFunction] = Field(
-        default=AmazonBedrockEmbeddingFunction,
-        description="Amazon Bedrock embedding function class",
-    )
-    model_name: str = Field(
-        default="amazon.titan-embed-text-v1",
-        description="Model name to use for embeddings",
-        validation_alias="EMBEDDINGS_BEDROCK_MODEL_NAME",
-    )
-    session: Any = Field(
-        default_factory=create_aws_session, description="AWS session object"
-    )

lib/crewai/src/crewai/rag/embeddings/providers/aws/types.py

@@ -1,19 +0,0 @@
-"""Type definitions for AWS embedding providers."""
-
-from typing import Annotated, Any, Literal
-
-from typing_extensions import Required, TypedDict
-
-
-class BedrockProviderConfig(TypedDict, total=False):
-    """Configuration for Bedrock provider."""
-
-    model_name: Annotated[str, "amazon.titan-embed-text-v1"]
-    session: Any
-
-
-class BedrockProviderSpec(TypedDict, total=False):
-    """Bedrock provider specification."""
-
-    provider: Required[Literal["amazon-bedrock"]]
-    config: BedrockProviderConfig

lib/crewai/src/crewai/rag/embeddings/providers/cohere/__init__.py

@@ -1,13 +0,0 @@
-"""Cohere embedding providers."""
-
-from crewai.rag.embeddings.providers.cohere.cohere_provider import CohereProvider
-from crewai.rag.embeddings.providers.cohere.types import (
-    CohereProviderConfig,
-    CohereProviderSpec,
-)
-
-__all__ = [
-    "CohereProvider",
-    "CohereProviderConfig",
-    "CohereProviderSpec",
-]

lib/crewai/src/crewai/rag/embeddings/providers/cohere/cohere_provider.py

@@ -1,24 +0,0 @@
-"""Cohere embeddings provider."""
-
-from chromadb.utils.embedding_functions.cohere_embedding_function import (
-    CohereEmbeddingFunction,
-)
-from pydantic import Field
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-
-
-class CohereProvider(BaseEmbeddingsProvider[CohereEmbeddingFunction]):
-    """Cohere embeddings provider."""
-
-    embedding_callable: type[CohereEmbeddingFunction] = Field(
-        default=CohereEmbeddingFunction, description="Cohere embedding function class"
-    )
-    api_key: str = Field(
-        description="Cohere API key", validation_alias="EMBEDDINGS_COHERE_API_KEY"
-    )
-    model_name: str = Field(
-        default="large",
-        description="Model name to use for embeddings",
-        validation_alias="EMBEDDINGS_COHERE_MODEL_NAME",
-    )

lib/crewai/src/crewai/rag/embeddings/providers/cohere/types.py

@@ -1,19 +0,0 @@
-"""Type definitions for Cohere embedding providers."""
-
-from typing import Annotated, Literal
-
-from typing_extensions import Required, TypedDict
-
-
-class CohereProviderConfig(TypedDict, total=False):
-    """Configuration for Cohere provider."""
-
-    api_key: str
-    model_name: Annotated[str, "large"]
-
-
-class CohereProviderSpec(TypedDict, total=False):
-    """Cohere provider specification."""
-
-    provider: Required[Literal["cohere"]]
-    config: CohereProviderConfig

lib/crewai/src/crewai/rag/embeddings/providers/custom/__init__.py

@@ -1,13 +0,0 @@
-"""Custom embedding providers."""
-
-from crewai.rag.embeddings.providers.custom.custom_provider import CustomProvider
-from crewai.rag.embeddings.providers.custom.types import (
-    CustomProviderConfig,
-    CustomProviderSpec,
-)
-
-__all__ = [
-    "CustomProvider",
-    "CustomProviderConfig",
-    "CustomProviderSpec",
-]

lib/crewai/src/crewai/rag/embeddings/providers/custom/custom_provider.py

@@ -1,19 +0,0 @@
-"""Custom embeddings provider for user-defined embedding functions."""
-
-from pydantic import Field
-from pydantic_settings import SettingsConfigDict
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-from crewai.rag.embeddings.providers.custom.embedding_callable import (
-    CustomEmbeddingFunction,
-)
-
-
-class CustomProvider(BaseEmbeddingsProvider[CustomEmbeddingFunction]):
-    """Custom embeddings provider for user-defined embedding functions."""
-
-    embedding_callable: type[CustomEmbeddingFunction] = Field(
-        ..., description="Custom embedding function class"
-    )
-
-    model_config = SettingsConfigDict(extra="allow")

lib/crewai/src/crewai/rag/embeddings/providers/custom/embedding_callable.py

@@ -1,22 +0,0 @@
-"""Custom embedding function base implementation."""
-
-from crewai.rag.core.base_embeddings_callable import EmbeddingFunction
-from crewai.rag.core.types import Documents, Embeddings
-
-
-class CustomEmbeddingFunction(EmbeddingFunction[Documents]):
-    """Base class for custom embedding functions.
-
-    This provides a concrete implementation that can be subclassed for custom embeddings.
-    """
-
-    def __call__(self, input: Documents) -> Embeddings:
-        """Convert input documents to embeddings.
-
-        Args:
-            input: List of documents to embed.
-
-        Returns:
-            List of numpy arrays representing the embeddings.
-        """
-        raise NotImplementedError("Subclasses must implement __call__ method")

lib/crewai/src/crewai/rag/embeddings/providers/custom/types.py

@@ -1,19 +0,0 @@
-"""Type definitions for custom embedding providers."""
-
-from typing import Literal
-
-from chromadb.api.types import EmbeddingFunction
-from typing_extensions import Required, TypedDict
-
-
-class CustomProviderConfig(TypedDict, total=False):
-    """Configuration for Custom provider."""
-
-    embedding_callable: type[EmbeddingFunction]
-
-
-class CustomProviderSpec(TypedDict, total=False):
-    """Custom provider specification."""
-
-    provider: Required[Literal["custom"]]
-    config: CustomProviderConfig

lib/crewai/src/crewai/rag/embeddings/providers/google/__init__.py

@@ -1,23 +0,0 @@
-"""Google embedding providers."""
-
-from crewai.rag.embeddings.providers.google.generative_ai import (
-    GenerativeAiProvider,
-)
-from crewai.rag.embeddings.providers.google.types import (
-    GenerativeAiProviderConfig,
-    GenerativeAiProviderSpec,
-    VertexAIProviderConfig,
-    VertexAIProviderSpec,
-)
-from crewai.rag.embeddings.providers.google.vertex import (
-    VertexAIProvider,
-)
-
-__all__ = [
-    "GenerativeAiProvider",
-    "GenerativeAiProviderConfig",
-    "GenerativeAiProviderSpec",
-    "VertexAIProvider",
-    "VertexAIProviderConfig",
-    "VertexAIProviderSpec",
-]

lib/crewai/src/crewai/rag/embeddings/providers/google/generative_ai.py

@@ -1,30 +0,0 @@
-"""Google Generative AI embeddings provider."""
-
-from chromadb.utils.embedding_functions.google_embedding_function import (
-    GoogleGenerativeAiEmbeddingFunction,
-)
-from pydantic import Field
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-
-
-class GenerativeAiProvider(BaseEmbeddingsProvider[GoogleGenerativeAiEmbeddingFunction]):
-    """Google Generative AI embeddings provider."""
-
-    embedding_callable: type[GoogleGenerativeAiEmbeddingFunction] = Field(
-        default=GoogleGenerativeAiEmbeddingFunction,
-        description="Google Generative AI embedding function class",
-    )
-    model_name: str = Field(
-        default="models/embedding-001",
-        description="Model name to use for embeddings",
-        validation_alias="EMBEDDINGS_GOOGLE_GENERATIVE_AI_MODEL_NAME",
-    )
-    api_key: str = Field(
-        description="Google API key", validation_alias="EMBEDDINGS_GOOGLE_API_KEY"
-    )
-    task_type: str = Field(
-        default="RETRIEVAL_DOCUMENT",
-        description="Task type for embeddings",
-        validation_alias="EMBEDDINGS_GOOGLE_GENERATIVE_AI_TASK_TYPE",
-    )

lib/crewai/src/crewai/rag/embeddings/providers/google/types.py

@@ -1,36 +0,0 @@
-"""Type definitions for Google embedding providers."""
-
-from typing import Annotated, Literal
-
-from typing_extensions import Required, TypedDict
-
-
-class GenerativeAiProviderConfig(TypedDict, total=False):
-    """Configuration for Google Generative AI provider."""
-
-    api_key: str
-    model_name: Annotated[str, "models/embedding-001"]
-    task_type: Annotated[str, "RETRIEVAL_DOCUMENT"]
-
-
-class GenerativeAiProviderSpec(TypedDict):
-    """Google Generative AI provider specification."""
-
-    provider: Literal["google-generativeai"]
-    config: GenerativeAiProviderConfig
-
-
-class VertexAIProviderConfig(TypedDict, total=False):
-    """Configuration for Vertex AI provider."""
-
-    api_key: str
-    model_name: Annotated[str, "textembedding-gecko"]
-    project_id: Annotated[str, "cloud-large-language-models"]
-    region: Annotated[str, "us-central1"]
-
-
-class VertexAIProviderSpec(TypedDict, total=False):
-    """Vertex AI provider specification."""
-
-    provider: Required[Literal["google-vertex"]]
-    config: VertexAIProviderConfig

lib/crewai/src/crewai/rag/embeddings/providers/google/vertex.py

@@ -1,35 +0,0 @@
-"""Google Vertex AI embeddings provider."""
-
-from chromadb.utils.embedding_functions.google_embedding_function import (
-    GoogleVertexEmbeddingFunction,
-)
-from pydantic import Field
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-
-
-class VertexAIProvider(BaseEmbeddingsProvider[GoogleVertexEmbeddingFunction]):
-    """Google Vertex AI embeddings provider."""
-
-    embedding_callable: type[GoogleVertexEmbeddingFunction] = Field(
-        default=GoogleVertexEmbeddingFunction,
-        description="Vertex AI embedding function class",
-    )
-    model_name: str = Field(
-        default="textembedding-gecko",
-        description="Model name to use for embeddings",
-        validation_alias="EMBEDDINGS_GOOGLE_VERTEX_MODEL_NAME",
-    )
-    api_key: str = Field(
-        description="Google API key", validation_alias="EMBEDDINGS_GOOGLE_CLOUD_API_KEY"
-    )
-    project_id: str = Field(
-        default="cloud-large-language-models",
-        description="GCP project ID",
-        validation_alias="EMBEDDINGS_GOOGLE_CLOUD_PROJECT",
-    )
-    region: str = Field(
-        default="us-central1",
-        description="GCP region",
-        validation_alias="EMBEDDINGS_GOOGLE_CLOUD_REGION",
-    )

lib/crewai/src/crewai/rag/embeddings/providers/huggingface/__init__.py

@@ -1,15 +0,0 @@
-"""HuggingFace embedding providers."""
-
-from crewai.rag.embeddings.providers.huggingface.huggingface_provider import (
-    HuggingFaceProvider,
-)
-from crewai.rag.embeddings.providers.huggingface.types import (
-    HuggingFaceProviderConfig,
-    HuggingFaceProviderSpec,
-)
-
-__all__ = [
-    "HuggingFaceProvider",
-    "HuggingFaceProviderConfig",
-    "HuggingFaceProviderSpec",
-]

lib/crewai/src/crewai/rag/embeddings/providers/huggingface/huggingface_provider.py

@@ -1,20 +0,0 @@
-"""HuggingFace embeddings provider."""
-
-from chromadb.utils.embedding_functions.huggingface_embedding_function import (
-    HuggingFaceEmbeddingServer,
-)
-from pydantic import Field
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-
-
-class HuggingFaceProvider(BaseEmbeddingsProvider[HuggingFaceEmbeddingServer]):
-    """HuggingFace embeddings provider."""
-
-    embedding_callable: type[HuggingFaceEmbeddingServer] = Field(
-        default=HuggingFaceEmbeddingServer,
-        description="HuggingFace embedding function class",
-    )
-    url: str = Field(
-        description="HuggingFace API URL", validation_alias="EMBEDDINGS_HUGGINGFACE_URL"
-    )

lib/crewai/src/crewai/rag/embeddings/providers/huggingface/types.py

@@ -1,18 +0,0 @@
-"""Type definitions for HuggingFace embedding providers."""
-
-from typing import Literal
-
-from typing_extensions import Required, TypedDict
-
-
-class HuggingFaceProviderConfig(TypedDict, total=False):
-    """Configuration for HuggingFace provider."""
-
-    url: str
-
-
-class HuggingFaceProviderSpec(TypedDict, total=False):
-    """HuggingFace provider specification."""
-
-    provider: Required[Literal["huggingface"]]
-    config: HuggingFaceProviderConfig

lib/crewai/src/crewai/rag/embeddings/providers/ibm/__init__.py

@@ -1,17 +0,0 @@
-"""IBM embedding providers."""
-
-from crewai.rag.embeddings.providers.ibm.types import (
-    WatsonProviderSpec,
-    WatsonXProviderConfig,
-    WatsonXProviderSpec,
-)
-from crewai.rag.embeddings.providers.ibm.watsonx import (
-    WatsonXProvider,
-)
-
-__all__ = [
-    "WatsonProviderSpec",
-    "WatsonXProvider",
-    "WatsonXProviderConfig",
-    "WatsonXProviderSpec",
-]

lib/crewai/src/crewai/rag/embeddings/providers/ibm/embedding_callable.py

@@ -1,159 +0,0 @@
-"""IBM WatsonX embedding function implementation."""
-
-from typing import cast
-
-from chromadb.api.types import Documents, EmbeddingFunction, Embeddings
-from typing_extensions import Unpack
-
-from crewai.rag.embeddings.providers.ibm.types import WatsonXProviderConfig
-
-
-class WatsonXEmbeddingFunction(EmbeddingFunction[Documents]):
-    """Embedding function for IBM WatsonX models."""
-
-    def __init__(self, **kwargs: Unpack[WatsonXProviderConfig]) -> None:
-        """Initialize WatsonX embedding function.
-
-        Args:
-            **kwargs: Configuration parameters for WatsonX Embeddings and Credentials.
-        """
-        super().__init__(**kwargs)
-        self._config = kwargs
-
-    @staticmethod
-    def name() -> str:
-        """Return the name of the embedding function for ChromaDB compatibility."""
-        return "watsonx"
-
-    def __call__(self, input: Documents) -> Embeddings:
-        """Generate embeddings for input documents.
-
-        Args:
-            input: List of documents to embed.
-
-        Returns:
-            List of embedding vectors.
-        """
-        try:
-            import ibm_watsonx_ai.foundation_models as watson_models  # type: ignore[import-not-found, import-untyped]
-            from ibm_watsonx_ai import (
-                Credentials,  # type: ignore[import-not-found, import-untyped]
-            )
-            from ibm_watsonx_ai.metanames import (  # type: ignore[import-not-found, import-untyped]
-                EmbedTextParamsMetaNames as EmbedParams,
-            )
-
-        except ImportError as e:
-            raise ImportError(
-                "ibm-watsonx-ai is required for watsonx embeddings. "
-                "Install it with: uv add ibm-watsonx-ai"
-            ) from e
-
-        if isinstance(input, str):
-            input = [input]
-
-        embeddings_config: dict = {
-            "model_id": self._config["model_id"],
-        }
-        if "params" in self._config and self._config["params"] is not None:
-            embeddings_config["params"] = self._config["params"]
-        if "project_id" in self._config and self._config["project_id"] is not None:
-            embeddings_config["project_id"] = self._config["project_id"]
-        if "space_id" in self._config and self._config["space_id"] is not None:
-            embeddings_config["space_id"] = self._config["space_id"]
-        if "api_client" in self._config and self._config["api_client"] is not None:
-            embeddings_config["api_client"] = self._config["api_client"]
-        if "verify" in self._config and self._config["verify"] is not None:
-            embeddings_config["verify"] = self._config["verify"]
-        if "persistent_connection" in self._config:
-            embeddings_config["persistent_connection"] = self._config[
-                "persistent_connection"
-            ]
-        if "batch_size" in self._config:
-            embeddings_config["batch_size"] = self._config["batch_size"]
-        if "concurrency_limit" in self._config:
-            embeddings_config["concurrency_limit"] = self._config["concurrency_limit"]
-        if "max_retries" in self._config and self._config["max_retries"] is not None:
-            embeddings_config["max_retries"] = self._config["max_retries"]
-        if "delay_time" in self._config and self._config["delay_time"] is not None:
-            embeddings_config["delay_time"] = self._config["delay_time"]
-        if (
-            "retry_status_codes" in self._config
-            and self._config["retry_status_codes"] is not None
-        ):
-            embeddings_config["retry_status_codes"] = self._config["retry_status_codes"]
-
-        if "credentials" in self._config and self._config["credentials"] is not None:
-            embeddings_config["credentials"] = self._config["credentials"]
-        else:
-            cred_config: dict = {}
-            if "url" in self._config and self._config["url"] is not None:
-                cred_config["url"] = self._config["url"]
-            if "api_key" in self._config and self._config["api_key"] is not None:
-                cred_config["api_key"] = self._config["api_key"]
-            if "name" in self._config and self._config["name"] is not None:
-                cred_config["name"] = self._config["name"]
-            if (
-                "iam_serviceid_crn" in self._config
-                and self._config["iam_serviceid_crn"] is not None
-            ):
-                cred_config["iam_serviceid_crn"] = self._config["iam_serviceid_crn"]
-            if (
-                "trusted_profile_id" in self._config
-                and self._config["trusted_profile_id"] is not None
-            ):
-                cred_config["trusted_profile_id"] = self._config["trusted_profile_id"]
-            if "token" in self._config and self._config["token"] is not None:
-                cred_config["token"] = self._config["token"]
-            if (
-                "projects_token" in self._config
-                and self._config["projects_token"] is not None
-            ):
-                cred_config["projects_token"] = self._config["projects_token"]
-            if "username" in self._config and self._config["username"] is not None:
-                cred_config["username"] = self._config["username"]
-            if "password" in self._config and self._config["password"] is not None:
-                cred_config["password"] = self._config["password"]
-            if (
-                "instance_id" in self._config
-                and self._config["instance_id"] is not None
-            ):
-                cred_config["instance_id"] = self._config["instance_id"]
-            if "version" in self._config and self._config["version"] is not None:
-                cred_config["version"] = self._config["version"]
-            if (
-                "bedrock_url" in self._config
-                and self._config["bedrock_url"] is not None
-            ):
-                cred_config["bedrock_url"] = self._config["bedrock_url"]
-            if (
-                "platform_url" in self._config
-                and self._config["platform_url"] is not None
-            ):
-                cred_config["platform_url"] = self._config["platform_url"]
-            if "proxies" in self._config and self._config["proxies"] is not None:
-                cred_config["proxies"] = self._config["proxies"]
-            if (
-                "verify" not in embeddings_config
-                and "verify" in self._config
-                and self._config["verify"] is not None
-            ):
-                cred_config["verify"] = self._config["verify"]
-
-            if cred_config:
-                embeddings_config["credentials"] = Credentials(**cred_config)
-
-        if "params" not in embeddings_config:
-            embeddings_config["params"] = {
-                EmbedParams.TRUNCATE_INPUT_TOKENS: 3,
-                EmbedParams.RETURN_OPTIONS: {"input_text": True},
-            }
-
-        embedding = watson_models.Embeddings(**embeddings_config)
-
-        try:
-            embeddings = embedding.embed_documents(input)
-            return cast(Embeddings, embeddings)
-        except Exception as e:
-            print(f"Error during WatsonX embedding: {e}")
-            raise

lib/crewai/src/crewai/rag/embeddings/providers/ibm/types.py

@@ -1,58 +0,0 @@
-"""Type definitions for IBM WatsonX embedding providers."""
-
-from typing import Annotated, Any, Literal
-
-from typing_extensions import Required, TypedDict, deprecated
-
-
-class WatsonXProviderConfig(TypedDict, total=False):
-    """Configuration for WatsonX provider."""
-
-    model_id: str
-    url: str
-    params: dict[str, str | dict[str, str]]
-    credentials: Any
-    project_id: str
-    space_id: str
-    api_client: Any
-    verify: bool | str
-    persistent_connection: Annotated[bool, True]
-    batch_size: Annotated[int, 100]
-    concurrency_limit: Annotated[int, 10]
-    max_retries: int
-    delay_time: float
-    retry_status_codes: list[int]
-    api_key: str
-    name: str
-    iam_serviceid_crn: str
-    trusted_profile_id: str
-    token: str
-    projects_token: str
-    username: str
-    password: str
-    instance_id: str
-    version: str
-    bedrock_url: str
-    platform_url: str
-    proxies: dict
-
-
-class WatsonXProviderSpec(TypedDict, total=False):
-    """WatsonX provider specification."""
-
-    provider: Required[Literal["watsonx"]]
-    config: WatsonXProviderConfig
-
-
-@deprecated(
-    'The "WatsonProviderSpec" provider spec is deprecated and will be removed in v1.0.0. Use "WatsonXProviderSpec" instead.'
-)
-class WatsonProviderSpec(TypedDict, total=False):
-    """Watson provider specification (deprecated).
-
-    Notes:
-        - This is deprecated. Use WatsonXProviderSpec with provider="watsonx" instead.
-    """
-
-    provider: Required[Literal["watson"]]
-    config: WatsonXProviderConfig

lib/crewai/src/crewai/rag/embeddings/providers/ibm/watsonx.py

@@ -1,142 +0,0 @@
-"""IBM WatsonX embeddings provider."""
-
-from typing import Any
-
-from pydantic import Field, model_validator
-from typing_extensions import Self
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-from crewai.rag.embeddings.providers.ibm.embedding_callable import (
-    WatsonXEmbeddingFunction,
-)
-
-
-class WatsonXProvider(BaseEmbeddingsProvider[WatsonXEmbeddingFunction]):
-    """IBM WatsonX embeddings provider.
-
-    Note: Requires custom implementation as WatsonX uses a different interface.
-    """
-
-    embedding_callable: type[WatsonXEmbeddingFunction] = Field(
-        default=WatsonXEmbeddingFunction, description="WatsonX embedding function class"
-    )
-    model_id: str = Field(
-        description="WatsonX model ID", validation_alias="EMBEDDINGS_WATSONX_MODEL_ID"
-    )
-    params: dict[str, str | dict[str, str]] | None = Field(
-        default=None, description="Additional parameters"
-    )
-    credentials: Any | None = Field(default=None, description="WatsonX credentials")
-    project_id: str | None = Field(
-        default=None,
-        description="WatsonX project ID",
-        validation_alias="EMBEDDINGS_WATSONX_PROJECT_ID",
-    )
-    space_id: str | None = Field(
-        default=None,
-        description="WatsonX space ID",
-        validation_alias="EMBEDDINGS_WATSONX_SPACE_ID",
-    )
-    api_client: Any | None = Field(default=None, description="WatsonX API client")
-    verify: bool | str | None = Field(
-        default=None,
-        description="SSL verification",
-        validation_alias="EMBEDDINGS_WATSONX_VERIFY",
-    )
-    persistent_connection: bool = Field(
-        default=True,
-        description="Use persistent connection",
-        validation_alias="EMBEDDINGS_WATSONX_PERSISTENT_CONNECTION",
-    )
-    batch_size: int = Field(
-        default=100,
-        description="Batch size for processing",
-        validation_alias="EMBEDDINGS_WATSONX_BATCH_SIZE",
-    )
-    concurrency_limit: int = Field(
-        default=10,
-        description="Concurrency limit",
-        validation_alias="EMBEDDINGS_WATSONX_CONCURRENCY_LIMIT",
-    )
-    max_retries: int | None = Field(
-        default=None,
-        description="Maximum retries",
-        validation_alias="EMBEDDINGS_WATSONX_MAX_RETRIES",
-    )
-    delay_time: float | None = Field(
-        default=None,
-        description="Delay time between retries",
-        validation_alias="EMBEDDINGS_WATSONX_DELAY_TIME",
-    )
-    retry_status_codes: list[int] | None = Field(
-        default=None, description="HTTP status codes to retry on"
-    )
-    url: str = Field(
-        description="WatsonX API URL", validation_alias="EMBEDDINGS_WATSONX_URL"
-    )
-    api_key: str = Field(
-        description="WatsonX API key", validation_alias="EMBEDDINGS_WATSONX_API_KEY"
-    )
-    name: str | None = Field(
-        default=None,
-        description="Service name",
-        validation_alias="EMBEDDINGS_WATSONX_NAME",
-    )
-    iam_serviceid_crn: str | None = Field(
-        default=None,
-        description="IAM service ID CRN",
-        validation_alias="EMBEDDINGS_WATSONX_IAM_SERVICEID_CRN",
-    )
-    trusted_profile_id: str | None = Field(
-        default=None,
-        description="Trusted profile ID",
-        validation_alias="EMBEDDINGS_WATSONX_TRUSTED_PROFILE_ID",
-    )
-    token: str | None = Field(
-        default=None,
-        description="Bearer token",
-        validation_alias="EMBEDDINGS_WATSONX_TOKEN",
-    )
-    projects_token: str | None = Field(
-        default=None,
-        description="Projects token",
-        validation_alias="EMBEDDINGS_WATSONX_PROJECTS_TOKEN",
-    )
-    username: str | None = Field(
-        default=None,
-        description="Username",
-        validation_alias="EMBEDDINGS_WATSONX_USERNAME",
-    )
-    password: str | None = Field(
-        default=None,
-        description="Password",
-        validation_alias="EMBEDDINGS_WATSONX_PASSWORD",
-    )
-    instance_id: str | None = Field(
-        default=None,
-        description="Service instance ID",
-        validation_alias="EMBEDDINGS_WATSONX_INSTANCE_ID",
-    )
-    version: str | None = Field(
-        default=None,
-        description="API version",
-        validation_alias="EMBEDDINGS_WATSONX_VERSION",
-    )
-    bedrock_url: str | None = Field(
-        default=None,
-        description="Bedrock URL",
-        validation_alias="EMBEDDINGS_WATSONX_BEDROCK_URL",
-    )
-    platform_url: str | None = Field(
-        default=None,
-        description="Platform URL",
-        validation_alias="EMBEDDINGS_WATSONX_PLATFORM_URL",
-    )
-    proxies: dict | None = Field(default=None, description="Proxy configuration")
-
-    @model_validator(mode="after")
-    def validate_space_or_project(self) -> Self:
-        """Validate that either space_id or project_id is provided."""
-        if not self.space_id and not self.project_id:
-            raise ValueError("One of 'space_id' or 'project_id' must be provided")
-        return self

lib/crewai/src/crewai/rag/embeddings/providers/instructor/__init__.py

@@ -1,15 +0,0 @@
-"""Instructor embedding providers."""
-
-from crewai.rag.embeddings.providers.instructor.instructor_provider import (
-    InstructorProvider,
-)
-from crewai.rag.embeddings.providers.instructor.types import (
-    InstructorProviderConfig,
-    InstructorProviderSpec,
-)
-
-__all__ = [
-    "InstructorProvider",
-    "InstructorProviderConfig",
-    "InstructorProviderSpec",
-]

lib/crewai/src/crewai/rag/embeddings/providers/instructor/instructor_provider.py

@@ -1,32 +0,0 @@
-"""Instructor embeddings provider."""
-
-from chromadb.utils.embedding_functions.instructor_embedding_function import (
-    InstructorEmbeddingFunction,
-)
-from pydantic import Field
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-
-
-class InstructorProvider(BaseEmbeddingsProvider[InstructorEmbeddingFunction]):
-    """Instructor embeddings provider."""
-
-    embedding_callable: type[InstructorEmbeddingFunction] = Field(
-        default=InstructorEmbeddingFunction,
-        description="Instructor embedding function class",
-    )
-    model_name: str = Field(
-        default="hkunlp/instructor-base",
-        description="Model name to use",
-        validation_alias="EMBEDDINGS_INSTRUCTOR_MODEL_NAME",
-    )
-    device: str = Field(
-        default="cpu",
-        description="Device to run model on (cpu or cuda)",
-        validation_alias="EMBEDDINGS_INSTRUCTOR_DEVICE",
-    )
-    instruction: str | None = Field(
-        default=None,
-        description="Instruction for embeddings",
-        validation_alias="EMBEDDINGS_INSTRUCTOR_INSTRUCTION",
-    )

lib/crewai/src/crewai/rag/embeddings/providers/instructor/types.py

@@ -1,20 +0,0 @@
-"""Type definitions for Instructor embedding providers."""
-
-from typing import Annotated, Literal
-
-from typing_extensions import Required, TypedDict
-
-
-class InstructorProviderConfig(TypedDict, total=False):
-    """Configuration for Instructor provider."""
-
-    model_name: Annotated[str, "hkunlp/instructor-base"]
-    device: Annotated[str, "cpu"]
-    instruction: str
-
-
-class InstructorProviderSpec(TypedDict, total=False):
-    """Instructor provider specification."""
-
-    provider: Required[Literal["instructor"]]
-    config: InstructorProviderConfig

lib/crewai/src/crewai/rag/embeddings/providers/jina/__init__.py

@@ -1,13 +0,0 @@
-"""Jina embedding providers."""
-
-from crewai.rag.embeddings.providers.jina.jina_provider import JinaProvider
-from crewai.rag.embeddings.providers.jina.types import (
-    JinaProviderConfig,
-    JinaProviderSpec,
-)
-
-__all__ = [
-    "JinaProvider",
-    "JinaProviderConfig",
-    "JinaProviderSpec",
-]

lib/crewai/src/crewai/rag/embeddings/providers/jina/jina_provider.py

@@ -1,24 +0,0 @@
-"""Jina embeddings provider."""
-
-from chromadb.utils.embedding_functions.jina_embedding_function import (
-    JinaEmbeddingFunction,
-)
-from pydantic import Field
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-
-
-class JinaProvider(BaseEmbeddingsProvider[JinaEmbeddingFunction]):
-    """Jina embeddings provider."""
-
-    embedding_callable: type[JinaEmbeddingFunction] = Field(
-        default=JinaEmbeddingFunction, description="Jina embedding function class"
-    )
-    api_key: str = Field(
-        description="Jina API key", validation_alias="EMBEDDINGS_JINA_API_KEY"
-    )
-    model_name: str = Field(
-        default="jina-embeddings-v2-base-en",
-        description="Model name to use for embeddings",
-        validation_alias="EMBEDDINGS_JINA_MODEL_NAME",
-    )

lib/crewai/src/crewai/rag/embeddings/providers/jina/types.py

@@ -1,19 +0,0 @@
-"""Type definitions for Jina embedding providers."""
-
-from typing import Annotated, Literal
-
-from typing_extensions import Required, TypedDict
-
-
-class JinaProviderConfig(TypedDict, total=False):
-    """Configuration for Jina provider."""
-
-    api_key: str
-    model_name: Annotated[str, "jina-embeddings-v2-base-en"]
-
-
-class JinaProviderSpec(TypedDict, total=False):
-    """Jina provider specification."""
-
-    provider: Required[Literal["jina"]]
-    config: JinaProviderConfig

lib/crewai/src/crewai/rag/embeddings/providers/microsoft/__init__.py

@@ -1,15 +0,0 @@
-"""Microsoft embedding providers."""
-
-from crewai.rag.embeddings.providers.microsoft.azure import (
-    AzureProvider,
-)
-from crewai.rag.embeddings.providers.microsoft.types import (
-    AzureProviderConfig,
-    AzureProviderSpec,
-)
-
-__all__ = [
-    "AzureProvider",
-    "AzureProviderConfig",
-    "AzureProviderSpec",
-]

lib/crewai/src/crewai/rag/embeddings/providers/microsoft/azure.py

@@ -1,60 +0,0 @@
-"""Azure OpenAI embeddings provider."""
-
-from typing import Any
-
-from chromadb.utils.embedding_functions.openai_embedding_function import (
-    OpenAIEmbeddingFunction,
-)
-from pydantic import Field
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-
-
-class AzureProvider(BaseEmbeddingsProvider[OpenAIEmbeddingFunction]):
-    """Azure OpenAI embeddings provider."""
-
-    embedding_callable: type[OpenAIEmbeddingFunction] = Field(
-        default=OpenAIEmbeddingFunction,
-        description="Azure OpenAI embedding function class",
-    )
-    api_key: str = Field(
-        description="Azure API key", validation_alias="EMBEDDINGS_OPENAI_API_KEY"
-    )
-    api_base: str | None = Field(
-        default=None,
-        description="Azure endpoint URL",
-        validation_alias="EMBEDDINGS_OPENAI_API_BASE",
-    )
-    api_type: str = Field(
-        default="azure",
-        description="API type for Azure",
-        validation_alias="EMBEDDINGS_OPENAI_API_TYPE",
-    )
-    api_version: str | None = Field(
-        default=None,
-        description="Azure API version",
-        validation_alias="EMBEDDINGS_OPENAI_API_VERSION",
-    )
-    model_name: str = Field(
-        default="text-embedding-ada-002",
-        description="Model name to use for embeddings",
-        validation_alias="EMBEDDINGS_OPENAI_MODEL_NAME",
-    )
-    default_headers: dict[str, Any] | None = Field(
-        default=None, description="Default headers for API requests"
-    )
-    dimensions: int | None = Field(
-        default=None,
-        description="Embedding dimensions",
-        validation_alias="EMBEDDINGS_OPENAI_DIMENSIONS",
-    )
-    deployment_id: str | None = Field(
-        default=None,
-        description="Azure deployment ID",
-        validation_alias="EMBEDDINGS_OPENAI_DEPLOYMENT_ID",
-    )
-    organization_id: str | None = Field(
-        default=None,
-        description="Organization ID",
-        validation_alias="EMBEDDINGS_OPENAI_ORGANIZATION_ID",
-    )

lib/crewai/src/crewai/rag/embeddings/providers/microsoft/types.py

@@ -1,26 +0,0 @@
-"""Type definitions for Microsoft Azure embedding providers."""
-
-from typing import Annotated, Any, Literal
-
-from typing_extensions import Required, TypedDict
-
-
-class AzureProviderConfig(TypedDict, total=False):
-    """Configuration for Azure provider."""
-
-    api_key: str
-    api_base: str
-    api_type: Annotated[str, "azure"]
-    api_version: str
-    model_name: Annotated[str, "text-embedding-ada-002"]
-    default_headers: dict[str, Any]
-    dimensions: int
-    deployment_id: str
-    organization_id: str
-
-
-class AzureProviderSpec(TypedDict, total=False):
-    """Azure provider specification."""
-
-    provider: Required[Literal["azure"]]
-    config: AzureProviderConfig

lib/crewai/src/crewai/rag/embeddings/providers/ollama/__init__.py

@@ -1,15 +0,0 @@
-"""Ollama embedding providers."""
-
-from crewai.rag.embeddings.providers.ollama.ollama_provider import (
-    OllamaProvider,
-)
-from crewai.rag.embeddings.providers.ollama.types import (
-    OllamaProviderConfig,
-    OllamaProviderSpec,
-)
-
-__all__ = [
-    "OllamaProvider",
-    "OllamaProviderConfig",
-    "OllamaProviderSpec",
-]

lib/crewai/src/crewai/rag/embeddings/providers/ollama/ollama_provider.py

@@ -1,25 +0,0 @@
-"""Ollama embeddings provider."""
-
-from chromadb.utils.embedding_functions.ollama_embedding_function import (
-    OllamaEmbeddingFunction,
-)
-from pydantic import Field
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-
-
-class OllamaProvider(BaseEmbeddingsProvider[OllamaEmbeddingFunction]):
-    """Ollama embeddings provider."""
-
-    embedding_callable: type[OllamaEmbeddingFunction] = Field(
-        default=OllamaEmbeddingFunction, description="Ollama embedding function class"
-    )
-    url: str = Field(
-        default="http://localhost:11434/api/embeddings",
-        description="Ollama API endpoint URL",
-        validation_alias="EMBEDDINGS_OLLAMA_URL",
-    )
-    model_name: str = Field(
-        description="Model name to use for embeddings",
-        validation_alias="EMBEDDINGS_OLLAMA_MODEL_NAME",
-    )

lib/crewai/src/crewai/rag/embeddings/providers/ollama/types.py

@@ -1,19 +0,0 @@
-"""Type definitions for Ollama embedding providers."""
-
-from typing import Annotated, Literal
-
-from typing_extensions import Required, TypedDict
-
-
-class OllamaProviderConfig(TypedDict, total=False):
-    """Configuration for Ollama provider."""
-
-    url: Annotated[str, "http://localhost:11434/api/embeddings"]
-    model_name: str
-
-
-class OllamaProviderSpec(TypedDict, total=False):
-    """Ollama provider specification."""
-
-    provider: Required[Literal["ollama"]]
-    config: OllamaProviderConfig

lib/crewai/src/crewai/rag/embeddings/providers/onnx/__init__.py

@@ -1,13 +0,0 @@
-"""ONNX embedding providers."""
-
-from crewai.rag.embeddings.providers.onnx.onnx_provider import ONNXProvider
-from crewai.rag.embeddings.providers.onnx.types import (
-    ONNXProviderConfig,
-    ONNXProviderSpec,
-)
-
-__all__ = [
-    "ONNXProvider",
-    "ONNXProviderConfig",
-    "ONNXProviderSpec",
-]

lib/crewai/src/crewai/rag/embeddings/providers/onnx/onnx_provider.py

@@ -1,19 +0,0 @@
-"""ONNX embeddings provider."""
-
-from chromadb.utils.embedding_functions.onnx_mini_lm_l6_v2 import ONNXMiniLM_L6_V2
-from pydantic import Field
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-
-
-class ONNXProvider(BaseEmbeddingsProvider[ONNXMiniLM_L6_V2]):
-    """ONNX embeddings provider."""
-
-    embedding_callable: type[ONNXMiniLM_L6_V2] = Field(
-        default=ONNXMiniLM_L6_V2, description="ONNX MiniLM embedding function class"
-    )
-    preferred_providers: list[str] | None = Field(
-        default=None,
-        description="Preferred ONNX execution providers",
-        validation_alias="EMBEDDINGS_ONNX_PREFERRED_PROVIDERS",
-    )

lib/crewai/src/crewai/rag/embeddings/providers/onnx/types.py

@@ -1,18 +0,0 @@
-"""Type definitions for ONNX embedding providers."""
-
-from typing import Literal
-
-from typing_extensions import Required, TypedDict
-
-
-class ONNXProviderConfig(TypedDict, total=False):
-    """Configuration for ONNX provider."""
-
-    preferred_providers: list[str]
-
-
-class ONNXProviderSpec(TypedDict, total=False):
-    """ONNX provider specification."""
-
-    provider: Required[Literal["onnx"]]
-    config: ONNXProviderConfig

lib/crewai/src/crewai/rag/embeddings/providers/openai/__init__.py

@@ -1,15 +0,0 @@
-"""OpenAI embedding providers."""
-
-from crewai.rag.embeddings.providers.openai.openai_provider import (
-    OpenAIProvider,
-)
-from crewai.rag.embeddings.providers.openai.types import (
-    OpenAIProviderConfig,
-    OpenAIProviderSpec,
-)
-
-__all__ = [
-    "OpenAIProvider",
-    "OpenAIProviderConfig",
-    "OpenAIProviderSpec",
-]

lib/crewai/src/crewai/rag/embeddings/providers/openai/openai_provider.py

@@ -1,62 +0,0 @@
-"""OpenAI embeddings provider."""
-
-from typing import Any
-
-from chromadb.utils.embedding_functions.openai_embedding_function import (
-    OpenAIEmbeddingFunction,
-)
-from pydantic import Field
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-
-
-class OpenAIProvider(BaseEmbeddingsProvider[OpenAIEmbeddingFunction]):
-    """OpenAI embeddings provider."""
-
-    embedding_callable: type[OpenAIEmbeddingFunction] = Field(
-        default=OpenAIEmbeddingFunction,
-        description="OpenAI embedding function class",
-    )
-    api_key: str | None = Field(
-        default=None,
-        description="OpenAI API key",
-        validation_alias="EMBEDDINGS_OPENAI_API_KEY",
-    )
-    model_name: str = Field(
-        default="text-embedding-ada-002",
-        description="Model name to use for embeddings",
-        validation_alias="EMBEDDINGS_OPENAI_MODEL_NAME",
-    )
-    api_base: str | None = Field(
-        default=None,
-        description="Base URL for API requests",
-        validation_alias="EMBEDDINGS_OPENAI_API_BASE",
-    )
-    api_type: str | None = Field(
-        default=None,
-        description="API type (e.g., 'azure')",
-        validation_alias="EMBEDDINGS_OPENAI_API_TYPE",
-    )
-    api_version: str | None = Field(
-        default=None,
-        description="API version",
-        validation_alias="EMBEDDINGS_OPENAI_API_VERSION",
-    )
-    default_headers: dict[str, Any] | None = Field(
-        default=None, description="Default headers for API requests"
-    )
-    dimensions: int | None = Field(
-        default=None,
-        description="Embedding dimensions",
-        validation_alias="EMBEDDINGS_OPENAI_DIMENSIONS",
-    )
-    deployment_id: str | None = Field(
-        default=None,
-        description="Azure deployment ID",
-        validation_alias="EMBEDDINGS_OPENAI_DEPLOYMENT_ID",
-    )
-    organization_id: str | None = Field(
-        default=None,
-        description="OpenAI organization ID",
-        validation_alias="EMBEDDINGS_OPENAI_ORGANIZATION_ID",
-    )

lib/crewai/src/crewai/rag/embeddings/providers/openai/types.py

@@ -1,26 +0,0 @@
-"""Type definitions for OpenAI embedding providers."""
-
-from typing import Annotated, Any, Literal
-
-from typing_extensions import Required, TypedDict
-
-
-class OpenAIProviderConfig(TypedDict, total=False):
-    """Configuration for OpenAI provider."""
-
-    api_key: str
-    model_name: Annotated[str, "text-embedding-ada-002"]
-    api_base: str
-    api_type: str
-    api_version: str
-    default_headers: dict[str, Any]
-    dimensions: int
-    deployment_id: str
-    organization_id: str
-
-
-class OpenAIProviderSpec(TypedDict, total=False):
-    """OpenAI provider specification."""
-
-    provider: Required[Literal["openai"]]
-    config: OpenAIProviderConfig

lib/crewai/src/crewai/rag/embeddings/providers/openclip/__init__.py

@@ -1,15 +0,0 @@
-"""OpenCLIP embedding providers."""
-
-from crewai.rag.embeddings.providers.openclip.openclip_provider import (
-    OpenCLIPProvider,
-)
-from crewai.rag.embeddings.providers.openclip.types import (
-    OpenCLIPProviderConfig,
-    OpenCLIPProviderSpec,
-)
-
-__all__ = [
-    "OpenCLIPProvider",
-    "OpenCLIPProviderConfig",
-    "OpenCLIPProviderSpec",
-]

lib/crewai/src/crewai/rag/embeddings/providers/openclip/openclip_provider.py

@@ -1,32 +0,0 @@
-"""OpenCLIP embeddings provider."""
-
-from chromadb.utils.embedding_functions.open_clip_embedding_function import (
-    OpenCLIPEmbeddingFunction,
-)
-from pydantic import Field
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-
-
-class OpenCLIPProvider(BaseEmbeddingsProvider[OpenCLIPEmbeddingFunction]):
-    """OpenCLIP embeddings provider."""
-
-    embedding_callable: type[OpenCLIPEmbeddingFunction] = Field(
-        default=OpenCLIPEmbeddingFunction,
-        description="OpenCLIP embedding function class",
-    )
-    model_name: str = Field(
-        default="ViT-B-32",
-        description="Model name to use",
-        validation_alias="EMBEDDINGS_OPENCLIP_MODEL_NAME",
-    )
-    checkpoint: str = Field(
-        default="laion2b_s34b_b79k",
-        description="Model checkpoint",
-        validation_alias="EMBEDDINGS_OPENCLIP_CHECKPOINT",
-    )
-    device: str | None = Field(
-        default="cpu",
-        description="Device to run model on",
-        validation_alias="EMBEDDINGS_OPENCLIP_DEVICE",
-    )

lib/crewai/src/crewai/rag/embeddings/providers/openclip/types.py

@@ -1,20 +0,0 @@
-"""Type definitions for OpenCLIP embedding providers."""
-
-from typing import Annotated, Literal
-
-from typing_extensions import Required, TypedDict
-
-
-class OpenCLIPProviderConfig(TypedDict, total=False):
-    """Configuration for OpenCLIP provider."""
-
-    model_name: Annotated[str, "ViT-B-32"]
-    checkpoint: Annotated[str, "laion2b_s34b_b79k"]
-    device: Annotated[str, "cpu"]
-
-
-class OpenCLIPProviderSpec(TypedDict):
-    """OpenCLIP provider specification."""
-
-    provider: Required[Literal["openclip"]]
-    config: OpenCLIPProviderConfig

lib/crewai/src/crewai/rag/embeddings/providers/roboflow/__init__.py

@@ -1,15 +0,0 @@
-"""Roboflow embedding providers."""
-
-from crewai.rag.embeddings.providers.roboflow.roboflow_provider import (
-    RoboflowProvider,
-)
-from crewai.rag.embeddings.providers.roboflow.types import (
-    RoboflowProviderConfig,
-    RoboflowProviderSpec,
-)
-
-__all__ = [
-    "RoboflowProvider",
-    "RoboflowProviderConfig",
-    "RoboflowProviderSpec",
-]

lib/crewai/src/crewai/rag/embeddings/providers/roboflow/roboflow_provider.py

@@ -1,27 +0,0 @@
-"""Roboflow embeddings provider."""
-
-from chromadb.utils.embedding_functions.roboflow_embedding_function import (
-    RoboflowEmbeddingFunction,
-)
-from pydantic import Field
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-
-
-class RoboflowProvider(BaseEmbeddingsProvider[RoboflowEmbeddingFunction]):
-    """Roboflow embeddings provider."""
-
-    embedding_callable: type[RoboflowEmbeddingFunction] = Field(
-        default=RoboflowEmbeddingFunction,
-        description="Roboflow embedding function class",
-    )
-    api_key: str = Field(
-        default="",
-        description="Roboflow API key",
-        validation_alias="EMBEDDINGS_ROBOFLOW_API_KEY",
-    )
-    api_url: str = Field(
-        default="https://infer.roboflow.com",
-        description="Roboflow API URL",
-        validation_alias="EMBEDDINGS_ROBOFLOW_API_URL",
-    )

lib/crewai/src/crewai/rag/embeddings/providers/roboflow/types.py

@@ -1,19 +0,0 @@
-"""Type definitions for Roboflow embedding providers."""
-
-from typing import Annotated, Literal
-
-from typing_extensions import Required, TypedDict
-
-
-class RoboflowProviderConfig(TypedDict, total=False):
-    """Configuration for Roboflow provider."""
-
-    api_key: Annotated[str, ""]
-    api_url: Annotated[str, "https://infer.roboflow.com"]
-
-
-class RoboflowProviderSpec(TypedDict):
-    """Roboflow provider specification."""
-
-    provider: Required[Literal["roboflow"]]
-    config: RoboflowProviderConfig

lib/crewai/src/crewai/rag/embeddings/providers/sentence_transformer/__init__.py

@@ -1,15 +0,0 @@
-"""SentenceTransformer embedding providers."""
-
-from crewai.rag.embeddings.providers.sentence_transformer.sentence_transformer_provider import (
-    SentenceTransformerProvider,
-)
-from crewai.rag.embeddings.providers.sentence_transformer.types import (
-    SentenceTransformerProviderConfig,
-    SentenceTransformerProviderSpec,
-)
-
-__all__ = [
-    "SentenceTransformerProvider",
-    "SentenceTransformerProviderConfig",
-    "SentenceTransformerProviderSpec",
-]

lib/crewai/src/crewai/rag/embeddings/providers/sentence_transformer/sentence_transformer_provider.py

@@ -1,34 +0,0 @@
-"""SentenceTransformer embeddings provider."""
-
-from chromadb.utils.embedding_functions.sentence_transformer_embedding_function import (
-    SentenceTransformerEmbeddingFunction,
-)
-from pydantic import Field
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-
-
-class SentenceTransformerProvider(
-    BaseEmbeddingsProvider[SentenceTransformerEmbeddingFunction]
-):
-    """SentenceTransformer embeddings provider."""
-
-    embedding_callable: type[SentenceTransformerEmbeddingFunction] = Field(
-        default=SentenceTransformerEmbeddingFunction,
-        description="SentenceTransformer embedding function class",
-    )
-    model_name: str = Field(
-        default="all-MiniLM-L6-v2",
-        description="Model name to use",
-        validation_alias="EMBEDDINGS_SENTENCE_TRANSFORMER_MODEL_NAME",
-    )
-    device: str = Field(
-        default="cpu",
-        description="Device to run model on (cpu or cuda)",
-        validation_alias="EMBEDDINGS_SENTENCE_TRANSFORMER_DEVICE",
-    )
-    normalize_embeddings: bool = Field(
-        default=False,
-        description="Whether to normalize embeddings",
-        validation_alias="EMBEDDINGS_SENTENCE_TRANSFORMER_NORMALIZE_EMBEDDINGS",
-    )

lib/crewai/src/crewai/rag/embeddings/providers/sentence_transformer/types.py

@@ -1,20 +0,0 @@
-"""Type definitions for SentenceTransformer embedding providers."""
-
-from typing import Annotated, Literal
-
-from typing_extensions import Required, TypedDict
-
-
-class SentenceTransformerProviderConfig(TypedDict, total=False):
-    """Configuration for SentenceTransformer provider."""
-
-    model_name: Annotated[str, "all-MiniLM-L6-v2"]
-    device: Annotated[str, "cpu"]
-    normalize_embeddings: Annotated[bool, False]
-
-
-class SentenceTransformerProviderSpec(TypedDict):
-    """SentenceTransformer provider specification."""
-
-    provider: Required[Literal["sentence-transformer"]]
-    config: SentenceTransformerProviderConfig

lib/crewai/src/crewai/rag/embeddings/providers/text2vec/__init__.py

@@ -1,15 +0,0 @@
-"""Text2Vec embedding providers."""
-
-from crewai.rag.embeddings.providers.text2vec.text2vec_provider import (
-    Text2VecProvider,
-)
-from crewai.rag.embeddings.providers.text2vec.types import (
-    Text2VecProviderConfig,
-    Text2VecProviderSpec,
-)
-
-__all__ = [
-    "Text2VecProvider",
-    "Text2VecProviderConfig",
-    "Text2VecProviderSpec",
-]

lib/crewai/src/crewai/rag/embeddings/providers/text2vec/text2vec_provider.py

@@ -1,22 +0,0 @@
-"""Text2Vec embeddings provider."""
-
-from chromadb.utils.embedding_functions.text2vec_embedding_function import (
-    Text2VecEmbeddingFunction,
-)
-from pydantic import Field
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-
-
-class Text2VecProvider(BaseEmbeddingsProvider[Text2VecEmbeddingFunction]):
-    """Text2Vec embeddings provider."""
-
-    embedding_callable: type[Text2VecEmbeddingFunction] = Field(
-        default=Text2VecEmbeddingFunction,
-        description="Text2Vec embedding function class",
-    )
-    model_name: str = Field(
-        default="shibing624/text2vec-base-chinese",
-        description="Model name to use",
-        validation_alias="EMBEDDINGS_TEXT2VEC_MODEL_NAME",
-    )

lib/crewai/src/crewai/rag/embeddings/providers/text2vec/types.py

@@ -1,18 +0,0 @@
-"""Type definitions for Text2Vec embedding providers."""
-
-from typing import Annotated, Literal
-
-from typing_extensions import Required, TypedDict
-
-
-class Text2VecProviderConfig(TypedDict, total=False):
-    """Configuration for Text2Vec provider."""
-
-    model_name: Annotated[str, "shibing624/text2vec-base-chinese"]
-
-
-class Text2VecProviderSpec(TypedDict):
-    """Text2Vec provider specification."""
-
-    provider: Required[Literal["text2vec"]]
-    config: Text2VecProviderConfig

lib/crewai/src/crewai/rag/embeddings/providers/voyageai/__init__.py

@@ -1,15 +0,0 @@
-"""VoyageAI embedding providers."""
-
-from crewai.rag.embeddings.providers.voyageai.types import (
-    VoyageAIProviderConfig,
-    VoyageAIProviderSpec,
-)
-from crewai.rag.embeddings.providers.voyageai.voyageai_provider import (
-    VoyageAIProvider,
-)
-
-__all__ = [
-    "VoyageAIProvider",
-    "VoyageAIProviderConfig",
-    "VoyageAIProviderSpec",
-]

lib/crewai/src/crewai/rag/embeddings/providers/voyageai/embedding_callable.py

@@ -1,62 +0,0 @@
-"""VoyageAI embedding function implementation."""
-
-from typing import cast
-
-from chromadb.api.types import Documents, EmbeddingFunction, Embeddings
-from typing_extensions import Unpack
-
-from crewai.rag.embeddings.providers.voyageai.types import VoyageAIProviderConfig
-
-
-class VoyageAIEmbeddingFunction(EmbeddingFunction[Documents]):
-    """Embedding function for VoyageAI models."""
-
-    def __init__(self, **kwargs: Unpack[VoyageAIProviderConfig]) -> None:
-        """Initialize VoyageAI embedding function.
-
-        Args:
-            **kwargs: Configuration parameters for VoyageAI.
-        """
-        try:
-            import voyageai  # type: ignore[import-not-found]
-
-        except ImportError as e:
-            raise ImportError(
-                "voyageai is required for voyageai embeddings. "
-                "Install it with: uv add voyageai"
-            ) from e
-        self._config = kwargs
-        self._client = voyageai.Client(
-            api_key=kwargs["api_key"],
-            max_retries=kwargs.get("max_retries", 0),
-            timeout=kwargs.get("timeout"),
-        )
-
-    @staticmethod
-    def name() -> str:
-        """Return the name of the embedding function for ChromaDB compatibility."""
-        return "voyageai"
-
-    def __call__(self, input: Documents) -> Embeddings:
-        """Generate embeddings for input documents.
-
-        Args:
-            input: List of documents to embed.
-
-        Returns:
-            List of embedding vectors.
-        """
-
-        if isinstance(input, str):
-            input = [input]
-
-        result = self._client.embed(
-            texts=input,
-            model=self._config.get("model", "voyage-2"),
-            input_type=self._config.get("input_type"),
-            truncation=self._config.get("truncation", True),
-            output_dtype=self._config.get("output_dtype"),
-            output_dimension=self._config.get("output_dimension"),
-        )
-
-        return cast(Embeddings, result.embeddings)

lib/crewai/src/crewai/rag/embeddings/providers/voyageai/types.py

@@ -1,25 +0,0 @@
-"""Type definitions for VoyageAI embedding providers."""
-
-from typing import Annotated, Literal
-
-from typing_extensions import Required, TypedDict
-
-
-class VoyageAIProviderConfig(TypedDict, total=False):
-    """Configuration for VoyageAI provider."""
-
-    api_key: str
-    model: Annotated[str, "voyage-2"]
-    input_type: str
-    truncation: Annotated[bool, True]
-    output_dtype: str
-    output_dimension: int
-    max_retries: Annotated[int, 0]
-    timeout: float
-
-
-class VoyageAIProviderSpec(TypedDict):
-    """VoyageAI provider specification."""
-
-    provider: Required[Literal["voyageai"]]
-    config: VoyageAIProviderConfig

lib/crewai/src/crewai/rag/embeddings/providers/voyageai/voyageai_provider.py

@@ -1,55 +0,0 @@
-"""Voyage AI embeddings provider."""
-
-from pydantic import Field
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-from crewai.rag.embeddings.providers.voyageai.embedding_callable import (
-    VoyageAIEmbeddingFunction,
-)
-
-
-class VoyageAIProvider(BaseEmbeddingsProvider[VoyageAIEmbeddingFunction]):
-    """Voyage AI embeddings provider."""
-
-    embedding_callable: type[VoyageAIEmbeddingFunction] = Field(
-        default=VoyageAIEmbeddingFunction,
-        description="Voyage AI embedding function class",
-    )
-    model: str = Field(
-        default="voyage-2",
-        description="Model to use for embeddings",
-        validation_alias="EMBEDDINGS_VOYAGEAI_MODEL",
-    )
-    api_key: str = Field(
-        description="Voyage AI API key", validation_alias="EMBEDDINGS_VOYAGEAI_API_KEY"
-    )
-    input_type: str | None = Field(
-        default=None,
-        description="Input type for embeddings",
-        validation_alias="EMBEDDINGS_VOYAGEAI_INPUT_TYPE",
-    )
-    truncation: bool = Field(
-        default=True,
-        description="Whether to truncate inputs",
-        validation_alias="EMBEDDINGS_VOYAGEAI_TRUNCATION",
-    )
-    output_dtype: str | None = Field(
-        default=None,
-        description="Output data type",
-        validation_alias="EMBEDDINGS_VOYAGEAI_OUTPUT_DTYPE",
-    )
-    output_dimension: int | None = Field(
-        default=None,
-        description="Output dimension",
-        validation_alias="EMBEDDINGS_VOYAGEAI_OUTPUT_DIMENSION",
-    )
-    max_retries: int = Field(
-        default=0,
-        description="Maximum retries for API calls",
-        validation_alias="EMBEDDINGS_VOYAGEAI_MAX_RETRIES",
-    )
-    timeout: float | None = Field(
-        default=None,
-        description="Timeout for API calls",
-        validation_alias="EMBEDDINGS_VOYAGEAI_TIMEOUT",
-    )

lib/crewai/src/crewai/rag/embeddings/types.py

@@ -1,78 +0,0 @@
-"""Type definitions for the embeddings module."""
-
-from typing import Literal, TypeAlias
-
-from crewai.rag.core.base_embeddings_provider import BaseEmbeddingsProvider
-from crewai.rag.embeddings.providers.aws.types import BedrockProviderSpec
-from crewai.rag.embeddings.providers.cohere.types import CohereProviderSpec
-from crewai.rag.embeddings.providers.custom.types import CustomProviderSpec
-from crewai.rag.embeddings.providers.google.types import (
-    GenerativeAiProviderSpec,
-    VertexAIProviderSpec,
-)
-from crewai.rag.embeddings.providers.huggingface.types import HuggingFaceProviderSpec
-from crewai.rag.embeddings.providers.ibm.types import (
-    WatsonProviderSpec,
-    WatsonXProviderSpec,
-)
-from crewai.rag.embeddings.providers.instructor.types import InstructorProviderSpec
-from crewai.rag.embeddings.providers.jina.types import JinaProviderSpec
-from crewai.rag.embeddings.providers.microsoft.types import AzureProviderSpec
-from crewai.rag.embeddings.providers.ollama.types import OllamaProviderSpec
-from crewai.rag.embeddings.providers.onnx.types import ONNXProviderSpec
-from crewai.rag.embeddings.providers.openai.types import OpenAIProviderSpec
-from crewai.rag.embeddings.providers.openclip.types import OpenCLIPProviderSpec
-from crewai.rag.embeddings.providers.roboflow.types import RoboflowProviderSpec
-from crewai.rag.embeddings.providers.sentence_transformer.types import (
-    SentenceTransformerProviderSpec,
-)
-from crewai.rag.embeddings.providers.text2vec.types import Text2VecProviderSpec
-from crewai.rag.embeddings.providers.voyageai.types import VoyageAIProviderSpec
-
-ProviderSpec = (
-    AzureProviderSpec
-    | BedrockProviderSpec
-    | CohereProviderSpec
-    | CustomProviderSpec
-    | GenerativeAiProviderSpec
-    | HuggingFaceProviderSpec
-    | InstructorProviderSpec
-    | JinaProviderSpec
-    | OllamaProviderSpec
-    | ONNXProviderSpec
-    | OpenAIProviderSpec
-    | OpenCLIPProviderSpec
-    | RoboflowProviderSpec
-    | SentenceTransformerProviderSpec
-    | Text2VecProviderSpec
-    | VertexAIProviderSpec
-    | VoyageAIProviderSpec
-    | WatsonProviderSpec  # Deprecated, use WatsonXProviderSpec
-    | WatsonXProviderSpec
-)
-
-AllowedEmbeddingProviders = Literal[
-    "azure",
-    "amazon-bedrock",
-    "cohere",
-    "custom",
-    "google-generativeai",
-    "google-vertex",
-    "huggingface",
-    "instructor",
-    "jina",
-    "ollama",
-    "onnx",
-    "openai",
-    "openclip",
-    "roboflow",
-    "sentence-transformer",
-    "text2vec",
-    "voyageai",
-    "watsonx",
-    "watson",  # for backward compatibility until v1.0.0
-]
-
-EmbedderConfig: TypeAlias = (
-    ProviderSpec | BaseEmbeddingsProvider | type[BaseEmbeddingsProvider]
-)

lib/crewai/src/crewai/rag/qdrant/__init__.py

@@ -1 +0,0 @@
-"""Qdrant vector database client implementation."""

lib/crewai/src/crewai/rag/storage/__init__.py

@@ -1 +0,0 @@
-"""Storage components for RAG infrastructure."""

lib/crewai/src/crewai/utilities/__init__.py

@@ -1,24 +0,0 @@
-from crewai.utilities.converter import Converter, ConverterError
-from crewai.utilities.exceptions.context_window_exceeding_exception import (
-    LLMContextLengthExceededError,
-)
-from crewai.utilities.file_handler import FileHandler
-from crewai.utilities.i18n import I18N
-from crewai.utilities.internal_instructor import InternalInstructor
-from crewai.utilities.logger import Logger
-from crewai.utilities.printer import Printer
-from crewai.utilities.prompts import Prompts
-from crewai.utilities.rpm_controller import RPMController
-
-__all__ = [
-    "I18N",
-    "Converter",
-    "ConverterError",
-    "FileHandler",
-    "InternalInstructor",
-    "LLMContextLengthExceededError",
-    "Logger",
-    "Printer",
-    "Prompts",
-    "RPMController",
-]

lib/crewai/src/crewai/utilities/constants.py

@@ -1,32 +0,0 @@
-from typing import Annotated, Final
-
-from crewai.utilities.printer import PrinterColor
-
-TRAINING_DATA_FILE: Final[str] = "training_data.pkl"
-TRAINED_AGENTS_DATA_FILE: Final[str] = "trained_agents_data.pkl"
-KNOWLEDGE_DIRECTORY: Final[str] = "knowledge"
-MAX_FILE_NAME_LENGTH: Final[int] = 255
-EMITTER_COLOR: Final[PrinterColor] = "bold_blue"
-
-
-class _NotSpecified:
-    """Sentinel class to detect when no value has been explicitly provided.
-
-    Notes:
-        - TODO: Consider moving this class and NOT_SPECIFIED to types.py
-          as they are more type-related constructs than business constants.
-    """
-
-    def __repr__(self) -> str:
-        return "NOT_SPECIFIED"
-
-
-NOT_SPECIFIED: Final[
-    Annotated[
-        _NotSpecified,
-        "Sentinel value used to detect when no value has been explicitly provided. "
-        "Unlike `None`, which might be a valid value from the user, `NOT_SPECIFIED` "
-        "allows us to distinguish between 'not passed at all' and 'explicitly passed None' or '[]'.",
-    ]
-] = _NotSpecified()
-CREWAI_BASE_URL: Final[str] = "https://app.crewai.com"

lib/crewai/src/crewai/utilities/converter.py

@@ -1,448 +0,0 @@
-from __future__ import annotations
-
-import json
-import re
-from typing import TYPE_CHECKING, Any, Final, TypedDict, Union, get_args, get_origin
-
-from pydantic import BaseModel, ValidationError
-from typing_extensions import Unpack
-
-from crewai.agents.agent_builder.utilities.base_output_converter import OutputConverter
-from crewai.utilities.internal_instructor import InternalInstructor
-from crewai.utilities.printer import Printer
-from crewai.utilities.pydantic_schema_parser import PydanticSchemaParser
-
-if TYPE_CHECKING:
-    from crewai.agent import Agent
-    from crewai.llm import LLM
-    from crewai.llms.base_llm import BaseLLM
-
-_JSON_PATTERN: Final[re.Pattern[str]] = re.compile(r"({.*})", re.DOTALL)
-
-
-class ConverterError(Exception):
-    """Error raised when Converter fails to parse the input."""
-
-    def __init__(self, message: str, *args: object) -> None:
-        """Initialize the ConverterError with a message.
-
-        Args:
-            message: The error message.
-            *args: Additional arguments for the base Exception class.
-        """
-        super().__init__(message, *args)
-        self.message = message
-
-
-class Converter(OutputConverter):
-    """Class that converts text into either pydantic or json."""
-
-    def to_pydantic(self, current_attempt: int = 1) -> BaseModel:
-        """Convert text to pydantic.
-
-        Args:
-            current_attempt: The current attempt number for conversion retries.
-
-        Returns:
-            A Pydantic BaseModel instance.
-
-        Raises:
-            ConverterError: If conversion fails after maximum attempts.
-        """
-        try:
-            if self.llm.supports_function_calling():
-                result = self._create_instructor().to_pydantic()
-            else:
-                response = self.llm.call(
-                    [
-                        {"role": "system", "content": self.instructions},
-                        {"role": "user", "content": self.text},
-                    ]
-                )
-                try:
-                    # Try to directly validate the response JSON
-                    result = self.model.model_validate_json(response)
-                except ValidationError:
-                    # If direct validation fails, attempt to extract valid JSON
-                    result = handle_partial_json(
-                        result=response,
-                        model=self.model,
-                        is_json_output=False,
-                        agent=None,
-                    )
-                    # Ensure result is a BaseModel instance
-                    if not isinstance(result, BaseModel):
-                        if isinstance(result, dict):
-                            result = self.model.model_validate(result)
-                        elif isinstance(result, str):
-                            try:
-                                parsed = json.loads(result)
-                                result = self.model.model_validate(parsed)
-                            except Exception as parse_err:
-                                raise ConverterError(
-                                    f"Failed to convert partial JSON result into Pydantic: {parse_err}"
-                                ) from parse_err
-                        else:
-                            raise ConverterError(
-                                "handle_partial_json returned an unexpected type."
-                            ) from None
-            return result
-        except ValidationError as e:
-            if current_attempt < self.max_attempts:
-                return self.to_pydantic(current_attempt + 1)
-            raise ConverterError(
-                f"Failed to convert text into a Pydantic model due to validation error: {e}"
-            ) from e
-        except Exception as e:
-            if current_attempt < self.max_attempts:
-                return self.to_pydantic(current_attempt + 1)
-            raise ConverterError(
-                f"Failed to convert text into a Pydantic model due to error: {e}"
-            ) from e
-
-    def to_json(self, current_attempt: int = 1) -> str | ConverterError | Any:  # type: ignore[override]
-        """Convert text to json.
-
-        Args:
-            current_attempt: The current attempt number for conversion retries.
-
-        Returns:
-            A JSON string or ConverterError if conversion fails.
-
-        Raises:
-            ConverterError: If conversion fails after maximum attempts.
-
-        """
-        try:
-            if self.llm.supports_function_calling():
-                return self._create_instructor().to_json()
-            return json.dumps(
-                self.llm.call(
-                    [
-                        {"role": "system", "content": self.instructions},
-                        {"role": "user", "content": self.text},
-                    ]
-                )
-            )
-        except Exception as e:
-            if current_attempt < self.max_attempts:
-                return self.to_json(current_attempt + 1)
-            return ConverterError(f"Failed to convert text into JSON, error: {e}.")
-
-    def _create_instructor(self) -> InternalInstructor:
-        """Create an instructor."""
-
-        return InternalInstructor(
-            llm=self.llm,
-            model=self.model,
-            content=self.text,
-        )
-
-
-def convert_to_model(
-    result: str,
-    output_pydantic: type[BaseModel] | None,
-    output_json: type[BaseModel] | None,
-    agent: Agent | None = None,
-    converter_cls: type[Converter] | None = None,
-) -> dict[str, Any] | BaseModel | str:
-    """Convert a result string to a Pydantic model or JSON.
-
-    Args:
-        result: The result string to convert.
-        output_pydantic: The Pydantic model class to convert to.
-        output_json: The Pydantic model class to convert to JSON.
-        agent: The agent instance.
-        converter_cls: The converter class to use.
-
-    Returns:
-        The converted result as a dict, BaseModel, or original string.
-    """
-    model = output_pydantic or output_json
-    if model is None:
-        return result
-    try:
-        escaped_result = json.dumps(json.loads(result, strict=False))
-        return validate_model(
-            result=escaped_result, model=model, is_json_output=bool(output_json)
-        )
-    except json.JSONDecodeError:
-        return handle_partial_json(
-            result=result,
-            model=model,
-            is_json_output=bool(output_json),
-            agent=agent,
-            converter_cls=converter_cls,
-        )
-
-    except ValidationError:
-        return handle_partial_json(
-            result=result,
-            model=model,
-            is_json_output=bool(output_json),
-            agent=agent,
-            converter_cls=converter_cls,
-        )
-
-    except Exception as e:
-        Printer().print(
-            content=f"Unexpected error during model conversion: {type(e).__name__}: {e}. Returning original result.",
-            color="red",
-        )
-        return result
-
-
-def validate_model(
-    result: str, model: type[BaseModel], is_json_output: bool
-) -> dict[str, Any] | BaseModel:
-    """Validate and convert a JSON string to a Pydantic model or dict.
-
-    Args:
-        result: The JSON string to validate and convert.
-        model: The Pydantic model class to convert to.
-        is_json_output: Whether to return a dict (True) or Pydantic model (False).
-
-    Returns:
-        The converted result as a dict or BaseModel.
-    """
-    exported_result = model.model_validate_json(result)
-    if is_json_output:
-        return exported_result.model_dump()
-    return exported_result
-
-
-def handle_partial_json(
-    result: str,
-    model: type[BaseModel],
-    is_json_output: bool,
-    agent: Agent | None,
-    converter_cls: type[Converter] | None = None,
-) -> dict[str, Any] | BaseModel | str:
-    """Handle partial JSON in a result string and convert to Pydantic model or dict.
-
-    Args:
-        result: The result string to process.
-        model: The Pydantic model class to convert to.
-        is_json_output: Whether to return a dict (True) or Pydantic model (False).
-        agent: The agent instance.
-        converter_cls: The converter class to use.
-
-    Returns:
-        The converted result as a dict, BaseModel, or original string.
-    """
-    match = _JSON_PATTERN.search(result)
-    if match:
-        try:
-            exported_result = model.model_validate_json(match.group())
-            if is_json_output:
-                return exported_result.model_dump()
-            return exported_result
-        except json.JSONDecodeError:
-            pass
-        except ValidationError:
-            pass
-        except Exception as e:
-            Printer().print(
-                content=f"Unexpected error during partial JSON handling: {type(e).__name__}: {e}. Attempting alternative conversion method.",
-                color="red",
-            )
-
-    return convert_with_instructions(
-        result=result,
-        model=model,
-        is_json_output=is_json_output,
-        agent=agent,
-        converter_cls=converter_cls,
-    )
-
-
-def convert_with_instructions(
-    result: str,
-    model: type[BaseModel],
-    is_json_output: bool,
-    agent: Agent | None,
-    converter_cls: type[Converter] | None = None,
-) -> dict | BaseModel | str:
-    """Convert a result string to a Pydantic model or JSON using instructions.
-
-    Args:
-        result: The result string to convert.
-        model: The Pydantic model class to convert to.
-        is_json_output: Whether to return a dict (True) or Pydantic model (False).
-        agent: The agent instance.
-        converter_cls: The converter class to use.
-
-    Returns:
-        The converted result as a dict, BaseModel, or original string.
-
-    Raises:
-        TypeError: If neither agent nor converter_cls is provided.
-
-    Notes:
-        - TODO: Fix llm typing issues, return llm should not be able to be str or None.
-    """
-    if agent is None:
-        raise TypeError("Agent must be provided if converter_cls is not specified.")
-    llm = agent.function_calling_llm or agent.llm
-    instructions = get_conversion_instructions(model=model, llm=llm)
-    converter = create_converter(
-        agent=agent,
-        converter_cls=converter_cls,
-        llm=llm,
-        text=result,
-        model=model,
-        instructions=instructions,
-    )
-    exported_result = (
-        converter.to_pydantic() if not is_json_output else converter.to_json()
-    )
-
-    if isinstance(exported_result, ConverterError):
-        Printer().print(
-            content=f"{exported_result.message} Using raw output instead.",
-            color="red",
-        )
-        return result
-
-    return exported_result
-
-
-def get_conversion_instructions(
-    model: type[BaseModel], llm: BaseLLM | LLM | str
-) -> str:
-    """Generate conversion instructions based on the model and LLM capabilities.
-
-    Args:
-        model: A Pydantic model class.
-        llm: The language model instance.
-
-    Returns:
-
-    """
-    instructions = "Please convert the following text into valid JSON."
-    if (
-        llm
-        and not isinstance(llm, str)
-        and hasattr(llm, "supports_function_calling")
-        and llm.supports_function_calling()
-    ):
-        model_schema = PydanticSchemaParser(model=model).get_schema()
-        instructions += (
-            f"\n\nOutput ONLY the valid JSON and nothing else.\n\n"
-            f"The JSON must follow this schema exactly:\n```json\n{model_schema}\n```"
-        )
-    else:
-        model_description = generate_model_description(model)
-        instructions += (
-            f"\n\nOutput ONLY the valid JSON and nothing else.\n\n"
-            f"The JSON must follow this format exactly:\n{model_description}"
-        )
-    return instructions
-
-
-class CreateConverterKwargs(TypedDict, total=False):
-    """Keyword arguments for creating a converter.
-
-    Attributes:
-        llm: The language model instance.
-        text: The text to convert.
-        model: The Pydantic model class.
-        instructions: The conversion instructions.
-    """
-
-    llm: BaseLLM | LLM | str
-    text: str
-    model: type[BaseModel]
-    instructions: str
-
-
-def create_converter(
-    agent: Agent | None = None,
-    converter_cls: type[Converter] | None = None,
-    *args: Any,
-    **kwargs: Unpack[CreateConverterKwargs],
-) -> Converter:
-    """Create a converter instance based on the agent or provided class.
-
-    Args:
-        agent: The agent instance.
-        converter_cls: The converter class to instantiate.
-        *args: The positional arguments to pass to the converter.
-        **kwargs: The keyword arguments to pass to the converter.
-
-    Returns:
-        An instance of the specified converter class.
-
-    Raises:
-        ValueError: If neither agent nor converter_cls is provided.
-        AttributeError: If the agent does not have a 'get_output_converter' method.
-        Exception: If no converter instance is created.
-
-    """
-    if agent and not converter_cls:
-        if hasattr(agent, "get_output_converter"):
-            converter = agent.get_output_converter(*args, **kwargs)
-        else:
-            raise AttributeError("Agent does not have a 'get_output_converter' method")
-    elif converter_cls:
-        converter = converter_cls(*args, **kwargs)
-    else:
-        raise ValueError("Either agent or converter_cls must be provided")
-
-    if not converter:
-        raise Exception("No output converter found or set.")
-
-    return converter
-
-
-def generate_model_description(model: type[BaseModel]) -> str:
-    """Generate a string description of a Pydantic model's fields and their types.
-
-    This function takes a Pydantic model class and returns a string that describes
-    the model's fields and their respective types. The description includes handling
-    of complex types such as `Optional`, `List`, and `Dict`, as well as nested Pydantic
-    models.
-
-    Args:
-        model: A Pydantic model class.
-
-    Returns:
-        A string representation of the model's fields and types.
-    """
-
-    def describe_field(field_type: Any) -> str:
-        """Recursively describe a field's type.
-
-        Args:
-            field_type: The type of the field to describe.
-
-        Returns:
-            A string representation of the field's type.
-        """
-        origin = get_origin(field_type)
-        args = get_args(field_type)
-
-        if origin is Union or (origin is None and len(args) > 0):
-            # Handle both Union and the new '|' syntax
-            non_none_args = [arg for arg in args if arg is not type(None)]
-            if len(non_none_args) == 1:
-                return f"Optional[{describe_field(non_none_args[0])}]"
-            return f"Optional[Union[{', '.join(describe_field(arg) for arg in non_none_args)}]]"
-        if origin is list:
-            return f"List[{describe_field(args[0])}]"
-        if origin is dict:
-            key_type = describe_field(args[0])
-            value_type = describe_field(args[1])
-            return f"Dict[{key_type}, {value_type}]"
-        if isinstance(field_type, type) and issubclass(field_type, BaseModel):
-            return generate_model_description(field_type)
-        if hasattr(field_type, "__name__"):
-            return field_type.__name__
-        return str(field_type)
-
-    fields = model.model_fields
-    field_descriptions = [
-        f'"{name}": {describe_field(field.annotation)}'
-        for name, field in fields.items()
-    ]
-    return "{\n  " + ",\n  ".join(field_descriptions) + "\n}"

lib/crewai/src/crewai/utilities/crew/__init__.py

@@ -1 +0,0 @@
-"""Crew-specific utilities."""

lib/crewai/src/crewai/utilities/crew/models.py

@@ -1,17 +0,0 @@
-"""Models for crew-related data structures."""
-
-from pydantic import BaseModel, Field
-
-
-class CrewContext(BaseModel):
-    """Model representing crew context information.
-
-    Attributes:
-        id: Unique identifier for the crew.
-        key: Optional crew key/name for identification.
-    """
-
-    id: str | None = Field(default=None, description="Unique identifier for the crew")
-    key: str | None = Field(
-        default=None, description="Optional crew key/name for identification"
-    )

lib/crewai/src/crewai/utilities/exceptions/context_window_exceeding_exception.py

@@ -1,58 +0,0 @@
-from typing import Final
-
-CONTEXT_LIMIT_ERRORS: Final[list[str]] = [
-    "expected a string with maximum length",
-    "maximum context length",
-    "context length exceeded",
-    "context_length_exceeded",
-    "context window full",
-    "too many tokens",
-    "input is too long",
-    "exceeds token limit",
-]
-
-
-class LLMContextLengthExceededError(Exception):
-    """Exception raised when the context length of a language model is exceeded.
-
-    Attributes:
-        original_error_message: The original error message from the LLM.
-    """
-
-    def __init__(self, error_message: str) -> None:
-        """Initialize the exception with the original error message.
-
-        Args:
-            error_message: The original error message from the LLM.
-        """
-        self.original_error_message = error_message
-        super().__init__(self._get_error_message(error_message))
-
-    @staticmethod
-    def _is_context_limit_error(error_message: str) -> bool:
-        """Check if the error message indicates a context length limit error.
-
-        Args:
-            error_message: The error message to check.
-
-        Returns:
-            True if the error message indicates a context length limit error, False otherwise.
-        """
-        return any(
-            phrase.lower() in error_message.lower() for phrase in CONTEXT_LIMIT_ERRORS
-        )
-
-    @staticmethod
-    def _get_error_message(error_message: str) -> str:
-        """Generate a user-friendly error message based on the original error message.
-
-        Args:
-            error_message: The original error message from the LLM.
-
-        Returns:
-            A user-friendly error message.
-        """
-        return (
-            f"LLM context length exceeded. Original error: {error_message}\n"
-            "Consider using a smaller input or implementing a text splitting strategy."
-        )

lib/crewai/src/crewai/utilities/file_handler.py

@@ -1,174 +0,0 @@
-import json
-import os
-import pickle
-from datetime import datetime
-from typing import Any, TypedDict
-
-from typing_extensions import Unpack
-
-
-class LogEntry(TypedDict, total=False):
-    """TypedDict for log entry kwargs with optional fields for flexibility."""
-
-    task_name: str
-    task: str
-    agent: str
-    status: str
-    output: str
-    input: str
-    message: str
-    level: str
-    crew: str
-    flow: str
-    tool: str
-    error: str
-    duration: float
-    metadata: dict[str, Any]
-
-
-class FileHandler:
-    """Handler for file operations supporting both JSON and text-based logging.
-
-    Attributes:
-        _path: The path to the log file.
-    """
-
-    def __init__(self, file_path: bool | str) -> None:
-        """Initialize the FileHandler with the specified file path.
-        Args:
-            file_path: Path to the log file or boolean flag.
-        """
-        self._initialize_path(file_path)
-
-    def _initialize_path(self, file_path: bool | str) -> None:
-        """Initialize the file path based on the input type.
-
-        Args:
-            file_path: Path to the log file or boolean flag.
-
-        Raises:
-            ValueError: If file_path is neither a string nor a boolean.
-        """
-        if file_path is True:  # File path is boolean True
-            self._path = os.path.join(os.curdir, "logs.txt")
-
-        elif isinstance(file_path, str):  # File path is a string
-            if file_path.endswith((".json", ".txt")):
-                self._path = (
-                    file_path  # No modification if the file ends with .json or .txt
-                )
-            else:
-                self._path = (
-                    file_path + ".txt"
-                )  # Append .txt if the file doesn't end with .json or .txt
-
-        else:
-            raise ValueError(
-                "file_path must be a string or boolean."
-            )  # Handle the case where file_path isn't valid
-
-    def log(self, **kwargs: Unpack[LogEntry]) -> None:
-        """Log data with structured fields.
-
-        Keyword Args:
-            task_name: Name of the task.
-            task: Description of the task.
-            agent: Name of the agent.
-            status: Status of the operation.
-            output: Output data.
-            input: Input data.
-            message: Log message.
-            level: Log level (e.g., INFO, ERROR).
-            crew: Name of the crew.
-            flow: Name of the flow.
-            tool: Name of the tool used.
-            error: Error message if any.
-            duration: Duration of the operation in seconds.
-            metadata: Additional metadata as a dictionary.
-
-        Raises:
-            ValueError: If logging fails.
-        """
-        try:
-            now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            log_entry = {"timestamp": now, **kwargs}
-
-            if self._path.endswith(".json"):
-                # Append log in JSON format
-                try:
-                    # Try reading existing content to avoid overwriting
-                    with open(self._path, encoding="utf-8") as read_file:
-                        existing_data = json.load(read_file)
-                        existing_data.append(log_entry)
-                except (json.JSONDecodeError, FileNotFoundError):
-                    # If no valid JSON or file doesn't exist, start with an empty list
-                    existing_data = [log_entry]
-
-                with open(self._path, "w", encoding="utf-8") as write_file:
-                    json.dump(existing_data, write_file, indent=4)
-                    write_file.write("\n")
-
-            else:
-                # Append log in plain text format
-                message = (
-                    f"{now}: "
-                    + ", ".join([f'{key}="{value}"' for key, value in kwargs.items()])
-                    + "\n"
-                )
-                with open(self._path, "a", encoding="utf-8") as file:
-                    file.write(message)
-
-        except Exception as e:
-            raise ValueError(f"Failed to log message: {e!s}") from e
-
-
-class PickleHandler:
-    """Handler for saving and loading data using pickle.
-
-    Attributes:
-        file_path: The path to the pickle file.
-    """
-
-    def __init__(self, file_name: str) -> None:
-        """Initialize the PickleHandler with the name of the file where data will be stored.
-
-        The file will be saved in the current directory.
-
-        Args:
-            file_name: The name of the file for saving and loading data.
-        """
-        if not file_name.endswith(".pkl"):
-            file_name += ".pkl"
-
-        self.file_path = os.path.join(os.getcwd(), file_name)
-
-    def initialize_file(self) -> None:
-        """Initialize the file with an empty dictionary and overwrite any existing data."""
-        self.save({})
-
-    def save(self, data: Any) -> None:
-        """
-        Save the data to the specified file using pickle.
-
-        Args:
-          data: The data to be saved to the file.
-        """
-        with open(self.file_path, "wb") as f:
-            pickle.dump(obj=data, file=f)
-
-    def load(self) -> Any:
-        """Load the data from the specified file using pickle.
-
-        Returns:
-            The data loaded from the file.
-        """
-        if not os.path.exists(self.file_path) or os.path.getsize(self.file_path) == 0:
-            return {}  # Return an empty dictionary if the file does not exist or is empty
-
-        with open(self.file_path, "rb") as file:
-            try:
-                return pickle.load(file)  # noqa: S301
-            except EOFError:
-                return {}  # Return an empty dictionary if the file is empty or corrupted
-            except Exception:
-                raise  # Raise any other exceptions that occur during loading

lib/crewai/src/crewai/utilities/formatter.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Final
-
-from crewai.utilities.constants import _NotSpecified
-
-if TYPE_CHECKING:
-    from crewai.task import Task
-    from crewai.tasks.task_output import TaskOutput
-
-
-DIVIDERS: Final[str] = "\n\n----------\n\n"
-
-
-def aggregate_raw_outputs_from_task_outputs(task_outputs: list[TaskOutput]) -> str:
-    """Generate string context from the task outputs.
-
-    Args:
-        task_outputs: List of TaskOutput objects.
-
-    Returns:
-        A string containing the aggregated raw outputs from the task outputs.
-    """
-
-    return DIVIDERS.join(output.raw for output in task_outputs)
-
-
-def aggregate_raw_outputs_from_tasks(tasks: list[Task] | _NotSpecified) -> str:
-    """Generate string context from the tasks.
-
-    Args:
-        tasks: List of Task objects or _NotSpecified.
-
-    Returns:
-        A string containing the aggregated raw outputs from the tasks.
-    """
-
-    task_outputs = (
-        [task.output for task in tasks if task.output is not None]
-        if isinstance(tasks, list)
-        else []
-    )
-
-    return aggregate_raw_outputs_from_task_outputs(task_outputs)

lib/crewai/src/crewai/utilities/i18n.py

@@ -1,110 +0,0 @@
-"""Internationalization support for CrewAI prompts and messages."""
-
-import json
-import os
-from typing import Literal
-
-from pydantic import BaseModel, Field, PrivateAttr, model_validator
-from typing_extensions import Self
-
-
-class I18N(BaseModel):
-    """Handles loading and retrieving internationalized prompts.
-
-    Attributes:
-        _prompts: Internal dictionary storing loaded prompts.
-        prompt_file: Optional path to a custom JSON file containing prompts.
-    """
-
-    _prompts: dict[str, dict[str, str]] = PrivateAttr()
-    prompt_file: str | None = Field(
-        default=None,
-        description="Path to the prompt_file file to load",
-    )
-
-    @model_validator(mode="after")
-    def load_prompts(self) -> Self:
-        """Load prompts from a JSON file.
-
-        Returns:
-            The I18N instance with loaded prompts.
-
-        Raises:
-            Exception: If the prompt file is not found or cannot be decoded.
-        """
-        try:
-            if self.prompt_file:
-                with open(self.prompt_file, encoding="utf-8") as f:
-                    self._prompts = json.load(f)
-            else:
-                dir_path = os.path.dirname(os.path.realpath(__file__))
-                prompts_path = os.path.join(dir_path, "../translations/en.json")
-
-                with open(prompts_path, encoding="utf-8") as f:
-                    self._prompts = json.load(f)
-        except FileNotFoundError as e:
-            raise Exception(f"Prompt file '{self.prompt_file}' not found.") from e
-        except json.JSONDecodeError as e:
-            raise Exception("Error decoding JSON from the prompts file.") from e
-
-        if not self._prompts:
-            self._prompts = {}
-
-        return self
-
-    def slice(self, slice: str) -> str:
-        """Retrieve a prompt slice by key.
-
-        Args:
-            slice: The key of the prompt slice to retrieve.
-
-        Returns:
-            The prompt slice as a string.
-        """
-        return self.retrieve("slices", slice)
-
-    def errors(self, error: str) -> str:
-        """Retrieve an error message by key.
-
-        Args:
-            error: The key of the error message to retrieve.
-
-        Returns:
-            The error message as a string.
-        """
-        return self.retrieve("errors", error)
-
-    def tools(self, tool: str) -> str | dict[str, str]:
-        """Retrieve a tool prompt by key.
-
-        Args:
-            tool: The key of the tool prompt to retrieve.
-
-        Returns:
-            The tool prompt as a string or dictionary.
-        """
-        return self.retrieve("tools", tool)
-
-    def retrieve(
-        self,
-        kind: Literal[
-            "slices", "errors", "tools", "reasoning", "hierarchical_manager_agent"
-        ],
-        key: str,
-    ) -> str:
-        """Retrieve a prompt by kind and key.
-
-        Args:
-            kind: The kind of prompt.
-            key: The key of the specific prompt to retrieve.
-
-        Returns:
-            The prompt as a string.
-
-        Raises:
-            Exception: If the prompt for the given kind and key is not found.
-        """
-        try:
-            return self._prompts[kind][key]
-        except Exception as e:
-            raise Exception(f"Prompt for '{kind}':'{key}'  not found.") from e

lib/crewai/src/crewai/utilities/import_utils.py

@@ -1,95 +0,0 @@
-"""Import utilities for optional dependencies."""
-
-import importlib
-from types import ModuleType
-from typing import Annotated, Any, TypeAlias
-
-from pydantic import AfterValidator, TypeAdapter
-from typing_extensions import deprecated
-
-
-@deprecated(
-    "Not needed when using `crewai.utilities.import_utils.import_and_validate_definition`"
-)
-class OptionalDependencyError(ImportError):
-    """Exception raised when an optional dependency is not installed."""
-
-
-@deprecated(
-    "Use `crewai.utilities.import_utils.import_and_validate_definition` instead."
-)
-def require(name: str, *, purpose: str, attr: str | None = None) -> ModuleType | Any:
-    """Import a module, optionally returning a specific attribute.
-
-    Args:
-        name: The module name to import.
-        purpose: Description of what requires this dependency.
-        attr: Optional attribute name to get from the module.
-
-    Returns:
-        The imported module or the specified attribute.
-
-    Raises:
-        OptionalDependencyError: If the module is not installed.
-        AttributeError: If the specified attribute doesn't exist.
-    """
-    try:
-        module = importlib.import_module(name)
-        if attr is not None:
-            return getattr(module, attr)
-        return module
-    except ImportError as exc:
-        package_name = name.split(".")[0]
-        raise OptionalDependencyError(
-            f"{purpose} requires the optional dependency '{name}'.\n"
-            f"Install it with: uv add {package_name}"
-        ) from exc
-    except AttributeError as exc:
-        raise AttributeError(f"Module '{name}' has no attribute '{attr}'") from exc
-
-
-def validate_import_path(v: str) -> Any:
-    """Import and return the class/function from the import path.
-
-    Args:
-        v: Import path string in the format 'module.path.ClassName'.
-
-    Returns:
-        The imported class or function.
-
-    Raises:
-        ValueError: If the import path is malformed or the module cannot be imported.
-    """
-    module_path, _, attr = v.rpartition(".")
-    if not module_path or not attr:
-        raise ValueError(f"import_path '{v}' must be of the form 'module.ClassName'")
-
-    try:
-        mod = importlib.import_module(module_path)
-    except ImportError as exc:
-        parts = module_path.split(".")
-        if not parts:
-            raise ValueError(f"Malformed import path: '{v}'") from exc
-        package = parts[0]
-        raise ValueError(
-            f"Package '{package}' could not be imported. Install it with: uv add {package}"
-        ) from exc
-
-    if not hasattr(mod, attr):
-        raise ValueError(f"Attribute '{attr}' not found in module '{module_path}'")
-    return getattr(mod, attr)
-
-
-ImportedDefinition: TypeAlias = Annotated[Any, AfterValidator(validate_import_path)]
-adapter = TypeAdapter(ImportedDefinition)
-
-
-def import_and_validate_definition(v: str) -> Any:
-    """Pydantic-compatible function to import a class/function from a string path.
-
-    Args:
-        v: Import path string in the format 'module.path.ClassName'.
-    Returns:
-        The imported class or function
-    """
-    return adapter.validate_python(v)

lib/crewai/src/crewai/utilities/internal_instructor.py

@@ -1,98 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Generic, TypeGuard, TypeVar
-
-from pydantic import BaseModel
-
-if TYPE_CHECKING:
-    from crewai.agent import Agent
-    from crewai.llm import LLM
-    from crewai.llms.base_llm import BaseLLM
-
-from crewai.utilities.logger_utils import suppress_warnings
-from crewai.utilities.types import LLMMessage
-
-T = TypeVar("T", bound=BaseModel)
-
-
-def _is_valid_llm(llm: Any) -> TypeGuard[str | LLM | BaseLLM]:
-    """Type guard to ensure LLM is valid and not None.
-
-    Args:
-        llm: The LLM to validate
-
-    Returns:
-        True if LLM is valid (string or has model attribute), False otherwise
-    """
-    return llm is not None and (isinstance(llm, str) or hasattr(llm, "model"))
-
-
-class InternalInstructor(Generic[T]):
-    """Class that wraps an agent LLM with instructor for structured output generation.
-
-    Attributes:
-        content: The content to be processed
-        model: The Pydantic model class for the response
-        agent: The agent with LLM
-        llm: The LLM instance or model name
-    """
-
-    def __init__(
-        self,
-        content: str,
-        model: type[T],
-        agent: Agent | None = None,
-        llm: LLM | BaseLLM | str | None = None,
-    ) -> None:
-        """Initialize InternalInstructor.
-
-        Args:
-            content: The content to be processed
-            model: The Pydantic model class for the response
-            agent: The agent with LLM
-            llm: The LLM instance or model name
-        """
-        self.content = content
-        self.agent = agent
-        self.model = model
-        self.llm = llm or (agent.function_calling_llm or agent.llm if agent else None)
-
-        with suppress_warnings():
-            import instructor
-            from litellm import completion
-
-            self._client = instructor.from_litellm(completion)
-
-    def to_json(self) -> str:
-        """Convert the structured output to JSON format.
-
-        Returns:
-            JSON string representation of the structured output
-        """
-        pydantic_model = self.to_pydantic()
-        return pydantic_model.model_dump_json(indent=2)
-
-    def to_pydantic(self) -> T:
-        """Generate structured output using the specified Pydantic model.
-
-        Returns:
-            Instance of the specified Pydantic model with structured data
-
-        Raises:
-            ValueError: If LLM is not provided or invalid
-        """
-        messages: list[LLMMessage] = [{"role": "user", "content": self.content}]
-
-        if not _is_valid_llm(self.llm):
-            raise ValueError(
-                "LLM must be provided and have a model attribute or be a string"
-            )
-
-        if isinstance(self.llm, str):
-            model_name = self.llm
-        else:
-            model_name = self.llm.model
-
-        return self._client.chat.completions.create(
-            model=model_name, response_model=self.model, messages=messages
-        )

lib/crewai/src/crewai/utilities/logger.py

@@ -1,35 +0,0 @@
-from datetime import datetime
-
-from pydantic import BaseModel, Field, PrivateAttr
-
-from crewai.utilities.printer import ColoredText, Printer, PrinterColor
-
-
-class Logger(BaseModel):
-    verbose: bool = Field(
-        default=False,
-        description="Enables verbose logging with timestamps",
-    )
-    default_color: PrinterColor = Field(
-        default="bold_yellow",
-        description="Default color for log messages",
-    )
-    _printer: Printer = PrivateAttr(default_factory=Printer)
-
-    def log(self, level: str, message: str, color: PrinterColor | None = None) -> None:
-        """Log a message with timestamp if verbose mode is enabled.
-
-        Args:
-            level: The log level (e.g., 'info', 'warning', 'error').
-            message: The message to log.
-            color: Optional color for the message. Defaults to default_color.
-        """
-        if self.verbose:
-            timestamp: str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            self._printer.print(
-                [
-                    ColoredText(f"\n[{timestamp}]", "cyan"),
-                    ColoredText(f"[{level.upper()}]: ", "yellow"),
-                    ColoredText(message, color or self.default_color),
-                ]
-            )