feat: add OceanBase vector search tool with lazy distance function loading

Add OceanBaseVectorSearchTool for vector similarity search on OceanBase database.
Includes a fix to use lazy loading for distance functions - only the requested
distance function is loaded via getattr, avoiding failures when other distance
functions may not exist in the pyobvector package.

.env.test

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

docs/docs.json

@@ -440,6 +440,7 @@
                   "en/enterprise/guides/build-crew",
                   "en/enterprise/guides/prepare-for-deployment",
                   "en/enterprise/guides/deploy-to-amp",
+                  "en/enterprise/guides/private-package-registry",
                   "en/enterprise/guides/kickoff-crew",
                   "en/enterprise/guides/update-crew",
                   "en/enterprise/guides/enable-crew-studio",
@@ -878,6 +879,7 @@
                   "pt-BR/enterprise/guides/build-crew",
                   "pt-BR/enterprise/guides/prepare-for-deployment",
                   "pt-BR/enterprise/guides/deploy-to-amp",
+                  "pt-BR/enterprise/guides/private-package-registry",
                   "pt-BR/enterprise/guides/kickoff-crew",
                   "pt-BR/enterprise/guides/update-crew",
                   "pt-BR/enterprise/guides/enable-crew-studio",
@@ -1343,6 +1345,7 @@
                   "ko/enterprise/guides/build-crew",
                   "ko/enterprise/guides/prepare-for-deployment",
                   "ko/enterprise/guides/deploy-to-amp",
+                  "ko/enterprise/guides/private-package-registry",
                   "ko/enterprise/guides/kickoff-crew",
                   "ko/enterprise/guides/update-crew",
                   "ko/enterprise/guides/enable-crew-studio",

docs/en/concepts/llms.mdx

@@ -470,7 +470,7 @@ In this section, you'll find detailed examples that help you select, configure,
       To get an Express mode API key:
       - New Google Cloud users: Get an [express mode API key](https://cloud.google.com/vertex-ai/generative-ai/docs/start/quickstart?usertype=apikey)
       - Existing Google Cloud users: Get a [Google Cloud API key bound to a service account](https://cloud.google.com/docs/authentication/api-keys)
-      
+
       For more details, see the [Vertex AI Express mode documentation](https://docs.cloud.google.com/vertex-ai/generative-ai/docs/start/quickstart?usertype=apikey).
     </Info>
 
@@ -652,6 +652,7 @@ In this section, you'll find detailed examples that help you select, configure,
     # Optional
     AWS_SESSION_TOKEN=<your-session-token>  # For temporary credentials
     AWS_DEFAULT_REGION=<your-region>  # Defaults to us-east-1
+    AWS_REGION_NAME=<your-region>  # Alternative configuration for backwards compatibility with LiteLLM. Defaults to us-east-1
     ```
 
     **Basic Usage:**
@@ -695,6 +696,7 @@ In this section, you'll find detailed examples that help you select, configure,
     - `AWS_SECRET_ACCESS_KEY`: AWS secret key (required)
     - `AWS_SESSION_TOKEN`: AWS session token for temporary credentials (optional)
     - `AWS_DEFAULT_REGION`: AWS region (defaults to `us-east-1`)
+    - `AWS_REGION_NAME`: AWS region (defaults to `us-east-1`). Alternative configuration for backwards compatibility with LiteLLM
 
     **Features:**
     - Native tool calling support via Converse API

docs/en/enterprise/guides/deploy-to-amp.mdx

@@ -177,6 +177,11 @@ You need to push your crew to a GitHub repository. If you haven't created a crew
       ![Set Environment Variables](/images/enterprise/set-env-variables.png)
     </Frame>
 
+    <Info>
+      Using private Python packages? You'll need to add your registry credentials here too.
+      See [Private Package Registries](/en/enterprise/guides/private-package-registry) for the required variables.
+    </Info>
+
   </Step>
 
   <Step title="Deploy Your Crew">

docs/en/enterprise/guides/prepare-for-deployment.mdx

@@ -256,6 +256,12 @@ Before deployment, ensure you have:
 1. **LLM API keys** ready (OpenAI, Anthropic, Google, etc.)
 2. **Tool API keys** if using external tools (Serper, etc.)
 
+<Info>
+  If your project depends on packages from a **private PyPI registry**, you'll also need to configure
+  registry authentication credentials as environment variables. See the
+  [Private Package Registries](/en/enterprise/guides/private-package-registry) guide for details.
+</Info>
+
 <Tip>
   Test your project locally with the same environment variables before deploying
   to catch configuration issues early.

docs/en/enterprise/guides/private-package-registry.mdx

@@ -0,0 +1,263 @@
+---
+title: "Private Package Registries"
+description: "Install private Python packages from authenticated PyPI registries in CrewAI AMP"
+icon: "lock"
+mode: "wide"
+---
+
+<Note>
+  This guide covers how to configure your CrewAI project to install Python packages
+  from private PyPI registries (Azure DevOps Artifacts, GitHub Packages, GitLab, AWS CodeArtifact, etc.)
+  when deploying to CrewAI AMP.
+</Note>
+
+## When You Need This
+
+If your project depends on internal or proprietary Python packages hosted on a private registry
+rather than the public PyPI, you'll need to:
+
+1. Tell UV **where** to find the package (an index URL)
+2. Tell UV **which** packages come from that index (a source mapping)
+3. Provide **credentials** so UV can authenticate during install
+
+CrewAI AMP uses [UV](https://docs.astral.sh/uv/) for dependency resolution and installation.
+UV supports authenticated private registries through `pyproject.toml` configuration combined
+with environment variables for credentials.
+
+## Step 1: Configure pyproject.toml
+
+Three pieces work together in your `pyproject.toml`:
+
+### 1a. Declare the dependency
+
+Add the private package to your `[project.dependencies]` like any other dependency:
+
+```toml
+[project]
+dependencies = [
+    "crewai[tools]>=0.100.1,<1.0.0",
+    "my-private-package>=1.2.0",
+]
+```
+
+### 1b. Define the index
+
+Register your private registry as a named index under `[[tool.uv.index]]`:
+
+```toml
+[[tool.uv.index]]
+name = "my-private-registry"
+url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
+explicit = true
+```
+
+<Info>
+  The `name` field is important — UV uses it to construct the environment variable names
+  for authentication (see [Step 2](#step-2-set-authentication-credentials) below).
+
+  Setting `explicit = true` means UV won't search this index for every package — only the
+  ones you explicitly map to it in `[tool.uv.sources]`. This avoids unnecessary queries
+  against your private registry and protects against dependency confusion attacks.
+</Info>
+
+### 1c. Map the package to the index
+
+Tell UV which packages should be resolved from your private index using `[tool.uv.sources]`:
+
+```toml
+[tool.uv.sources]
+my-private-package = { index = "my-private-registry" }
+```
+
+### Complete example
+
+```toml
+[project]
+name = "my-crew-project"
+version = "0.1.0"
+requires-python = ">=3.10,<=3.13"
+dependencies = [
+    "crewai[tools]>=0.100.1,<1.0.0",
+    "my-private-package>=1.2.0",
+]
+
+[tool.crewai]
+type = "crew"
+
+[[tool.uv.index]]
+name = "my-private-registry"
+url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
+explicit = true
+
+[tool.uv.sources]
+my-private-package = { index = "my-private-registry" }
+```
+
+After updating `pyproject.toml`, regenerate your lock file:
+
+```bash
+uv lock
+```
+
+<Warning>
+  Always commit the updated `uv.lock` along with your `pyproject.toml` changes.
+  The lock file is required for deployment — see [Prepare for Deployment](/en/enterprise/guides/prepare-for-deployment).
+</Warning>
+
+## Step 2: Set Authentication Credentials
+
+UV authenticates against private indexes using environment variables that follow a naming convention
+based on the index name you defined in `pyproject.toml`:
+
+```
+UV_INDEX_{UPPER_NAME}_USERNAME
+UV_INDEX_{UPPER_NAME}_PASSWORD
+```
+
+Where `{UPPER_NAME}` is your index name converted to **uppercase** with **hyphens replaced by underscores**.
+
+For example, an index named `my-private-registry` uses:
+
+| Variable | Value |
+|----------|-------|
+| `UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME` | Your registry username or token name |
+| `UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD` | Your registry password or token/PAT |
+
+<Warning>
+  These environment variables **must** be added via the CrewAI AMP **Environment Variables** settings —
+  either globally or at the deployment level. They cannot be set in `.env` files or hardcoded in your project.
+
+  See [Setting Environment Variables in AMP](#setting-environment-variables-in-amp) below.
+</Warning>
+
+## Registry Provider Reference
+
+The table below shows the index URL format and credential values for common registry providers.
+Replace placeholder values with your actual organization and feed details.
+
+| Provider | Index URL | Username | Password |
+|----------|-----------|----------|----------|
+| **Azure DevOps Artifacts** | `https://pkgs.dev.azure.com/{org}/_packaging/{feed}/pypi/simple/` | Any non-empty string (e.g. `token`) | Personal Access Token (PAT) with Packaging Read scope |
+| **GitHub Packages** | `https://pypi.pkg.github.com/{owner}/simple/` | GitHub username | Personal Access Token (classic) with `read:packages` scope |
+| **GitLab Package Registry** | `https://gitlab.com/api/v4/projects/{project_id}/packages/pypi/simple/` | `__token__` | Project or Personal Access Token with `read_api` scope |
+| **AWS CodeArtifact** | Use the URL from `aws codeartifact get-repository-endpoint` | `aws` | Token from `aws codeartifact get-authorization-token` |
+| **Google Artifact Registry** | `https://{region}-python.pkg.dev/{project}/{repo}/simple/` | `_json_key_base64` | Base64-encoded service account key |
+| **JFrog Artifactory** | `https://{instance}.jfrog.io/artifactory/api/pypi/{repo}/simple/` | Username or email | API key or identity token |
+| **Self-hosted (devpi, Nexus, etc.)** | Your registry's simple API URL | Registry username | Registry password |
+
+<Tip>
+  For **AWS CodeArtifact**, the authorization token expires periodically.
+  You'll need to refresh the `UV_INDEX_*_PASSWORD` value when it expires.
+  Consider automating this in your CI/CD pipeline.
+</Tip>
+
+## Setting Environment Variables in AMP
+
+Private registry credentials must be configured as environment variables in CrewAI AMP.
+You have two options:
+
+<Tabs>
+  <Tab title="Web Interface">
+    1. Log in to [CrewAI AMP](https://app.crewai.com)
+    2. Navigate to your automation
+    3. Open the **Environment Variables** tab
+    4. Add each variable (`UV_INDEX_*_USERNAME` and `UV_INDEX_*_PASSWORD`) with its value
+
+    See the [Deploy to AMP — Set Environment Variables](/en/enterprise/guides/deploy-to-amp#set-environment-variables) step for details.
+  </Tab>
+  <Tab title="CLI Deployment">
+    Add the variables to your local `.env` file before running `crewai deploy create`.
+    The CLI will securely transfer them to the platform:
+
+    ```bash
+    # .env
+    OPENAI_API_KEY=sk-...
+    UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
+    UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat-here
+    ```
+
+    ```bash
+    crewai deploy create
+    ```
+  </Tab>
+</Tabs>
+
+<Warning>
+  **Never** commit credentials to your repository. Use AMP environment variables for all secrets.
+  The `.env` file should be listed in `.gitignore`.
+</Warning>
+
+To update credentials on an existing deployment, see [Update Your Crew — Environment Variables](/en/enterprise/guides/update-crew).
+
+## How It All Fits Together
+
+When CrewAI AMP builds your automation, the resolution flow works like this:
+
+<Steps>
+  <Step title="Build starts">
+    AMP pulls your repository and reads `pyproject.toml` and `uv.lock`.
+  </Step>
+  <Step title="UV resolves dependencies">
+    UV reads `[tool.uv.sources]` to determine which index each package should come from.
+  </Step>
+  <Step title="UV authenticates">
+    For each private index, UV looks up `UV_INDEX_{NAME}_USERNAME` and `UV_INDEX_{NAME}_PASSWORD`
+    from the environment variables you configured in AMP.
+  </Step>
+  <Step title="Packages install">
+    UV downloads and installs all packages — both public (from PyPI) and private (from your registry).
+  </Step>
+  <Step title="Automation runs">
+    Your crew or flow starts with all dependencies available.
+  </Step>
+</Steps>
+
+## Troubleshooting
+
+### Authentication Errors During Build
+
+**Symptom**: Build fails with `401 Unauthorized` or `403 Forbidden` when resolving a private package.
+
+**Check**:
+- The `UV_INDEX_*` environment variable names match your index name exactly (uppercased, hyphens → underscores)
+- Credentials are set in AMP environment variables, not just in a local `.env`
+- Your token/PAT has the required read permissions for the package feed
+- The token hasn't expired (especially relevant for AWS CodeArtifact)
+
+### Package Not Found
+
+**Symptom**: `No matching distribution found for my-private-package`.
+
+**Check**:
+- The index URL in `pyproject.toml` ends with `/simple/`
+- The `[tool.uv.sources]` entry maps the correct package name to the correct index name
+- The package is actually published to your private registry
+- Run `uv lock` locally with the same credentials to verify resolution works
+
+### Lock File Conflicts
+
+**Symptom**: `uv lock` fails or produces unexpected results after adding a private index.
+
+**Solution**: Set the credentials locally and regenerate:
+
+```bash
+export UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
+export UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat
+uv lock
+```
+
+Then commit the updated `uv.lock`.
+
+## Related Guides
+
+<CardGroup cols={3}>
+  <Card title="Prepare for Deployment" icon="clipboard-check" href="/en/enterprise/guides/prepare-for-deployment">
+    Verify project structure and dependencies before deploying.
+  </Card>
+  <Card title="Deploy to AMP" icon="rocket" href="/en/enterprise/guides/deploy-to-amp">
+    Deploy your crew or flow and configure environment variables.
+  </Card>
+  <Card title="Update Your Crew" icon="arrows-rotate" href="/en/enterprise/guides/update-crew">
+    Update environment variables and push changes to a running deployment.
+  </Card>
+</CardGroup>

docs/ko/enterprise/guides/deploy-to-amp.mdx

@@ -176,6 +176,11 @@ Crew를 GitHub 저장소에 푸시해야 합니다. 아직 Crew를 만들지 않
       ![Set Environment Variables](/images/enterprise/set-env-variables.png)
     </Frame>
 
+    <Info>
+      프라이빗 Python 패키지를 사용하시나요? 여기에 레지스트리 자격 증명도 추가해야 합니다.
+      필요한 변수는 [프라이빗 패키지 레지스트리](/ko/enterprise/guides/private-package-registry)를 참조하세요.
+    </Info>
+
   </Step>
 
   <Step title="Crew 배포하기">

docs/ko/enterprise/guides/prepare-for-deployment.mdx

@@ -256,6 +256,12 @@ Crews와 Flows 모두 `src/project_name/main.py`에 진입점이 있습니다:
 1. **LLM API 키** (OpenAI, Anthropic, Google 등)
 2. **도구 API 키** - 외부 도구를 사용하는 경우 (Serper 등)
 
+<Info>
+  프로젝트가 **프라이빗 PyPI 레지스트리**의 패키지에 의존하는 경우, 레지스트리 인증 자격 증명도
+  환경 변수로 구성해야 합니다. 자세한 내용은
+  [프라이빗 패키지 레지스트리](/ko/enterprise/guides/private-package-registry) 가이드를 참조하세요.
+</Info>
+
 <Tip>
   구성 문제를 조기에 발견하기 위해 배포 전에 동일한 환경 변수로
   로컬에서 프로젝트를 테스트하세요.

docs/ko/enterprise/guides/private-package-registry.mdx

@@ -0,0 +1,261 @@
+---
+title: "프라이빗 패키지 레지스트리"
+description: "CrewAI AMP에서 인증된 PyPI 레지스트리의 프라이빗 Python 패키지 설치하기"
+icon: "lock"
+mode: "wide"
+---
+
+<Note>
+  이 가이드는 CrewAI AMP에 배포할 때 프라이빗 PyPI 레지스트리(Azure DevOps Artifacts, GitHub Packages,
+  GitLab, AWS CodeArtifact 등)에서 Python 패키지를 설치하도록 CrewAI 프로젝트를 구성하는 방법을 다룹니다.
+</Note>
+
+## 이 가이드가 필요한 경우
+
+프로젝트가 공개 PyPI가 아닌 프라이빗 레지스트리에 호스팅된 내부 또는 독점 Python 패키지에
+의존하는 경우, 다음을 수행해야 합니다:
+
+1. UV에 패키지를 **어디서** 찾을지 알려줍니다 (index URL)
+2. UV에 **어떤** 패키지가 해당 index에서 오는지 알려줍니다 (source 매핑)
+3. UV가 설치 중에 인증할 수 있도록 **자격 증명**을 제공합니다
+
+CrewAI AMP는 의존성 해결 및 설치에 [UV](https://docs.astral.sh/uv/)를 사용합니다.
+UV는 `pyproject.toml` 구성과 자격 증명용 환경 변수를 결합하여 인증된 프라이빗 레지스트리를 지원합니다.
+
+## 1단계: pyproject.toml 구성
+
+`pyproject.toml`에서 세 가지 요소가 함께 작동합니다:
+
+### 1a. 의존성 선언
+
+프라이빗 패키지를 다른 의존성과 마찬가지로 `[project.dependencies]`에 추가합니다:
+
+```toml
+[project]
+dependencies = [
+    "crewai[tools]>=0.100.1,<1.0.0",
+    "my-private-package>=1.2.0",
+]
+```
+
+### 1b. index 정의
+
+프라이빗 레지스트리를 `[[tool.uv.index]]` 아래에 명명된 index로 등록합니다:
+
+```toml
+[[tool.uv.index]]
+name = "my-private-registry"
+url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
+explicit = true
+```
+
+<Info>
+  `name` 필드는 중요합니다 — UV는 이를 사용하여 인증을 위한 환경 변수 이름을
+  구성합니다 (아래 [2단계](#2단계-인증-자격-증명-설정)를 참조하세요).
+
+  `explicit = true`를 설정하면 UV가 모든 패키지에 대해 이 index를 검색하지 않습니다 —
+  `[tool.uv.sources]`에서 명시적으로 매핑한 패키지만 검색합니다. 이렇게 하면 프라이빗
+  레지스트리에 대한 불필요한 쿼리를 방지하고 의존성 혼동 공격을 차단할 수 있습니다.
+</Info>
+
+### 1c. 패키지를 index에 매핑
+
+`[tool.uv.sources]`를 사용하여 프라이빗 index에서 해결해야 할 패키지를 UV에 알려줍니다:
+
+```toml
+[tool.uv.sources]
+my-private-package = { index = "my-private-registry" }
+```
+
+### 전체 예시
+
+```toml
+[project]
+name = "my-crew-project"
+version = "0.1.0"
+requires-python = ">=3.10,<=3.13"
+dependencies = [
+    "crewai[tools]>=0.100.1,<1.0.0",
+    "my-private-package>=1.2.0",
+]
+
+[tool.crewai]
+type = "crew"
+
+[[tool.uv.index]]
+name = "my-private-registry"
+url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
+explicit = true
+
+[tool.uv.sources]
+my-private-package = { index = "my-private-registry" }
+```
+
+`pyproject.toml`을 업데이트한 후 lock 파일을 다시 생성합니다:
+
+```bash
+uv lock
+```
+
+<Warning>
+  업데이트된 `uv.lock`을 항상 `pyproject.toml` 변경 사항과 함께 커밋하세요.
+  lock 파일은 배포에 필수입니다 — [배포 준비하기](/ko/enterprise/guides/prepare-for-deployment)를 참조하세요.
+</Warning>
+
+## 2단계: 인증 자격 증명 설정
+
+UV는 `pyproject.toml`에서 정의한 index 이름을 기반으로 한 명명 규칙을 따르는
+환경 변수를 사용하여 프라이빗 index에 인증합니다:
+
+```
+UV_INDEX_{UPPER_NAME}_USERNAME
+UV_INDEX_{UPPER_NAME}_PASSWORD
+```
+
+여기서 `{UPPER_NAME}`은 index 이름을 **대문자**로 변환하고 **하이픈을 언더스코어로 대체**한 것입니다.
+
+예를 들어, `my-private-registry`라는 이름의 index는 다음을 사용합니다:
+
+| 변수 | 값 |
+|------|-----|
+| `UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME` | 레지스트리 사용자 이름 또는 토큰 이름 |
+| `UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD` | 레지스트리 비밀번호 또는 토큰/PAT |
+
+<Warning>
+  이 환경 변수는 CrewAI AMP **환경 변수** 설정을 통해 **반드시** 추가해야 합니다 —
+  전역적으로 또는 배포 수준에서. `.env` 파일에 설정하거나 프로젝트에 하드코딩할 수 없습니다.
+
+  아래 [AMP에서 환경 변수 설정](#amp에서-환경-변수-설정)을 참조하세요.
+</Warning>
+
+## 레지스트리 제공업체 참조
+
+아래 표는 일반적인 레지스트리 제공업체의 index URL 형식과 자격 증명 값을 보여줍니다.
+자리 표시자 값을 실제 조직 및 피드 세부 정보로 대체하세요.
+
+| 제공업체 | Index URL | 사용자 이름 | 비밀번호 |
+|---------|-----------|-----------|---------|
+| **Azure DevOps Artifacts** | `https://pkgs.dev.azure.com/{org}/_packaging/{feed}/pypi/simple/` | 비어 있지 않은 임의의 문자열 (예: `token`) | Packaging Read 범위의 Personal Access Token (PAT) |
+| **GitHub Packages** | `https://pypi.pkg.github.com/{owner}/simple/` | GitHub 사용자 이름 | `read:packages` 범위의 Personal Access Token (classic) |
+| **GitLab Package Registry** | `https://gitlab.com/api/v4/projects/{project_id}/packages/pypi/simple/` | `__token__` | `read_api` 범위의 Project 또는 Personal Access Token |
+| **AWS CodeArtifact** | `aws codeartifact get-repository-endpoint`의 URL 사용 | `aws` | `aws codeartifact get-authorization-token`의 토큰 |
+| **Google Artifact Registry** | `https://{region}-python.pkg.dev/{project}/{repo}/simple/` | `_json_key_base64` | Base64로 인코딩된 서비스 계정 키 |
+| **JFrog Artifactory** | `https://{instance}.jfrog.io/artifactory/api/pypi/{repo}/simple/` | 사용자 이름 또는 이메일 | API 키 또는 ID 토큰 |
+| **자체 호스팅 (devpi, Nexus 등)** | 레지스트리의 simple API URL | 레지스트리 사용자 이름 | 레지스트리 비밀번호 |
+
+<Tip>
+  **AWS CodeArtifact**의 경우 인증 토큰이 주기적으로 만료됩니다.
+  만료되면 `UV_INDEX_*_PASSWORD` 값을 갱신해야 합니다.
+  CI/CD 파이프라인에서 이를 자동화하는 것을 고려하세요.
+</Tip>
+
+## AMP에서 환경 변수 설정
+
+프라이빗 레지스트리 자격 증명은 CrewAI AMP에서 환경 변수로 구성해야 합니다.
+두 가지 옵션이 있습니다:
+
+<Tabs>
+  <Tab title="웹 인터페이스">
+    1. [CrewAI AMP](https://app.crewai.com)에 로그인합니다
+    2. 자동화로 이동합니다
+    3. **Environment Variables** 탭을 엽니다
+    4. 각 변수 (`UV_INDEX_*_USERNAME` 및 `UV_INDEX_*_PASSWORD`)에 값을 추가합니다
+
+    자세한 내용은 [AMP에 배포하기 — 환경 변수 설정하기](/ko/enterprise/guides/deploy-to-amp#환경-변수-설정하기) 단계를 참조하세요.
+  </Tab>
+  <Tab title="CLI 배포">
+    `crewai deploy create`를 실행하기 전에 로컬 `.env` 파일에 변수를 추가합니다.
+    CLI가 이를 안전하게 플랫폼으로 전송합니다:
+
+    ```bash
+    # .env
+    OPENAI_API_KEY=sk-...
+    UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
+    UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat-here
+    ```
+
+    ```bash
+    crewai deploy create
+    ```
+  </Tab>
+</Tabs>
+
+<Warning>
+  자격 증명을 저장소에 **절대** 커밋하지 마세요. 모든 비밀 정보에는 AMP 환경 변수를 사용하세요.
+  `.env` 파일은 `.gitignore`에 포함되어야 합니다.
+</Warning>
+
+기존 배포의 자격 증명을 업데이트하려면 [Crew 업데이트하기 — 환경 변수](/ko/enterprise/guides/update-crew)를 참조하세요.
+
+## 전체 동작 흐름
+
+CrewAI AMP가 자동화를 빌드할 때, 해결 흐름은 다음과 같이 작동합니다:
+
+<Steps>
+  <Step title="빌드 시작">
+    AMP가 저장소를 가져오고 `pyproject.toml`과 `uv.lock`을 읽습니다.
+  </Step>
+  <Step title="UV가 의존성 해결">
+    UV가 `[tool.uv.sources]`를 읽어 각 패키지가 어떤 index에서 와야 하는지 결정합니다.
+  </Step>
+  <Step title="UV가 인증">
+    각 프라이빗 index에 대해 UV가 AMP에서 구성한 환경 변수에서
+    `UV_INDEX_{NAME}_USERNAME`과 `UV_INDEX_{NAME}_PASSWORD`를 조회합니다.
+  </Step>
+  <Step title="패키지 설치">
+    UV가 공개(PyPI) 및 프라이빗(레지스트리) 패키지를 모두 다운로드하고 설치합니다.
+  </Step>
+  <Step title="자동화 실행">
+    모든 의존성이 사용 가능한 상태에서 crew 또는 flow가 시작됩니다.
+  </Step>
+</Steps>
+
+## 문제 해결
+
+### 빌드 중 인증 오류
+
+**증상**: 프라이빗 패키지를 해결할 때 `401 Unauthorized` 또는 `403 Forbidden`으로 빌드가 실패합니다.
+
+**확인사항**:
+- `UV_INDEX_*` 환경 변수 이름이 index 이름과 정확히 일치하는지 확인합니다 (대문자, 하이픈 -> 언더스코어)
+- 자격 증명이 로컬 `.env`뿐만 아니라 AMP 환경 변수에 설정되어 있는지 확인합니다
+- 토큰/PAT에 패키지 피드에 필요한 읽기 권한이 있는지 확인합니다
+- 토큰이 만료되지 않았는지 확인합니다 (특히 AWS CodeArtifact의 경우)
+
+### 패키지를 찾을 수 없음
+
+**증상**: `No matching distribution found for my-private-package`.
+
+**확인사항**:
+- `pyproject.toml`의 index URL이 `/simple/`로 끝나는지 확인합니다
+- `[tool.uv.sources]` 항목이 올바른 패키지 이름을 올바른 index 이름에 매핑하는지 확인합니다
+- 패키지가 실제로 프라이빗 레지스트리에 게시되어 있는지 확인합니다
+- 동일한 자격 증명으로 로컬에서 `uv lock`을 실행하여 해결이 작동하는지 확인합니다
+
+### Lock 파일 충돌
+
+**증상**: 프라이빗 index를 추가한 후 `uv lock`이 실패하거나 예상치 못한 결과를 생성합니다.
+
+**해결책**: 로컬에서 자격 증명을 설정하고 다시 생성합니다:
+
+```bash
+export UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
+export UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat
+uv lock
+```
+
+그런 다음 업데이트된 `uv.lock`을 커밋합니다.
+
+## 관련 가이드
+
+<CardGroup cols={3}>
+  <Card title="배포 준비하기" icon="clipboard-check" href="/ko/enterprise/guides/prepare-for-deployment">
+    배포 전에 프로젝트 구조와 의존성을 확인합니다.
+  </Card>
+  <Card title="AMP에 배포하기" icon="rocket" href="/ko/enterprise/guides/deploy-to-amp">
+    crew 또는 flow를 배포하고 환경 변수를 구성합니다.
+  </Card>
+  <Card title="Crew 업데이트하기" icon="arrows-rotate" href="/ko/enterprise/guides/update-crew">
+    환경 변수를 업데이트하고 실행 중인 배포에 변경 사항을 푸시합니다.
+  </Card>
+</CardGroup>

docs/pt-BR/enterprise/guides/deploy-to-amp.mdx

@@ -176,6 +176,11 @@ Você precisa enviar seu crew para um repositório do GitHub. Caso ainda não te
       ![Definir Variáveis de Ambiente](/images/enterprise/set-env-variables.png)
     </Frame>
 
+    <Info>
+      Usando pacotes Python privados? Você também precisará adicionar suas credenciais de registro aqui.
+      Consulte [Registros de Pacotes Privados](/pt-BR/enterprise/guides/private-package-registry) para as variáveis necessárias.
+    </Info>
+
   </Step>
 
   <Step title="Implante Seu Crew">

docs/pt-BR/enterprise/guides/prepare-for-deployment.mdx

@@ -256,6 +256,12 @@ Antes da implantação, certifique-se de ter:
 1. **Chaves de API de LLM** prontas (OpenAI, Anthropic, Google, etc.)
 2. **Chaves de API de ferramentas** se estiver usando ferramentas externas (Serper, etc.)
 
+<Info>
+  Se seu projeto depende de pacotes de um **registro PyPI privado**, você também precisará configurar
+  credenciais de autenticação do registro como variáveis de ambiente. Consulte o guia
+  [Registros de Pacotes Privados](/pt-BR/enterprise/guides/private-package-registry) para mais detalhes.
+</Info>
+
 <Tip>
   Teste seu projeto localmente com as mesmas variáveis de ambiente antes de implantar
   para detectar problemas de configuração antecipadamente.

docs/pt-BR/enterprise/guides/private-package-registry.mdx

@@ -0,0 +1,263 @@
+---
+title: "Registros de Pacotes Privados"
+description: "Instale pacotes Python privados de registros PyPI autenticados no CrewAI AMP"
+icon: "lock"
+mode: "wide"
+---
+
+<Note>
+  Este guia aborda como configurar seu projeto CrewAI para instalar pacotes Python
+  de registros PyPI privados (Azure DevOps Artifacts, GitHub Packages, GitLab, AWS CodeArtifact, etc.)
+  ao implantar no CrewAI AMP.
+</Note>
+
+## Quando Você Precisa Disso
+
+Se seu projeto depende de pacotes Python internos ou proprietários hospedados em um registro privado
+em vez do PyPI público, você precisará:
+
+1. Informar ao UV **onde** encontrar o pacote (uma URL de index)
+2. Informar ao UV **quais** pacotes vêm desse index (um mapeamento de source)
+3. Fornecer **credenciais** para que o UV possa autenticar durante a instalação
+
+O CrewAI AMP usa [UV](https://docs.astral.sh/uv/) para resolução e instalação de dependências.
+O UV suporta registros privados autenticados por meio da configuração do `pyproject.toml` combinada
+com variáveis de ambiente para credenciais.
+
+## Passo 1: Configurar o pyproject.toml
+
+Três elementos trabalham juntos no seu `pyproject.toml`:
+
+### 1a. Declarar a dependência
+
+Adicione o pacote privado ao seu `[project.dependencies]` como qualquer outra dependência:
+
+```toml
+[project]
+dependencies = [
+    "crewai[tools]>=0.100.1,<1.0.0",
+    "my-private-package>=1.2.0",
+]
+```
+
+### 1b. Definir o index
+
+Registre seu registro privado como um index nomeado em `[[tool.uv.index]]`:
+
+```toml
+[[tool.uv.index]]
+name = "my-private-registry"
+url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
+explicit = true
+```
+
+<Info>
+  O campo `name` é importante — o UV o utiliza para construir os nomes das variáveis de ambiente
+  para autenticação (veja o [Passo 2](#passo-2-configurar-credenciais-de-autenticação) abaixo).
+
+  Definir `explicit = true` significa que o UV não consultará esse index para todos os pacotes — apenas
+  os que você mapear explicitamente em `[tool.uv.sources]`. Isso evita consultas desnecessárias
+  ao seu registro privado e protege contra ataques de confusão de dependências.
+</Info>
+
+### 1c. Mapear o pacote para o index
+
+Informe ao UV quais pacotes devem ser resolvidos a partir do seu index privado usando `[tool.uv.sources]`:
+
+```toml
+[tool.uv.sources]
+my-private-package = { index = "my-private-registry" }
+```
+
+### Exemplo completo
+
+```toml
+[project]
+name = "my-crew-project"
+version = "0.1.0"
+requires-python = ">=3.10,<=3.13"
+dependencies = [
+    "crewai[tools]>=0.100.1,<1.0.0",
+    "my-private-package>=1.2.0",
+]
+
+[tool.crewai]
+type = "crew"
+
+[[tool.uv.index]]
+name = "my-private-registry"
+url = "https://pkgs.dev.azure.com/my-org/_packaging/my-feed/pypi/simple/"
+explicit = true
+
+[tool.uv.sources]
+my-private-package = { index = "my-private-registry" }
+```
+
+Após atualizar o `pyproject.toml`, regenere seu arquivo lock:
+
+```bash
+uv lock
+```
+
+<Warning>
+  Sempre faça commit do `uv.lock` atualizado junto com as alterações no `pyproject.toml`.
+  O arquivo lock é obrigatório para implantação — veja [Preparar para Implantação](/pt-BR/enterprise/guides/prepare-for-deployment).
+</Warning>
+
+## Passo 2: Configurar Credenciais de Autenticação
+
+O UV autentica em indexes privados usando variáveis de ambiente que seguem uma convenção de nomenclatura
+baseada no nome do index que você definiu no `pyproject.toml`:
+
+```
+UV_INDEX_{UPPER_NAME}_USERNAME
+UV_INDEX_{UPPER_NAME}_PASSWORD
+```
+
+Onde `{UPPER_NAME}` é o nome do seu index convertido para **maiúsculas** com **hifens substituídos por underscores**.
+
+Por exemplo, um index chamado `my-private-registry` usa:
+
+| Variável | Valor |
+|----------|-------|
+| `UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME` | Seu nome de usuário ou nome do token do registro |
+| `UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD` | Sua senha ou token/PAT do registro |
+
+<Warning>
+  Essas variáveis de ambiente **devem** ser adicionadas pelas configurações de **Variáveis de Ambiente** do CrewAI AMP —
+  globalmente ou no nível da implantação. Elas não podem ser definidas em arquivos `.env` ou codificadas no seu projeto.
+
+  Veja [Configurar Variáveis de Ambiente no AMP](#configurar-variáveis-de-ambiente-no-amp) abaixo.
+</Warning>
+
+## Referência de Provedores de Registro
+
+A tabela abaixo mostra o formato da URL de index e os valores de credenciais para provedores de registro comuns.
+Substitua os valores de exemplo pelos detalhes reais da sua organização e feed.
+
+| Provedor | URL do Index | Usuário | Senha |
+|----------|-------------|---------|-------|
+| **Azure DevOps Artifacts** | `https://pkgs.dev.azure.com/{org}/_packaging/{feed}/pypi/simple/` | Qualquer string não vazia (ex: `token`) | Personal Access Token (PAT) com escopo Packaging Read |
+| **GitHub Packages** | `https://pypi.pkg.github.com/{owner}/simple/` | Nome de usuário do GitHub | Personal Access Token (classic) com escopo `read:packages` |
+| **GitLab Package Registry** | `https://gitlab.com/api/v4/projects/{project_id}/packages/pypi/simple/` | `__token__` | Project ou Personal Access Token com escopo `read_api` |
+| **AWS CodeArtifact** | Use a URL de `aws codeartifact get-repository-endpoint` | `aws` | Token de `aws codeartifact get-authorization-token` |
+| **Google Artifact Registry** | `https://{region}-python.pkg.dev/{project}/{repo}/simple/` | `_json_key_base64` | Chave de conta de serviço codificada em Base64 |
+| **JFrog Artifactory** | `https://{instance}.jfrog.io/artifactory/api/pypi/{repo}/simple/` | Nome de usuário ou email | Chave API ou token de identidade |
+| **Auto-hospedado (devpi, Nexus, etc.)** | URL da API simple do seu registro | Nome de usuário do registro | Senha do registro |
+
+<Tip>
+  Para **AWS CodeArtifact**, o token de autorização expira periodicamente.
+  Você precisará atualizar o valor de `UV_INDEX_*_PASSWORD` quando ele expirar.
+  Considere automatizar isso no seu pipeline de CI/CD.
+</Tip>
+
+## Configurar Variáveis de Ambiente no AMP
+
+As credenciais do registro privado devem ser configuradas como variáveis de ambiente no CrewAI AMP.
+Você tem duas opções:
+
+<Tabs>
+  <Tab title="Interface Web">
+    1. Faça login no [CrewAI AMP](https://app.crewai.com)
+    2. Navegue até sua automação
+    3. Abra a aba **Environment Variables**
+    4. Adicione cada variável (`UV_INDEX_*_USERNAME` e `UV_INDEX_*_PASSWORD`) com seu valor
+
+    Veja o passo [Deploy para AMP — Definir Variáveis de Ambiente](/pt-BR/enterprise/guides/deploy-to-amp#definir-as-variáveis-de-ambiente) para detalhes.
+  </Tab>
+  <Tab title="Implantação via CLI">
+    Adicione as variáveis ao seu arquivo `.env` local antes de executar `crewai deploy create`.
+    A CLI as transferirá com segurança para a plataforma:
+
+    ```bash
+    # .env
+    OPENAI_API_KEY=sk-...
+    UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
+    UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat-here
+    ```
+
+    ```bash
+    crewai deploy create
+    ```
+  </Tab>
+</Tabs>
+
+<Warning>
+  **Nunca** faça commit de credenciais no seu repositório. Use variáveis de ambiente do AMP para todos os segredos.
+  O arquivo `.env` deve estar listado no `.gitignore`.
+</Warning>
+
+Para atualizar credenciais em uma implantação existente, veja [Atualizar Seu Crew — Variáveis de Ambiente](/pt-BR/enterprise/guides/update-crew).
+
+## Como Tudo se Conecta
+
+Quando o CrewAI AMP faz o build da sua automação, o fluxo de resolução funciona assim:
+
+<Steps>
+  <Step title="Build inicia">
+    O AMP busca seu repositório e lê o `pyproject.toml` e o `uv.lock`.
+  </Step>
+  <Step title="UV resolve dependências">
+    O UV lê `[tool.uv.sources]` para determinar de qual index cada pacote deve vir.
+  </Step>
+  <Step title="UV autentica">
+    Para cada index privado, o UV busca `UV_INDEX_{NAME}_USERNAME` e `UV_INDEX_{NAME}_PASSWORD`
+    nas variáveis de ambiente que você configurou no AMP.
+  </Step>
+  <Step title="Pacotes são instalados">
+    O UV baixa e instala todos os pacotes — tanto públicos (do PyPI) quanto privados (do seu registro).
+  </Step>
+  <Step title="Automação executa">
+    Seu crew ou flow inicia com todas as dependências disponíveis.
+  </Step>
+</Steps>
+
+## Solução de Problemas
+
+### Erros de Autenticação Durante o Build
+
+**Sintoma**: Build falha com `401 Unauthorized` ou `403 Forbidden` ao resolver um pacote privado.
+
+**Verifique**:
+- Os nomes das variáveis de ambiente `UV_INDEX_*` correspondem exatamente ao nome do seu index (maiúsculas, hifens -> underscores)
+- As credenciais estão definidas nas variáveis de ambiente do AMP, não apenas em um `.env` local
+- Seu token/PAT tem as permissões de leitura necessárias para o feed de pacotes
+- O token não expirou (especialmente relevante para AWS CodeArtifact)
+
+### Pacote Não Encontrado
+
+**Sintoma**: `No matching distribution found for my-private-package`.
+
+**Verifique**:
+- A URL do index no `pyproject.toml` termina com `/simple/`
+- A entrada `[tool.uv.sources]` mapeia o nome correto do pacote para o nome correto do index
+- O pacote está realmente publicado no seu registro privado
+- Execute `uv lock` localmente com as mesmas credenciais para verificar se a resolução funciona
+
+### Conflitos no Arquivo Lock
+
+**Sintoma**: `uv lock` falha ou produz resultados inesperados após adicionar um index privado.
+
+**Solução**: Defina as credenciais localmente e regenere:
+
+```bash
+export UV_INDEX_MY_PRIVATE_REGISTRY_USERNAME=token
+export UV_INDEX_MY_PRIVATE_REGISTRY_PASSWORD=your-pat
+uv lock
+```
+
+Em seguida, faça commit do `uv.lock` atualizado.
+
+## Guias Relacionados
+
+<CardGroup cols={3}>
+  <Card title="Preparar para Implantação" icon="clipboard-check" href="/pt-BR/enterprise/guides/prepare-for-deployment">
+    Verifique a estrutura do projeto e as dependências antes de implantar.
+  </Card>
+  <Card title="Deploy para AMP" icon="rocket" href="/pt-BR/enterprise/guides/deploy-to-amp">
+    Implante seu crew ou flow e configure variáveis de ambiente.
+  </Card>
+  <Card title="Atualizar Seu Crew" icon="arrows-rotate" href="/pt-BR/enterprise/guides/update-crew">
+    Atualize variáveis de ambiente e envie alterações para uma implantação em execução.
+  </Card>
+</CardGroup>

lib/crewai-tools/src/crewai_tools/__init__.py

@@ -98,6 +98,11 @@ from crewai_tools.tools.mongodb_vector_search_tool.vector_search import (
     MongoDBVectorSearchTool,
 )
 from crewai_tools.tools.multion_tool.multion_tool import MultiOnTool
+from crewai_tools.tools.oceanbase_vector_search_tool.oceanbase_vector_search_tool import (
+    OceanBaseToolSchema,
+    OceanBaseVectorSearchConfig,
+    OceanBaseVectorSearchTool,
+)
 from crewai_tools.tools.mysql_search_tool.mysql_search_tool import MySQLSearchTool
 from crewai_tools.tools.nl2sql.nl2sql_tool import NL2SQLTool
 from crewai_tools.tools.ocr_tool.ocr_tool import OCRTool
@@ -243,6 +248,9 @@ __all__ = [
     "MongoDBVectorSearchTool",
     "MultiOnTool",
     "MySQLSearchTool",
+    "OceanBaseToolSchema",
+    "OceanBaseVectorSearchConfig",
+    "OceanBaseVectorSearchTool",
     "NL2SQLTool",
     "OCRTool",
     "OxylabsAmazonProductScraperTool",

lib/crewai-tools/src/crewai_tools/tools/__init__.py

@@ -87,6 +87,11 @@ from crewai_tools.tools.mongodb_vector_search_tool import (
     MongoDBVectorSearchConfig,
     MongoDBVectorSearchTool,
 )
+from crewai_tools.tools.oceanbase_vector_search_tool import (
+    OceanBaseToolSchema,
+    OceanBaseVectorSearchConfig,
+    OceanBaseVectorSearchTool,
+)
 from crewai_tools.tools.multion_tool.multion_tool import MultiOnTool
 from crewai_tools.tools.mysql_search_tool.mysql_search_tool import MySQLSearchTool
 from crewai_tools.tools.nl2sql.nl2sql_tool import NL2SQLTool
@@ -226,6 +231,9 @@ __all__ = [
     "MongoDBVectorSearchConfig",
     "MongoDBVectorSearchTool",
     "MultiOnTool",
+    "OceanBaseToolSchema",
+    "OceanBaseVectorSearchConfig",
+    "OceanBaseVectorSearchTool",
     "MySQLSearchTool",
     "NL2SQLTool",
     "OCRTool",

lib/crewai-tools/src/crewai_tools/tools/oceanbase_vector_search_tool/README.md

@@ -0,0 +1,144 @@
+# OceanBaseVectorSearchTool
+
+## Description
+
+This tool is designed for performing vector similarity searches within an OceanBase database. OceanBase is a distributed relational database developed by Ant Group that supports native vector indexing and search capabilities using HNSW (Hierarchical Navigable Small World) algorithm.
+
+Use this tool to find semantically similar documents to a given query by leveraging OceanBase's vector search functionality.
+
+For more information about OceanBase vector capabilities, see:
+https://en.oceanbase.com/docs/common-oceanbase-database-10000000001976351
+
+## Installation
+
+Install the crewai_tools package with OceanBase support by executing the following command in your terminal:
+
+```shell
+pip install crewai-tools[oceanbase]
+```
+
+or
+
+```shell
+uv add crewai-tools --extra oceanbase
+```
+
+## Example
+
+### Basic Usage
+
+```python
+from crewai_tools import OceanBaseVectorSearchTool
+
+tool = OceanBaseVectorSearchTool(
+    connection_uri="127.0.0.1:2881",
+    user="root@test",
+    password="",
+    db_name="test",
+    table_name="documents",
+)
+```
+
+### With Custom Configuration
+
+```python
+from crewai_tools import OceanBaseVectorSearchConfig, OceanBaseVectorSearchTool
+
+query_config = OceanBaseVectorSearchConfig(
+    limit=10,
+    distance_func="cosine",
+    distance_threshold=0.5,
+)
+
+tool = OceanBaseVectorSearchTool(
+    connection_uri="127.0.0.1:2881",
+    user="root@test",
+    password="your_password",
+    db_name="my_database",
+    table_name="my_documents",
+    vector_column_name="embedding",
+    text_column_name="content",
+    metadata_column_name="metadata",
+    query_config=query_config,
+    embedding_model="text-embedding-3-large",
+    dimensions=3072,
+)
+```
+
+### Adding the Tool to an Agent
+
+```python
+from crewai import Agent
+from crewai_tools import OceanBaseVectorSearchTool
+
+tool = OceanBaseVectorSearchTool(
+    connection_uri="127.0.0.1:2881",
+    user="root@test",
+    db_name="test",
+    table_name="documents",
+)
+
+rag_agent = Agent(
+    name="rag_agent",
+    role="You are a helpful assistant that can answer questions using the OceanBaseVectorSearchTool.",
+    goal="Answer user questions by searching relevant documents",
+    backstory="You have access to a knowledge base stored in OceanBase",
+    llm="gpt-4o-mini",
+    tools=[tool],
+)
+```
+
+### Preloading Documents
+
+```python
+from crewai_tools import OceanBaseVectorSearchTool
+import os
+
+tool = OceanBaseVectorSearchTool(
+    connection_uri="127.0.0.1:2881",
+    user="root@test",
+    db_name="test",
+    table_name="documents",
+)
+
+texts = []
+metadatas = []
+for filename in os.listdir("knowledge"):
+    with open(os.path.join("knowledge", filename), "r") as f:
+        texts.append(f.read())
+        metadatas.append({"source": filename})
+
+tool.add_texts(texts, metadatas=metadatas)
+```
+
+## Configuration Options
+
+### OceanBaseVectorSearchConfig
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `limit` | int | 4 | Number of documents to return |
+| `distance_func` | str | "l2" | Distance function: "l2", "cosine", or "inner_product" |
+| `distance_threshold` | float | None | Only return results with distance <= threshold |
+| `include_embeddings` | bool | False | Whether to include embedding vectors in results |
+
+### OceanBaseVectorSearchTool
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `connection_uri` | str | Yes | OceanBase connection URI (e.g., "127.0.0.1:2881") |
+| `user` | str | Yes | Username for connection (e.g., "root@test") |
+| `password` | str | No | Password for connection |
+| `db_name` | str | No | Database name (default: "test") |
+| `table_name` | str | Yes | Table containing vector data |
+| `vector_column_name` | str | No | Column with embeddings (default: "embedding") |
+| `text_column_name` | str | No | Column with text content (default: "text") |
+| `metadata_column_name` | str | No | Column with metadata (default: "metadata") |
+| `embedding_model` | str | No | OpenAI model for embeddings (default: "text-embedding-3-large") |
+| `dimensions` | int | No | Embedding dimensions (default: 1536) |
+| `query_config` | OceanBaseVectorSearchConfig | No | Search configuration |
+
+## Environment Variables
+
+- `OPENAI_API_KEY`: Required for generating embeddings
+- `AZURE_OPENAI_ENDPOINT`: Optional, for Azure OpenAI support

lib/crewai-tools/src/crewai_tools/tools/oceanbase_vector_search_tool/__init__.py

@@ -0,0 +1,12 @@
+from crewai_tools.tools.oceanbase_vector_search_tool.oceanbase_vector_search_tool import (
+    OceanBaseToolSchema,
+    OceanBaseVectorSearchConfig,
+    OceanBaseVectorSearchTool,
+)
+
+
+__all__ = [
+    "OceanBaseToolSchema",
+    "OceanBaseVectorSearchConfig",
+    "OceanBaseVectorSearchTool",
+]

lib/crewai-tools/src/crewai_tools/tools/oceanbase_vector_search_tool/oceanbase_vector_search_tool.py

@@ -0,0 +1,267 @@
+from __future__ import annotations
+
+import json
+from logging import getLogger
+import os
+from typing import Any
+
+from crewai.tools import BaseTool, EnvVar
+from pydantic import BaseModel, Field
+
+
+try:
+    import pyobvector  # noqa: F401
+
+    PYOBVECTOR_AVAILABLE = True
+except ImportError:
+    PYOBVECTOR_AVAILABLE = False
+
+logger = getLogger(__name__)
+
+
+class OceanBaseToolSchema(BaseModel):
+    """Input schema for OceanBase vector search tool."""
+
+    query: str = Field(
+        ...,
+        description="The query to search for relevant information in the OceanBase database.",
+    )
+
+
+class OceanBaseVectorSearchConfig(BaseModel):
+    """Configuration for OceanBase vector search queries."""
+
+    limit: int = Field(
+        default=4,
+        description="Number of documents to return.",
+    )
+    distance_threshold: float | None = Field(
+        default=None,
+        description="Only return results where distance is less than or equal to this threshold.",
+    )
+    distance_func: str = Field(
+        default="l2",
+        description="Distance function to use for similarity search. Options: 'l2', 'cosine', 'inner_product'.",
+    )
+    include_embeddings: bool = Field(
+        default=False,
+        description="Whether to include the embedding vector of each result.",
+    )
+
+
+class OceanBaseVectorSearchTool(BaseTool):
+    """Tool to perform vector search on OceanBase database."""
+
+    name: str = "OceanBaseVectorSearchTool"
+    description: str = (
+        "A tool to perform vector similarity search on an OceanBase database "
+        "for retrieving relevant information from stored documents."
+    )
+
+    args_schema: type[BaseModel] = OceanBaseToolSchema
+    query_config: OceanBaseVectorSearchConfig | None = Field(
+        default=None,
+        description="OceanBase vector search query configuration.",
+    )
+    embedding_model: str = Field(
+        default="text-embedding-3-large",
+        description="OpenAI embedding model to use for generating query embeddings.",
+    )
+    dimensions: int = Field(
+        default=1536,
+        description="Number of dimensions in the embedding vector.",
+    )
+    connection_uri: str = Field(
+        ...,
+        description="Connection URI for OceanBase (e.g., '127.0.0.1:2881').",
+    )
+    user: str = Field(
+        ...,
+        description="Username for OceanBase connection (e.g., 'root@test').",
+    )
+    password: str = Field(
+        default="",
+        description="Password for OceanBase connection.",
+    )
+    db_name: str = Field(
+        default="test",
+        description="Database name in OceanBase.",
+    )
+    table_name: str = Field(
+        ...,
+        description="Name of the table containing vector data.",
+    )
+    vector_column_name: str = Field(
+        default="embedding",
+        description="Name of the column containing vector embeddings.",
+    )
+    text_column_name: str = Field(
+        default="text",
+        description="Name of the column containing text content.",
+    )
+    metadata_column_name: str | None = Field(
+        default="metadata",
+        description="Name of the column containing metadata (optional).",
+    )
+    env_vars: list[EnvVar] = Field(
+        default_factory=lambda: [
+            EnvVar(
+                name="OPENAI_API_KEY",
+                description="API key for OpenAI embeddings",
+                required=True,
+            ),
+        ]
+    )
+    package_dependencies: list[str] = Field(default_factory=lambda: ["pyobvector"])
+
+    _client: Any = None
+    _openai_client: Any = None
+
+    def __init__(self, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        if not PYOBVECTOR_AVAILABLE:
+            import click
+
+            if click.confirm(
+                "You are missing the 'pyobvector' package. Would you like to install it?"
+            ):
+                import subprocess
+
+                subprocess.run(["uv", "add", "pyobvector"], check=True)  # noqa: S607
+            else:
+                raise ImportError(
+                    "The 'pyobvector' package is required for OceanBaseVectorSearchTool."
+                )
+
+        if "AZURE_OPENAI_ENDPOINT" in os.environ:
+            from openai import AzureOpenAI
+
+            self._openai_client = AzureOpenAI()
+        elif "OPENAI_API_KEY" in os.environ:
+            from openai import Client
+
+            self._openai_client = Client()
+        else:
+            raise ValueError(
+                "OPENAI_API_KEY environment variable is required for OceanBaseVectorSearchTool."
+            )
+
+        from pyobvector import ObVecClient
+
+        self._client = ObVecClient(
+            uri=self.connection_uri,
+            user=self.user,
+            password=self.password,
+            db_name=self.db_name,
+        )
+
+    def _embed_text(self, text: str) -> list[float]:
+        """Generate embedding for the given text using OpenAI."""
+        response = self._openai_client.embeddings.create(
+            input=[text],
+            model=self.embedding_model,
+            dimensions=self.dimensions,
+        )
+        return response.data[0].embedding
+
+    def _get_distance_func(self) -> Any:
+        """Get the appropriate distance function from pyobvector."""
+        import pyobvector
+
+        config = self.query_config or OceanBaseVectorSearchConfig()
+        valid_distance_funcs = {
+            "l2": "l2_distance",
+            "cosine": "cosine_distance",
+            "inner_product": "inner_product",
+        }
+
+        func_name = valid_distance_funcs.get(config.distance_func, "l2_distance")
+        return getattr(pyobvector, func_name)
+
+    def _run(self, query: str) -> str:
+        """Execute vector search on OceanBase."""
+        try:
+            config = self.query_config or OceanBaseVectorSearchConfig()
+
+            query_vector = self._embed_text(query)
+
+            output_columns = [self.text_column_name]
+            if self.metadata_column_name:
+                output_columns.append(self.metadata_column_name)
+
+            results = self._client.ann_search(
+                table_name=self.table_name,
+                vec_data=query_vector,
+                vec_column_name=self.vector_column_name,
+                distance_func=self._get_distance_func(),
+                with_dist=True,
+                topk=config.limit,
+                output_column_names=output_columns,
+                distance_threshold=config.distance_threshold,
+            )
+
+            formatted_results = []
+            for row in results:
+                result_dict: dict[str, Any] = {}
+
+                if len(row) >= 1:
+                    result_dict["text"] = row[0]
+                if self.metadata_column_name and len(row) >= 2:
+                    result_dict["metadata"] = row[1]
+                if len(row) > len(output_columns):
+                    result_dict["distance"] = row[-1]
+
+                formatted_results.append(result_dict)
+
+            return json.dumps(formatted_results, indent=2, default=str)
+
+        except Exception as e:
+            logger.error(f"Error during OceanBase vector search: {e}")
+            return json.dumps({"error": str(e)})
+
+    def add_texts(
+        self,
+        texts: list[str],
+        metadatas: list[dict[str, Any]] | None = None,
+        ids: list[str] | None = None,
+    ) -> list[str]:
+        """Add texts with embeddings to the OceanBase table.
+
+        Args:
+            texts: List of text strings to add.
+            metadatas: Optional list of metadata dictionaries for each text.
+            ids: Optional list of unique IDs for each text.
+
+        Returns:
+            List of IDs for the added texts.
+        """
+        import uuid
+
+        if ids is None:
+            ids = [str(uuid.uuid4()) for _ in texts]
+
+        if metadatas is None:
+            metadatas = [{} for _ in texts]
+
+        data = []
+        for text, metadata, doc_id in zip(texts, metadatas, ids, strict=False):
+            embedding = self._embed_text(text)
+            row = {
+                "id": doc_id,
+                self.text_column_name: text,
+                self.vector_column_name: embedding,
+            }
+            if self.metadata_column_name:
+                row[self.metadata_column_name] = metadata
+            data.append(row)
+
+        self._client.insert(self.table_name, data=data)
+        return ids
+
+    def __del__(self) -> None:
+        """Cleanup clients on deletion."""
+        try:
+            if hasattr(self, "_openai_client") and self._openai_client:
+                self._openai_client.close()
+        except Exception as e:
+            logger.error(f"Error closing OpenAI client: {e}")

lib/crewai-tools/tests/tools/test_oceanbase_vector_search_tool.py

@@ -0,0 +1,208 @@
+import json
+import sys
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from crewai_tools import OceanBaseVectorSearchConfig
+
+
+mock_pyobvector = MagicMock()
+mock_pyobvector.ObVecClient = MagicMock()
+mock_pyobvector.l2_distance = MagicMock(return_value="l2_func")
+mock_pyobvector.cosine_distance = MagicMock(return_value="cosine_func")
+mock_pyobvector.inner_product = MagicMock(return_value="ip_func")
+sys.modules["pyobvector"] = mock_pyobvector
+
+
+@pytest.fixture
+def mock_openai_client():
+    """Create a mock OpenAI client."""
+    mock_client = MagicMock()
+    mock_embedding = MagicMock()
+    mock_embedding.embedding = [0.1] * 1536
+    mock_response = MagicMock()
+    mock_response.data = [mock_embedding]
+    mock_client.embeddings.create.return_value = mock_response
+    return mock_client
+
+
+@pytest.fixture
+def mock_obvec_client():
+    """Create a mock OceanBase vector client."""
+    mock_client = MagicMock()
+    return mock_client
+
+
+@pytest.fixture
+def oceanbase_vector_search_tool(mock_openai_client, mock_obvec_client):
+    """Create an OceanBaseVectorSearchTool with mocked clients."""
+    from crewai_tools import OceanBaseVectorSearchTool
+
+    with patch.dict("os.environ", {"OPENAI_API_KEY": "test-key"}):
+        with patch(
+            "crewai_tools.tools.oceanbase_vector_search_tool.oceanbase_vector_search_tool.PYOBVECTOR_AVAILABLE",
+            True,
+        ):
+            mock_pyobvector.ObVecClient.return_value = mock_obvec_client
+            with patch("openai.Client") as mock_openai_class:
+                mock_openai_class.return_value = mock_openai_client
+                tool = OceanBaseVectorSearchTool(
+                    connection_uri="127.0.0.1:2881",
+                    user="root@test",
+                    password="",
+                    db_name="test",
+                    table_name="test_table",
+                )
+                tool._openai_client = mock_openai_client
+                tool._client = mock_obvec_client
+                yield tool
+
+
+def test_successful_query_execution(oceanbase_vector_search_tool, mock_obvec_client):
+    """Test successful vector search query execution."""
+    mock_obvec_client.ann_search.return_value = [
+        ("test document content", {"source": "test.txt"}, 0.1),
+        ("another document", {"source": "test2.txt"}, 0.2),
+    ]
+
+    results = json.loads(oceanbase_vector_search_tool._run(query="test query"))
+
+    assert len(results) == 2
+    assert results[0]["text"] == "test document content"
+    assert results[0]["metadata"] == {"source": "test.txt"}
+    assert results[0]["distance"] == 0.1
+
+
+def test_query_with_custom_config(mock_openai_client, mock_obvec_client):
+    """Test vector search with custom configuration."""
+    from crewai_tools import OceanBaseVectorSearchTool
+
+    query_config = OceanBaseVectorSearchConfig(
+        limit=10,
+        distance_func="cosine",
+        distance_threshold=0.5,
+    )
+
+    with patch.dict("os.environ", {"OPENAI_API_KEY": "test-key"}):
+        with patch(
+            "crewai_tools.tools.oceanbase_vector_search_tool.oceanbase_vector_search_tool.PYOBVECTOR_AVAILABLE",
+            True,
+        ):
+            mock_pyobvector.ObVecClient.return_value = mock_obvec_client
+            with patch("openai.Client") as mock_openai_class:
+                mock_openai_class.return_value = mock_openai_client
+                tool = OceanBaseVectorSearchTool(
+                    connection_uri="127.0.0.1:2881",
+                    user="root@test",
+                    db_name="test",
+                    table_name="test_table",
+                    query_config=query_config,
+                )
+                tool._openai_client = mock_openai_client
+                tool._client = mock_obvec_client
+
+    mock_obvec_client.ann_search.return_value = [("doc", {}, 0.3)]
+
+    tool._run(query="test")
+
+    call_kwargs = mock_obvec_client.ann_search.call_args.kwargs
+    assert call_kwargs["topk"] == 10
+    assert call_kwargs["distance_threshold"] == 0.5
+
+
+def test_add_texts(oceanbase_vector_search_tool, mock_obvec_client):
+    """Test adding texts to the OceanBase table."""
+    texts = ["document 1", "document 2"]
+    metadatas = [{"source": "file1.txt"}, {"source": "file2.txt"}]
+
+    result_ids = oceanbase_vector_search_tool.add_texts(texts, metadatas=metadatas)
+
+    assert len(result_ids) == 2
+    mock_obvec_client.insert.assert_called_once()
+    call_args = mock_obvec_client.insert.call_args
+    assert call_args[0][0] == "test_table"
+    assert len(call_args[1]["data"]) == 2
+
+
+def test_add_texts_without_metadata(oceanbase_vector_search_tool, mock_obvec_client):
+    """Test adding texts without metadata."""
+    texts = ["document 1", "document 2"]
+
+    result_ids = oceanbase_vector_search_tool.add_texts(texts)
+
+    assert len(result_ids) == 2
+    mock_obvec_client.insert.assert_called_once()
+
+
+def test_error_handling(oceanbase_vector_search_tool, mock_obvec_client):
+    """Test error handling during search."""
+    mock_obvec_client.ann_search.side_effect = Exception("Database connection error")
+
+    result = json.loads(oceanbase_vector_search_tool._run(query="test"))
+
+    assert "error" in result
+    assert "Database connection error" in result["error"]
+
+
+def test_config_defaults():
+    """Test OceanBaseVectorSearchConfig default values."""
+    config = OceanBaseVectorSearchConfig()
+
+    assert config.limit == 4
+    assert config.distance_func == "l2"
+    assert config.distance_threshold is None
+    assert config.include_embeddings is False
+
+
+def test_config_custom_values():
+    """Test OceanBaseVectorSearchConfig with custom values."""
+    config = OceanBaseVectorSearchConfig(
+        limit=20,
+        distance_func="cosine",
+        distance_threshold=0.8,
+        include_embeddings=True,
+    )
+
+    assert config.limit == 20
+    assert config.distance_func == "cosine"
+    assert config.distance_threshold == 0.8
+    assert config.include_embeddings is True
+
+
+def test_tool_schema():
+    """Test OceanBaseToolSchema validation."""
+    from crewai_tools import OceanBaseToolSchema
+
+    schema = OceanBaseToolSchema(query="test query")
+    assert schema.query == "test query"
+
+
+def test_tool_schema_requires_query():
+    """Test that OceanBaseToolSchema requires a query."""
+    from crewai_tools import OceanBaseToolSchema
+    from pydantic import ValidationError
+
+    with pytest.raises(ValidationError):
+        OceanBaseToolSchema()
+
+
+def test_distance_function_selection(oceanbase_vector_search_tool):
+    """Test that the correct distance function is selected."""
+    oceanbase_vector_search_tool.query_config = OceanBaseVectorSearchConfig(
+        distance_func="l2"
+    )
+    func = oceanbase_vector_search_tool._get_distance_func()
+    assert func == mock_pyobvector.l2_distance
+
+    oceanbase_vector_search_tool.query_config = OceanBaseVectorSearchConfig(
+        distance_func="cosine"
+    )
+    func = oceanbase_vector_search_tool._get_distance_func()
+    assert func == mock_pyobvector.cosine_distance
+
+    oceanbase_vector_search_tool.query_config = OceanBaseVectorSearchConfig(
+        distance_func="inner_product"
+    )
+    func = oceanbase_vector_search_tool._get_distance_func()
+    assert func == mock_pyobvector.inner_product

lib/crewai/src/crewai/cli/constants.py

@@ -69,7 +69,7 @@ ENV_VARS: dict[str, list[dict[str, Any]]] = {
         },
         {
             "prompt": "Enter your AWS Region Name (press Enter to skip)",
-            "key_name": "AWS_REGION_NAME",
+            "key_name": "AWS_DEFAULT_REGION",
         },
     ],
     "azure": [

lib/crewai/src/crewai/llms/providers/bedrock/completion.py

@@ -234,7 +234,7 @@ class BedrockCompletion(BaseLLM):
         aws_access_key_id: str | None = None,
         aws_secret_access_key: str | None = None,
         aws_session_token: str | None = None,
-        region_name: str = "us-east-1",
+        region_name: str | None = None,
         temperature: float | None = None,
         max_tokens: int | None = None,
         top_p: float | None = None,
@@ -287,15 +287,6 @@ class BedrockCompletion(BaseLLM):
             **kwargs,
         )
 
-        # Initialize Bedrock client with proper configuration
-        session = Session(
-            aws_access_key_id=aws_access_key_id or os.getenv("AWS_ACCESS_KEY_ID"),
-            aws_secret_access_key=aws_secret_access_key
-            or os.getenv("AWS_SECRET_ACCESS_KEY"),
-            aws_session_token=aws_session_token or os.getenv("AWS_SESSION_TOKEN"),
-            region_name=region_name,
-        )
-
         # Configure client with timeouts and retries following AWS best practices
         config = Config(
             read_timeout=300,
@@ -306,8 +297,12 @@ class BedrockCompletion(BaseLLM):
             tcp_keepalive=True,
         )
 
-        self.client = session.client("bedrock-runtime", config=config)
-        self.region_name = region_name
+        self.region_name = (
+            region_name
+            or os.getenv("AWS_DEFAULT_REGION")
+            or os.getenv("AWS_REGION_NAME")
+            or "us-east-1"
+        )
 
         self.aws_access_key_id = aws_access_key_id or os.getenv("AWS_ACCESS_KEY_ID")
         self.aws_secret_access_key = aws_secret_access_key or os.getenv(
@@ -315,6 +310,16 @@ class BedrockCompletion(BaseLLM):
         )
         self.aws_session_token = aws_session_token or os.getenv("AWS_SESSION_TOKEN")
 
+        # Initialize Bedrock client with proper configuration
+        session = Session(
+            aws_access_key_id=self.aws_access_key_id,
+            aws_secret_access_key=self.aws_secret_access_key,
+            aws_session_token=self.aws_session_token,
+            region_name=self.region_name,
+        )
+
+        self.client = session.client("bedrock-runtime", config=config)
+
         self._async_exit_stack = AsyncExitStack() if AIOBOTOCORE_AVAILABLE else None
         self._async_client_initialized = False
 

lib/crewai/src/crewai/utilities/llm_utils.py

@@ -69,7 +69,7 @@ def create_llm(
 UNACCEPTED_ATTRIBUTES: Final[list[str]] = [
     "AWS_ACCESS_KEY_ID",
     "AWS_SECRET_ACCESS_KEY",
-    "AWS_REGION_NAME",
+    "AWS_DEFAULT_REGION",
 ]
 
 
@@ -146,7 +146,7 @@ def _llm_via_environment_or_fallback() -> LLM | None:
     unaccepted_attributes = [
         "AWS_ACCESS_KEY_ID",
         "AWS_SECRET_ACCESS_KEY",
-        "AWS_REGION_NAME",
+        "AWS_DEFAULT_REGION",
     ]
     set_provider = model_name.partition("/")[0] if "/" in model_name else "openai"
 

lib/crewai/tests/llms/bedrock/test_bedrock.py

@@ -437,17 +437,36 @@ def test_bedrock_aws_credentials_configuration():
     """
     Test that AWS credentials configuration works properly
     """
+    aws_access_key_id = "test-access-key"
+    aws_secret_access_key = "test-secret-key"
+    aws_region_name = "us-east-1"
+
+
     # Test with environment variables
     with patch.dict(os.environ, {
-        "AWS_ACCESS_KEY_ID": "test-access-key",
-        "AWS_SECRET_ACCESS_KEY": "test-secret-key",
-        "AWS_DEFAULT_REGION": "us-east-1"
+        "AWS_ACCESS_KEY_ID": aws_access_key_id,
+        "AWS_SECRET_ACCESS_KEY": aws_secret_access_key,
+        "AWS_DEFAULT_REGION": aws_region_name
     }):
         llm = LLM(model="bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0")
 
         from crewai.llms.providers.bedrock.completion import BedrockCompletion
         assert isinstance(llm, BedrockCompletion)
-        assert llm.region_name == "us-east-1"
+        assert llm.region_name == aws_region_name
+        assert llm.aws_access_key_id == aws_access_key_id
+        assert llm.aws_secret_access_key == aws_secret_access_key
+
+      # Test with litellm environment variables
+    with patch.dict(os.environ, {
+        "AWS_ACCESS_KEY_ID": aws_access_key_id,
+        "AWS_SECRET_ACCESS_KEY": aws_secret_access_key,
+        "AWS_REGION_NAME": aws_region_name
+    }):
+        llm = LLM(model="bedrock/anthropic.claude-3-5-sonnet-20241022-v2:0")
+
+        from crewai.llms.providers.bedrock.completion import BedrockCompletion
+        assert isinstance(llm, BedrockCompletion)
+        assert llm.region_name == aws_region_name
 
     # Test with explicit credentials
     llm_explicit = LLM(

lib/crewai/tests/utilities/test_llm_utils.py

@@ -81,7 +81,7 @@ def test_create_llm_from_env_with_unaccepted_attributes() -> None:
             "OPENAI_API_KEY": "fake-key",
             "AWS_ACCESS_KEY_ID": "fake-access-key",
             "AWS_SECRET_ACCESS_KEY": "fake-secret-key",
-            "AWS_REGION_NAME": "us-west-2",
+            "AWS_DEFAULT_REGION": "us-west-2",
         },
     ):
         llm = create_llm(llm_value=None)
@@ -89,7 +89,7 @@ def test_create_llm_from_env_with_unaccepted_attributes() -> None:
         assert llm.model == "gpt-3.5-turbo"
         assert not hasattr(llm, "AWS_ACCESS_KEY_ID")
         assert not hasattr(llm, "AWS_SECRET_ACCESS_KEY")
-        assert not hasattr(llm, "AWS_REGION_NAME")
+        assert not hasattr(llm, "AWS_DEFAULT_REGION")
 
 
 def test_create_llm_with_partial_attributes() -> None: