camel-ai 0.2.0__py3-none-any.whl → 0.2.3__py3-none-any.whl

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

@@ -14,7 +14,16 @@
 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
@@ -27,10 +36,8 @@ from camel.storages import (
 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 +105,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,9 +117,10 @@ 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]
 
@@ -175,7 +185,7 @@ class AutoRetriever:
     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 +222,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:

camel/retrievers/vector_retriever.py

@@ -13,7 +13,8 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import os
 import warnings
-from typing import Any, Dict, List, Optional, Union
+from io import IOBase
+from typing import IO, TYPE_CHECKING, Any, Dict, List, Optional, Union
 from urllib.parse import urlparse
 
 from camel.embeddings import BaseEmbedding, OpenAIEmbedding
@@ -27,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):
@@ -72,75 +71,97 @@ class VectorRetriever(BaseRetriever):
 
     def process(
         self,
-        content: Union[str, Element],
+        content: Union[str, "Element", IO[bytes]],
         chunk_type: str = "chunk_by_title",
         max_characters: int = 500,
+        embed_batch: int = 50,
+        should_chunk: bool = True,
         **kwargs: Any,
     ) -> None:
-        r"""Processes content from a file or URL, divides it into chunks by
-        using `Unstructured IO`, and stores their embeddings in the specified
-        vector storage.
+        r"""Processes content from local file path, remote URL, string
+        content, Element object, or a binary file object, divides it into
+        chunks by using `Unstructured IO`, and stores their embeddings in the
+        specified vector storage.
 
         Args:
-            content (Union[str, Element]): Local file path, remote URL,
-                string content or Element object.
+            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".
             max_characters (int): Max number of characters in each chunk.
                 Defaults to `500`.
+            embed_batch (int): Size of batch for embeddings. Defaults to `50`.
+            should_chunk (bool): If True, divide the content into chunks,
+                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]
-        else:
+        elif isinstance(content, IOBase):
+            elements = self.uio.parse_bytes(file=content, **kwargs) or []
+        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 elements:
-            chunks = self.uio.chunk_elements(
-                chunk_type=chunk_type,
-                elements=elements,
-                max_characters=max_characters,
-            )
+
         if not elements:
             warnings.warn(
                 f"No elements were extracted from the content: {content}"
             )
-            return
-        # Iterate to process and store embeddings, set batch of 50
-        for i in range(0, len(chunks), 50):
-            batch_chunks = chunks[i : i + 50]
-            batch_vectors = self.embedding_model.embed_list(
-                objs=[str(chunk) for chunk in batch_chunks]
+        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
             )
 
-            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, Element):
-                    content_path_info = {
-                        "content path": content.metadata.file_directory
+            # 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
+                            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,
@@ -178,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

@@ -11,6 +11,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+import logging
 from typing import Dict, List, Optional, Sequence, Tuple, Union
 
 from camel.agents import (
@@ -27,6 +28,9 @@ from camel.prompts import TextPrompt
 from camel.responses import ChatAgentResponse
 from camel.types import RoleType, TaskType
 
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.WARNING)
+
 
 class RolePlaying:
     r"""Role playing between two agents.
@@ -97,6 +101,14 @@ class RolePlaying:
         extend_task_specify_meta_dict: Optional[Dict] = None,
         output_language: Optional[str] = None,
     ) -> None:
+        if model is not None:
+            logger.warning(
+                "The provided model will override the model settings in "
+                "all agents, including any configurations passed "
+                "through assistant_agent_kwargs, user_agent_kwargs, and "
+                "other agent-specific kwargs."
+            )
+
         self.with_task_specify = with_task_specify
         self.with_task_planner = with_task_planner
         self.with_critic_in_the_loop = with_critic_in_the_loop
@@ -137,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,
@@ -442,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/__init__.py

@@ -13,6 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
 from .graph_storages.base import BaseGraphStorage
+from .graph_storages.nebula_graph import NebulaGraph
 from .graph_storages.neo4j_graph import Neo4jGraph
 from .key_value_storages.base import BaseKeyValueStorage
 from .key_value_storages.in_memory import InMemoryKeyValueStorage
@@ -40,4 +41,5 @@ __all__ = [
     'MilvusStorage',
     'BaseGraphStorage',
     'Neo4jGraph',
+    'NebulaGraph',
 ]

camel/storages/graph_storages/__init__.py

@@ -14,10 +14,12 @@
 
 from .base import BaseGraphStorage
 from .graph_element import GraphElement
+from .nebula_graph import NebulaGraph
 from .neo4j_graph import Neo4jGraph
 
 __all__ = [
     'BaseGraphStorage',
     'GraphElement',
     'Neo4jGraph',
+    'NebulaGraph',
 ]

camel/storages/graph_storages/graph_element.py

@@ -13,14 +13,12 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from __future__ import annotations
 
-from typing import List, Union
+from typing import TYPE_CHECKING, List, Union
 
 from pydantic import BaseModel, ConfigDict, Field
 
-try:
+if TYPE_CHECKING:
     from unstructured.documents.elements import Element
-except ImportError:
-    Element = None
 
 
 class Node(BaseModel):
@@ -73,6 +71,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.""")