camel-ai 0.2.37__py3-none-any.whl → 0.2.39__py3-none-any.whl

camel/models/openai_model.py

@@ -60,6 +60,10 @@ class OpenAIModel(BaseModelBackend):
         token_counter (Optional[BaseTokenCounter], optional): Token counter to
             use for the model. If not provided, :obj:`OpenAITokenCounter` will
             be used. (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required(
@@ -74,31 +78,33 @@ class OpenAIModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = ChatGPTConfig().as_dict()
         api_key = api_key or os.environ.get("OPENAI_API_KEY")
         url = url or os.environ.get("OPENAI_API_BASE_URL")
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
 
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
 
         self._client = OpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             base_url=self._url,
             api_key=self._api_key,
         )
         self._async_client = AsyncOpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             base_url=self._url,
             api_key=self._api_key,
         )
 
     def _sanitize_config(self, config_dict: Dict[str, Any]) -> Dict[str, Any]:
-        """Sanitize the model configuration for O1 models."""
+        r"""Sanitize the model configuration for O1 models."""
 
         if self.model_type in [
             ModelType.O1,
@@ -107,7 +113,7 @@ class OpenAIModel(BaseModelBackend):
             ModelType.O3_MINI,
         ]:
             warnings.warn(
-                "Warning: You are using an O1 model (O1_MINI or O1_PREVIEW), "
+                "Warning: You are using an reasoning model (O1 or O3), "
                 "which has certain limitations, reference: "
                 "`https://platform.openai.com/docs/guides/reasoning`.",
                 UserWarning,
@@ -119,6 +125,52 @@ class OpenAIModel(BaseModelBackend):
             }
         return config_dict
 
+    def _adapt_messages_for_o1_models(
+        self, messages: List[OpenAIMessage]
+    ) -> List[OpenAIMessage]:
+        r"""Adjust message roles to comply with O1 model requirements by
+        converting 'system' or 'developer' to 'user' role.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            processed_messages (List[OpenAIMessage]): Return a new list of
+                messages to avoid mutating input.
+        """
+
+        # Define supported O1 model types as a class constant would be better
+        O1_MODEL_TYPES = {ModelType.O1_MINI, ModelType.O1_PREVIEW}
+
+        if self.model_type not in O1_MODEL_TYPES:
+            return messages.copy()
+
+        # Issue warning only once using class state
+        if not hasattr(self, "_o1_warning_issued"):
+            warnings.warn(
+                "O1 models (O1_MINI/O1_PREVIEW) have role limitations: "
+                "System or Developer messages will be converted to user role."
+                "Reference: https://community.openai.com/t/"
+                "developer-role-not-accepted-for-o1-o1-mini-o3-mini/1110750/7",
+                UserWarning,
+                stacklevel=2,
+            )
+            self._o1_warning_issued = True
+
+        # Create new message list to avoid mutating input
+        processed_messages = []
+        for message in messages:
+            processed_message = message.copy()
+            if (
+                processed_message["role"] == "system"
+                or processed_message["role"] == "developer"
+            ):
+                processed_message["role"] = "user"  # type: ignore[arg-type]
+            processed_messages.append(processed_message)
+
+        return processed_messages
+
     @property
     def token_counter(self) -> BaseTokenCounter:
         r"""Initialize the token counter for the model backend.
@@ -152,6 +204,7 @@ class OpenAIModel(BaseModelBackend):
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
+        messages = self._adapt_messages_for_o1_models(messages)
         response_format = response_format or self.model_config_dict.get(
             "response_format", None
         )

camel/models/openrouter_model.py

@@ -51,6 +51,10 @@ class OpenRouterModel(BaseModelBackend):
             use for the model. If not provided, :obj:`OpenAITokenCounter(
             ModelType.GPT_4O_MINI)` will be used.
             (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required([("api_key", "OPENROUTER_API_KEY")])
@@ -61,6 +65,7 @@ class OpenRouterModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = OpenRouterConfig().as_dict()
@@ -68,17 +73,18 @@ class OpenRouterModel(BaseModelBackend):
         url = url or os.environ.get(
             "OPENROUTER_API_BASE_URL", "https://openrouter.ai/api/v1"
         )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         self._client = OpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,
         )
         self._async_client = AsyncOpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/models/qwen_model.py

@@ -52,6 +52,10 @@ class QwenModel(BaseModelBackend):
             use for the model. If not provided, :obj:`OpenAITokenCounter(
             ModelType.GPT_4O_MINI)` will be used.
             (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required(
@@ -66,6 +70,7 @@ class QwenModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = QwenConfig().as_dict()
@@ -74,17 +79,18 @@ class QwenModel(BaseModelBackend):
             "QWEN_API_BASE_URL",
             "https://dashscope.aliyuncs.com/compatible-mode/v1",
         )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         self._client = OpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,
         )
         self._async_client = AsyncOpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/models/samba_model.py

@@ -73,6 +73,10 @@ class SambaModel(BaseModelBackend):
         token_counter (Optional[BaseTokenCounter], optional): Token counter to
             use for the model. If not provided, :obj:`OpenAITokenCounter(
             ModelType.GPT_4O_MINI)` will be used.
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required(
@@ -87,6 +91,7 @@ class SambaModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = SambaCloudAPIConfig().as_dict()
@@ -95,19 +100,20 @@ class SambaModel(BaseModelBackend):
             "SAMBA_API_BASE_URL",
             "https://api.sambanova.ai/v1",
         )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
 
         if self._url == "https://api.sambanova.ai/v1":
             self._client = OpenAI(
-                timeout=180,
+                timeout=self._timeout,
                 max_retries=3,
                 base_url=self._url,
                 api_key=self._api_key,
             )
             self._async_client = AsyncOpenAI(
-                timeout=180,
+                timeout=self._timeout,
                 max_retries=3,
                 base_url=self._url,
                 api_key=self._api_key,

camel/models/sglang_model.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import logging
+import os
 import subprocess
 import threading
 import time
@@ -51,6 +52,10 @@ class SGLangModel(BaseModelBackend):
             use for the model. If not provided, :obj:`OpenAITokenCounter(
             ModelType.GPT_4O_MINI)` will be used.
             (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
 
     Reference: https://sgl-project.github.io/backend/openai_api_completions.html
     """
@@ -62,6 +67,7 @@ class SGLangModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = SGLangConfig().as_dict()
@@ -73,8 +79,9 @@ class SGLangModel(BaseModelBackend):
         self._lock = threading.Lock()
         self._inactivity_thread: Optional[threading.Thread] = None
 
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
 
         self._client = None
@@ -82,13 +89,13 @@ class SGLangModel(BaseModelBackend):
         if self._url:
             # Initialize the client if an existing URL is provided
             self._client = OpenAI(
-                timeout=180,
+                timeout=self._timeout,
                 max_retries=3,
                 api_key="Set-but-ignored",  # required but ignored
                 base_url=self._url,
             )
             self._async_client = AsyncOpenAI(
-                timeout=180,
+                timeout=self._timeout,
                 max_retries=3,
                 api_key="Set-but-ignored",  # required but ignored
                 base_url=self._url,
@@ -123,7 +130,7 @@ class SGLangModel(BaseModelBackend):
             self.last_run_time = time.time()
             # Initialize the client after the server starts
             self._client = OpenAI(
-                timeout=180,
+                timeout=self._timeout,
                 max_retries=3,
                 api_key="Set-but-ignored",  # required but ignored
                 base_url=self._url,

camel/models/siliconflow_model.py

@@ -51,6 +51,10 @@ class SiliconFlowModel(BaseModelBackend):
             use for the model. If not provided, :obj:`OpenAITokenCounter(
             ModelType.GPT_4O_MINI)` will be used.
             (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required(
@@ -65,6 +69,7 @@ class SiliconFlowModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = SiliconFlowConfig().as_dict()
@@ -73,11 +78,12 @@ class SiliconFlowModel(BaseModelBackend):
             "SILICONFLOW_API_BASE_URL",
             "https://api.siliconflow.cn/v1/",
         )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         self._client = OpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/models/stub_model.py

@@ -82,10 +82,11 @@ class StubModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         r"""All arguments are unused for the dummy model."""
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
 
     @property

camel/models/togetherai_model.py

@@ -52,6 +52,10 @@ class TogetherAIModel(BaseModelBackend):
         token_counter (Optional[BaseTokenCounter], optional): Token counter to
             use for the model. If not provided, :obj:`OpenAITokenCounter(
             ModelType.GPT_4O_MINI)` will be used.
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required(
@@ -66,6 +70,7 @@ class TogetherAIModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = TogetherAIConfig().as_dict()
@@ -73,18 +78,19 @@ class TogetherAIModel(BaseModelBackend):
         url = url or os.environ.get(
             "TOGETHER_API_BASE_URL", "https://api.together.xyz/v1"
         )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
 
         self._client = OpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,
         )
         self._async_client = AsyncOpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,
@@ -107,7 +113,7 @@ class TogetherAIModel(BaseModelBackend):
                 `ChatCompletion` in the non-stream mode, or
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
-        # Use OpenAI cilent as interface call Together AI
+        # Use OpenAI client as interface call Together AI
         # Reference: https://docs.together.ai/docs/openai-api-compatibility
         response = await self._async_client.chat.completions.create(
             messages=messages,
@@ -133,7 +139,7 @@ class TogetherAIModel(BaseModelBackend):
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
-        # Use OpenAI cilent as interface call Together AI
+        # Use OpenAI client as interface call Together AI
         # Reference: https://docs.together.ai/docs/openai-api-compatibility
         response = self._client.chat.completions.create(
             messages=messages,

camel/models/vllm_model.py

@@ -50,6 +50,10 @@ class VLLMModel(BaseModelBackend):
             use for the model. If not provided, :obj:`OpenAITokenCounter(
             ModelType.GPT_4O_MINI)` will be used.
             (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
 
     References:
         https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html
@@ -62,24 +66,26 @@ class VLLMModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = VLLMConfig().as_dict()
         url = url or os.environ.get("VLLM_BASE_URL")
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         if not self._url:
             self._start_server()
-        # Use OpenAI cilent as interface call vLLM
+        # Use OpenAI client as interface call vLLM
         self._client = OpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key="EMPTY",  # required but ignored
             base_url=self._url,
         )
         self._async_client = AsyncOpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key="EMPTY",  # required but ignored
             base_url=self._url,

camel/models/yi_model.py

@@ -51,6 +51,10 @@ class YiModel(BaseModelBackend):
             use for the model. If not provided, :obj:`OpenAITokenCounter(
             ModelType.GPT_4O_MINI)` will be used.
             (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required(
@@ -65,6 +69,7 @@ class YiModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = YiConfig().as_dict()
@@ -72,17 +77,18 @@ class YiModel(BaseModelBackend):
         url = url or os.environ.get(
             "YI_API_BASE_URL", "https://api.lingyiwanwu.com/v1"
         )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         self._client = OpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,
         )
         self._async_client = AsyncOpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/models/zhipuai_model.py

@@ -51,6 +51,10 @@ class ZhipuAIModel(BaseModelBackend):
             use for the model. If not provided, :obj:`OpenAITokenCounter(
             ModelType.GPT_4O_MINI)` will be used.
             (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required(
@@ -65,6 +69,7 @@ class ZhipuAIModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = ZhipuAIConfig().as_dict()
@@ -72,17 +77,18 @@ class ZhipuAIModel(BaseModelBackend):
         url = url or os.environ.get(
             "ZHIPUAI_API_BASE_URL", "https://open.bigmodel.cn/api/paas/v4/"
         )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         self._client = OpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,
         )
         self._async_client = AsyncOpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,
@@ -105,7 +111,7 @@ class ZhipuAIModel(BaseModelBackend):
                 `ChatCompletion` in the non-stream mode, or
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
-        # Use OpenAI cilent as interface call ZhipuAI
+        # Use OpenAI client as interface call ZhipuAI
         # Reference: https://open.bigmodel.cn/dev/api#openai_sdk
         response = await self._async_client.chat.completions.create(
             messages=messages,
@@ -131,7 +137,7 @@ class ZhipuAIModel(BaseModelBackend):
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
-        # Use OpenAI cilent as interface call ZhipuAI
+        # Use OpenAI client as interface call ZhipuAI
         # Reference: https://open.bigmodel.cn/dev/api#openai_sdk
         response = self._client.chat.completions.create(
             messages=messages,

camel/retrievers/auto_retriever.py

@@ -29,6 +29,7 @@ from camel.storages import (
     BaseVectorStorage,
     MilvusStorage,
     QdrantStorage,
+    TiDBStorage,
 )
 from camel.types import StorageType
 from camel.utils import Constants
@@ -90,6 +91,19 @@ class AutoRetriever:
                 url_and_api_key=self.url_and_api_key,
             )
 
+        if self.storage_type == StorageType.TIDB:
+            if self.url_and_api_key is None:
+                raise ValueError(
+                    "URL (database url) and API key required for TiDB storage "
+                    "are not provided. Format: "
+                    "mysql+pymysql://<username>:<password>@<host>:4000/test"
+                )
+            return TiDBStorage(
+                vector_dim=self.embedding_model.get_output_dim(),
+                collection_name=collection_name,
+                url_and_api_key=self.url_and_api_key,
+            )
+
         if self.storage_type == StorageType.QDRANT:
             return QdrantStorage(
                 vector_dim=self.embedding_model.get_output_dim(),

camel/retrievers/vector_retriever.py

@@ -224,7 +224,7 @@ class VectorRetriever(BaseRetriever):
         if top_k <= 0:
             raise ValueError("top_k must be a positive integer.")
 
-        # Load the storage incase it's hosted remote
+        # Load the storage in case it's hosted remote
         self.storage.load()
 
         query_vector = self.embedding_model.embed(obj=query)

camel/storages/__init__.py

@@ -28,6 +28,7 @@ from .vectordb_storages.base import (
 )
 from .vectordb_storages.milvus import MilvusStorage
 from .vectordb_storages.qdrant import QdrantStorage
+from .vectordb_storages.tidb import TiDBStorage
 
 __all__ = [
     'BaseKeyValueStorage',
@@ -40,6 +41,7 @@ __all__ = [
     'VectorDBQueryResult',
     'QdrantStorage',
     'MilvusStorage',
+    "TiDBStorage",
     'BaseGraphStorage',
     'Neo4jGraph',
     'NebulaGraph',

camel/storages/graph_storages/neo4j_graph.py

@@ -69,7 +69,7 @@ class Neo4jGraph(BaseGraphStorage):
     The detailed information about Neo4j is available at:
     `Neo4j https://neo4j.com/docs/getting-started`
 
-    This module refered to the work of Langchian and Llamaindex.
+    This module referred to the work of Langchian and Llamaindex.
 
     Args:
         url (str): The URL of the Neo4j database server.

camel/storages/vectordb_storages/__init__.py

@@ -21,6 +21,7 @@ from .base import (
 )
 from .milvus import MilvusStorage
 from .qdrant import QdrantStorage
+from .tidb import TiDBStorage
 
 __all__ = [
     'BaseVectorStorage',
@@ -28,6 +29,7 @@ __all__ = [
     'VectorDBQueryResult',
     'QdrantStorage',
     'MilvusStorage',
+    "TiDBStorage",
     'VectorRecord',
     'VectorDBStatus',
 ]

camel/storages/vectordb_storages/base.py

@@ -100,7 +100,7 @@ class VectorDBStatus(BaseModel):
     r"""Vector database status.
 
     Attributes:
-        vector_dim (int): The dimention of stored vectors.
+        vector_dim (int): The dimension of stored vectors.
         vector_count (int): The number of stored vectors.
 
     """
@@ -204,7 +204,7 @@ class BaseVectorStorage(ABC):
 
         Args:
             vector (List[float]): The search vector.
-            top_k (int): The number of top similer vectors.
+            top_k (int): The number of top similar vectors.
 
         Returns:
             List[List[Dict[str, Any]]]: A list of vector payloads retrieved