camel-ai 0.2.3a1__py3-none-any.whl → 0.2.4__py3-none-any.whl

camel/models/vllm_model.py

@@ -17,58 +17,66 @@ from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
 
-from camel.configs import VLLM_API_PARAMS
+from camel.configs import VLLM_API_PARAMS, VLLMConfig
 from camel.messages import OpenAIMessage
-from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.models import BaseModelBackend
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+)
 from camel.utils import BaseTokenCounter, OpenAITokenCounter
 
 
 # flake8: noqa: E501
-class VLLMModel:
-    r"""vLLM service interface."""
+class VLLMModel(BaseModelBackend):
+    r"""vLLM service interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`. If
+            :obj:`None`, :obj:`VLLMConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the model service. vLLM doesn't need API key, it would be ignored
+            if set. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the model service. If not
+            provided, :obj:`"http://localhost:8000/v1"` will be used.
+            (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter(
+            ModelType.GPT_4O_MINI)` will be used.
+            (default: :obj:`None`)
+
+    References:
+        https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html
+    """
 
     def __init__(
         self,
-        model_type: str,
-        model_config_dict: Dict[str, Any],
-        url: Optional[str] = None,
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
         api_key: Optional[str] = None,
+        url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        r"""Constructor for vLLM backend with OpenAI compatibility.
-
-        # Reference: https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html
-
-        Args:
-            model_type (str): Model for which a backend is created.
-            model_config_dict (Dict[str, Any]): A dictionary that will
-                be fed into openai.ChatCompletion.create().
-            url (Optional[str]): The url to the model service. (default:
-                :obj:`"http://localhost:8000/v1"`)
-            api_key (Optional[str]): The API key for authenticating with the
-                model service.
-            token_counter (Optional[BaseTokenCounter]): Token counter to use
-                for the model. If not provided, `OpenAITokenCounter(ModelType.
-                GPT_4O_MINI)` will be used.
-        """
-        self.model_type = model_type
-        self.model_config_dict = model_config_dict
-        self._url = (
-            url
-            or os.environ.get("VLLM_BASE_URL")
-            or "http://localhost:8000/v1"
+        if model_config_dict is None:
+            model_config_dict = VLLMConfig().as_dict()
+        url = url or os.environ.get("VLLM_BASE_URL")
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
         )
-        if not url and not os.environ.get("VLLM_BASE_URL"):
+        if not self._url:
             self._start_server()
         # Use OpenAI cilent as interface call vLLM
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
+            api_key="Set-but-ignored",  # required but ignored
             base_url=self._url,
-            api_key=api_key,
         )
-        self._token_counter = token_counter
-        self.check_model_config()
 
     def _start_server(self) -> None:
         r"""Starts the vllm server in a subprocess."""
@@ -78,8 +86,9 @@ class VLLMModel:
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
             )
+            self._url = "http://localhost:8000/v1"
             print(
-                f"vllm server started on http://localhost:8000/v1 "
+                f"vllm server started on {self._url} "
                 f"for {self.model_type} model."
             )
         except Exception as e:
@@ -135,22 +144,6 @@ class VLLMModel:
         )
         return response
 
-    @property
-    def token_limit(self) -> int:
-        r"""Returns the maximum token limit for the given model.
-
-        Returns:
-            int: The maximum token limit for the given model.
-        """
-        max_tokens = self.model_config_dict.get("max_tokens")
-        if isinstance(max_tokens, int):
-            return max_tokens
-        print(
-            "Must set `max_tokens` as an integer in `model_config_dict` when"
-            " setting up the model. Using 4096 as default value."
-        )
-        return 4096
-
     @property
     def stream(self) -> bool:
         r"""Returns whether the model is in stream mode, which sends partial

camel/models/zhipuai_model.py

@@ -17,10 +17,14 @@ from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
 
-from camel.configs import ZHIPUAI_API_PARAMS
+from camel.configs import ZHIPUAI_API_PARAMS, ZhipuAIConfig
 from camel.messages import OpenAIMessage
 from camel.models import BaseModelBackend
-from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+)
 from camel.utils import (
     BaseTokenCounter,
     OpenAITokenCounter,
@@ -29,40 +33,42 @@ from camel.utils import (
 
 
 class ZhipuAIModel(BaseModelBackend):
-    r"""ZhipuAI API in a unified BaseModelBackend interface."""
+    r"""ZhipuAI API in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, one of GLM_* series.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`. If
+            :obj:`None`, :obj:`ZhipuAIConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the ZhipuAI service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the ZhipuAI service.
+            (default: :obj:`https://open.bigmodel.cn/api/paas/v4/`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter(
+            ModelType.GPT_4O_MINI)` will be used.
+            (default: :obj:`None`)
+    """
 
     def __init__(
         self,
-        model_type: ModelType,
-        model_config_dict: Dict[str, Any],
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        r"""Constructor for ZhipuAI backend.
-
-        Args:
-            model_type (ModelType): Model for which a backend is created,
-                such as GLM_* series.
-            model_config_dict (Dict[str, Any]): A dictionary that will
-                be fed into openai.ChatCompletion.create().
-            api_key (Optional[str]): The API key for authenticating with the
-                ZhipuAI service. (default: :obj:`None`)
-            url (Optional[str]): The url to the ZhipuAI service. (default:
-                :obj:`None`)
-            token_counter (Optional[BaseTokenCounter]): Token counter to use
-                for the model. If not provided, `OpenAITokenCounter(ModelType.
-                GPT_4O_MINI)` will be used.
-        """
+        if model_config_dict is None:
+            model_config_dict = ZhipuAIConfig().as_dict()
+        api_key = api_key or os.environ.get("ZHIPUAI_API_KEY")
+        url = url or os.environ.get(
+            "ZHIPUAI_API_BASE_URL", "https://open.bigmodel.cn/api/paas/v4/"
+        )
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
-        self._url = url or os.environ.get("ZHIPUAI_API_BASE_URL")
-        self._api_key = api_key or os.environ.get("ZHIPUAI_API_KEY")
-        if not self._url or not self._api_key:
-            raise ValueError(
-                "ZHIPUAI_API_BASE_URL and ZHIPUAI_API_KEY should be set."
-            )
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
@@ -90,7 +96,7 @@ class ZhipuAIModel(BaseModelBackend):
         # Reference: https://open.bigmodel.cn/dev/api#openai_sdk
         response = self._client.chat.completions.create(
             messages=messages,
-            model=self.model_type.value,
+            model=self.model_type,
             **self.model_config_dict,
         )
         return response

camel/retrievers/auto_retriever.py

@@ -11,10 +11,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
-import datetime
-import os
 import re
-from typing import Collection, List, Optional, Sequence, Tuple, Union
+import uuid
+from typing import (
+    TYPE_CHECKING,
+    Collection,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+)
 
 from camel.embeddings import BaseEmbedding, OpenAIEmbedding
 from camel.retrievers.vector_retriever import VectorRetriever
@@ -22,15 +29,12 @@ from camel.storages import (
     BaseVectorStorage,
     MilvusStorage,
     QdrantStorage,
-    VectorDBQuery,
 )
 from camel.types import StorageType
 from camel.utils import Constants
 
-try:
+if TYPE_CHECKING:
     from unstructured.documents.elements import Element
-except ImportError:
-    Element = None
 
 
 class AutoRetriever:
@@ -98,7 +102,9 @@ class AutoRetriever:
             f"Unsupported vector storage type: {self.storage_type}"
         )
 
-    def _collection_name_generator(self, content: Union[str, Element]) -> str:
+    def _collection_name_generator(
+        self, content: Union[str, "Element"]
+    ) -> str:
         r"""Generates a valid collection name from a given file path or URL.
 
         Args:
@@ -108,74 +114,19 @@ class AutoRetriever:
         Returns:
             str: A sanitized, valid collection name suitable for use.
         """
+        from unstructured.documents.elements import Element
 
         if isinstance(content, Element):
-            content = content.metadata.file_directory
+            content = content.metadata.file_directory or str(uuid.uuid4())
 
         collection_name = re.sub(r'[^a-zA-Z0-9]', '', content)[:20]
 
         return collection_name
 
-    def _get_file_modified_date_from_file(
-        self, content_input_path: str
-    ) -> str:
-        r"""Retrieves the last modified date and time of a given file. This
-        function takes a file path as input and returns the last modified date
-        and time of that file.
-
-        Args:
-            content_input_path (str): The file path of the content whose
-                modified date is to be retrieved.
-
-        Returns:
-            str: The last modified time from file.
-        """
-        mod_time = os.path.getmtime(content_input_path)
-        readable_mod_time = datetime.datetime.fromtimestamp(
-            mod_time
-        ).isoformat(timespec='seconds')
-        return readable_mod_time
-
-    def _get_file_modified_date_from_storage(
-        self, vector_storage_instance: BaseVectorStorage
-    ) -> str:
-        r"""Retrieves the last modified date and time of a given file. This
-        function takes vector storage instance as input and returns the last
-        modified date from the metadata.
-
-        Args:
-            vector_storage_instance (BaseVectorStorage): The vector storage
-                where modified date is to be retrieved from metadata.
-
-        Returns:
-            str: The last modified date from vector storage.
-        """
-
-        # Insert any query to get modified date from vector db
-        # NOTE: Can be optimized when CAMEL vector storage support
-        # direct chunk payload extraction
-        query_vector_any = self.embedding_model.embed(obj="any_query")
-        query_any = VectorDBQuery(query_vector_any, top_k=1)
-        result_any = vector_storage_instance.query(query_any)
-
-        # Extract the file's last modified date from the metadata
-        # in the query result
-        if result_any[0].record.payload is not None:
-            file_modified_date_from_meta = result_any[0].record.payload[
-                "metadata"
-            ]['last_modified']
-        else:
-            raise ValueError(
-                "The vector storage exits but the payload is None,"
-                "please check the collection"
-            )
-
-        return file_modified_date_from_meta
-
     def run_vector_retriever(
         self,
         query: str,
-        contents: Union[str, List[str], Element, List[Element]],
+        contents: Union[str, List[str], "Element", List["Element"]],
         top_k: int = Constants.DEFAULT_TOP_K_RESULTS,
         similarity_threshold: float = Constants.DEFAULT_SIMILARITY_THRESHOLD,
         return_detailed_info: bool = False,
@@ -212,12 +163,20 @@ class AutoRetriever:
                 `contents` is empty.
             RuntimeError: If any errors occur during the retrieve process.
         """
+        from unstructured.documents.elements import Element
+
         if not contents:
             raise ValueError("content cannot be empty.")
 
-        contents = (
-            [contents] if isinstance(contents, (str, Element)) else contents
-        )
+        # Normalize contents to a list
+        if isinstance(contents, str):
+            contents = [contents]
+        elif isinstance(contents, Element):
+            contents = [contents]
+        elif not isinstance(contents, list):
+            raise ValueError(
+                "contents must be a string, Element, or a list of them."
+            )
 
         all_retrieved_info = []
         for content in contents:
@@ -228,34 +187,7 @@ class AutoRetriever:
                     collection_name
                 )
 
-                # Check the modified time of the input file path, only works
-                # for local path since no standard way for remote url
-                file_is_modified = False  # initialize with a default value
-                if (
-                    vector_storage_instance.status().vector_count != 0
-                    and isinstance(content, str)
-                    and os.path.exists(content)
-                ):
-                    # Get original modified date from file
-                    modified_date_from_file = (
-                        self._get_file_modified_date_from_file(content)
-                    )
-                    # Get modified date from vector storage
-                    modified_date_from_storage = (
-                        self._get_file_modified_date_from_storage(
-                            vector_storage_instance
-                        )
-                    )
-                    # Determine if the file has been modified since the last
-                    # check
-                    file_is_modified = (
-                        modified_date_from_file != modified_date_from_storage
-                    )
-
-                if (
-                    vector_storage_instance.status().vector_count == 0
-                    or file_is_modified
-                ):
+                if vector_storage_instance.status().vector_count == 0:
                     # Clear the vector storage
                     vector_storage_instance.clear()
                     # Process and store the content to the vector storage

camel/retrievers/vector_retriever.py

@@ -14,7 +14,7 @@
 import os
 import warnings
 from io import IOBase
-from typing import Any, Dict, List, Optional, Union
+from typing import IO, TYPE_CHECKING, Any, Dict, List, Optional, Union
 from urllib.parse import urlparse
 
 from camel.embeddings import BaseEmbedding, OpenAIEmbedding
@@ -28,10 +28,8 @@ from camel.storages import (
 )
 from camel.utils import Constants
 
-try:
+if TYPE_CHECKING:
     from unstructured.documents.elements import Element
-except ImportError:
-    Element = None
 
 
 class VectorRetriever(BaseRetriever):
@@ -73,7 +71,7 @@ class VectorRetriever(BaseRetriever):
 
     def process(
         self,
-        content: Union[str, Element, IOBase],
+        content: Union[str, "Element", IO[bytes]],
         chunk_type: str = "chunk_by_title",
         max_characters: int = 500,
         embed_batch: int = 50,
@@ -86,7 +84,7 @@ class VectorRetriever(BaseRetriever):
         specified vector storage.
 
         Args:
-            content (Union[str, Element, IOBase]): Local file path, remote
+            content (Union[str, Element, IO[bytes]]): Local file path, remote
                 URL, string content, Element object, or a binary file object.
             chunk_type (str): Type of chunking going to apply. Defaults to
                 "chunk_by_title".
@@ -97,67 +95,73 @@ class VectorRetriever(BaseRetriever):
                 otherwise skip chunking. Defaults to True.
             **kwargs (Any): Additional keyword arguments for content parsing.
         """
+        from unstructured.documents.elements import Element
+
         if isinstance(content, Element):
             elements = [content]
         elif isinstance(content, IOBase):
             elements = self.uio.parse_bytes(file=content, **kwargs) or []
-        else:
+        elif isinstance(content, str):
             # Check if the content is URL
             parsed_url = urlparse(content)
             is_url = all([parsed_url.scheme, parsed_url.netloc])
             if is_url or os.path.exists(content):
-                elements = self.uio.parse_file_or_url(content, **kwargs) or []
+                elements = (
+                    self.uio.parse_file_or_url(input_path=content, **kwargs)
+                    or []
+                )
             else:
                 elements = [self.uio.create_element_from_text(text=content)]
+
         if not elements:
             warnings.warn(
                 f"No elements were extracted from the content: {content}"
             )
-            return
-
-        # Chunk the content if required
-        chunks = (
-            self.uio.chunk_elements(
-                chunk_type=chunk_type,
-                elements=elements,
-                max_characters=max_characters,
+        else:
+            # Chunk the content if required
+            chunks = (
+                self.uio.chunk_elements(
+                    chunk_type=chunk_type,
+                    elements=elements,
+                    max_characters=max_characters,
+                )
+                if should_chunk
+                else elements
             )
-            if should_chunk
-            else elements
-        )
 
-        # Process chunks in batches and store embeddings
-        for i in range(0, len(chunks), embed_batch):
-            batch_chunks = chunks[i : i + embed_batch]
-            batch_vectors = self.embedding_model.embed_list(
-                objs=[str(chunk) for chunk in batch_chunks]
-            )
+            # Process chunks in batches and store embeddings
+            for i in range(0, len(chunks), embed_batch):
+                batch_chunks = chunks[i : i + embed_batch]
+                batch_vectors = self.embedding_model.embed_list(
+                    objs=[str(chunk) for chunk in batch_chunks]
+                )
 
-            records = []
-            # Prepare the payload for each vector record, includes the content
-            # path, chunk metadata, and chunk text
-            for vector, chunk in zip(batch_vectors, batch_chunks):
-                if isinstance(content, str):
-                    content_path_info = {"content path": content}
-                elif isinstance(content, IOBase):
-                    content_path_info = {"content path": "From file bytes"}
-                elif isinstance(content, Element):
-                    content_path_info = {
-                        "content path": content.metadata.file_directory
+                records = []
+                # Prepare the payload for each vector record, includes the
+                # content path, chunk metadata, and chunk text
+                for vector, chunk in zip(batch_vectors, batch_chunks):
+                    if isinstance(content, str):
+                        content_path_info = {"content path": content}
+                    elif isinstance(content, IOBase):
+                        content_path_info = {"content path": "From file bytes"}
+                    elif isinstance(content, Element):
+                        content_path_info = {
+                            "content path": content.metadata.file_directory
+                            or ""
+                        }
+                    chunk_metadata = {"metadata": chunk.metadata.to_dict()}
+                    chunk_text = {"text": str(chunk)}
+                    combined_dict = {
+                        **content_path_info,
+                        **chunk_metadata,
+                        **chunk_text,
                     }
-                chunk_metadata = {"metadata": chunk.metadata.to_dict()}
-                chunk_text = {"text": str(chunk)}
-                combined_dict = {
-                    **content_path_info,
-                    **chunk_metadata,
-                    **chunk_text,
-                }
 
-                records.append(
-                    VectorRecord(vector=vector, payload=combined_dict)
-                )
+                    records.append(
+                        VectorRecord(vector=vector, payload=combined_dict)
+                    )
 
-            self.storage.add(records=records)
+                self.storage.add(records=records)
 
     def query(
         self,
@@ -195,6 +199,13 @@ class VectorRetriever(BaseRetriever):
         db_query = VectorDBQuery(query_vector=query_vector, top_k=top_k)
         query_results = self.storage.query(query=db_query)
 
+        # If no results found, raise an error
+        if not query_results:
+            raise ValueError(
+                "Query result is empty, please check if "
+                "the vector storage is empty."
+            )
+
         if query_results[0].record.payload is None:
             raise ValueError(
                 "Payload of vector storage is None, please check the "

camel/societies/babyagi_playing.py

@@ -106,7 +106,7 @@ class BabyAGI:
         )
 
         self.assistant_agent: ChatAgent
-        self.assistant_sys_msg: BaseMessage
+        self.assistant_sys_msg: Optional[BaseMessage]
         self.task_creation_agent: TaskCreationAgent
         self.task_prioritization_agent: TaskPrioritizationAgent
         self.init_agents(
@@ -202,7 +202,8 @@ class BabyAGI:
 
         self.task_creation_agent = TaskCreationAgent(
             objective=self.specified_task_prompt,
-            role_name=self.assistant_sys_msg.role_name,
+            role_name=getattr(self.assistant_sys_msg, 'role_name', None)
+            or "assistant",
             output_language=output_language,
             message_window_size=message_window_size,
             **(task_creation_agent_kwargs or {}),
@@ -238,7 +239,9 @@ class BabyAGI:
 
         task_name = self.subtasks.popleft()
         assistant_msg_msg = BaseMessage.make_user_message(
-            role_name=self.assistant_sys_msg.role_name, content=f"{task_name}"
+            role_name=getattr(self.assistant_sys_msg, 'role_name', None)
+            or "assistant",
+            content=f"{task_name}",
         )
 
         assistant_response = self.assistant_agent.step(assistant_msg_msg)

camel/societies/role_playing.py

@@ -149,8 +149,8 @@ class RolePlaying:
 
         self.assistant_agent: ChatAgent
         self.user_agent: ChatAgent
-        self.assistant_sys_msg: BaseMessage
-        self.user_sys_msg: BaseMessage
+        self.assistant_sys_msg: Optional[BaseMessage]
+        self.user_sys_msg: Optional[BaseMessage]
         self._init_agents(
             init_assistant_sys_msg,
             init_user_sys_msg,
@@ -454,9 +454,11 @@ class RolePlaying:
         )
         if init_msg_content is None:
             init_msg_content = default_init_msg_content
+
         # Initialize a message sent by the assistant
         init_msg = BaseMessage.make_assistant_message(
-            role_name=self.assistant_sys_msg.role_name,
+            role_name=getattr(self.assistant_sys_msg, 'role_name', None)
+            or "assistant",
             content=init_msg_content,
         )
 

camel/storages/graph_storages/graph_element.py

@@ -20,7 +20,7 @@ from pydantic import BaseModel, ConfigDict, Field
 try:
     from unstructured.documents.elements import Element
 except ImportError:
-    Element = None
+    Element = None  # type:ignore[misc,assignment]
 
 
 class Node(BaseModel):
@@ -73,6 +73,6 @@ class GraphElement(BaseModel):
     source: Element
 
     def __post_init__(self):
-        if Element is None:
+        if "Element" not in globals():
             raise ImportError("""The 'unstructured' package is required to use
                               the 'source' attribute.""")

camel/storages/key_value_storages/json.py

@@ -18,7 +18,12 @@ from pathlib import Path
 from typing import Any, ClassVar, Dict, List, Optional
 
 from camel.storages.key_value_storages import BaseKeyValueStorage
-from camel.types import ModelType, OpenAIBackendRole, RoleType, TaskType
+from camel.types import (
+    ModelType,
+    OpenAIBackendRole,
+    RoleType,
+    TaskType,
+)
 
 
 class _CamelJSONEncoder(json.JSONEncoder):