camel-ai 0.2.3a1__py3-none-any.whl → 0.2.3a2__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

@@ -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

@@ -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

@@ -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.""")

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):

camel/toolkits/__init__.py

@@ -12,29 +12,37 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 # ruff: noqa: I001
-from .openai_function import (
+from .function_tool import (
+    FunctionTool,
     OpenAIFunction,
     get_openai_function_schema,
     get_openai_tool_schema,
 )
 from .open_api_specs.security_config import openapi_security_config
 
-from .google_maps_toolkit import GoogleMapsToolkit
+
 from .math_toolkit import MathToolkit, MATH_FUNCS
-from .open_api_toolkit import OpenAPIToolkit
-from .retrieval_toolkit import RetrievalToolkit
 from .search_toolkit import SearchToolkit, SEARCH_FUNCS
-from .twitter_toolkit import TwitterToolkit
 from .weather_toolkit import WeatherToolkit, WEATHER_FUNCS
-from .slack_toolkit import SlackToolkit
 from .dalle_toolkit import DalleToolkit, DALLE_FUNCS
+from .ask_news_toolkit import AskNewsToolkit, AsyncAskNewsToolkit
+
 from .linkedin_toolkit import LinkedInToolkit
 from .reddit_toolkit import RedditToolkit
-
+from .base import BaseToolkit
+from .google_maps_toolkit import GoogleMapsToolkit
 from .code_execution import CodeExecutionToolkit
 from .github_toolkit import GithubToolkit
+from .google_scholar_toolkit import GoogleScholarToolkit
+from .arxiv_toolkit import ArxivToolkit
+from .slack_toolkit import SlackToolkit
+from .twitter_toolkit import TwitterToolkit, TWITTER_FUNCS
+from .open_api_toolkit import OpenAPIToolkit
+from .retrieval_toolkit import RetrievalToolkit
 
 __all__ = [
+    'BaseToolkit',
+    'FunctionTool',
     'OpenAIFunction',
     'get_openai_function_schema',
     'get_openai_tool_schema',
@@ -52,8 +60,13 @@ __all__ = [
     'LinkedInToolkit',
     'RedditToolkit',
     'CodeExecutionToolkit',
+    'AskNewsToolkit',
+    'AsyncAskNewsToolkit',
+    'GoogleScholarToolkit',
+    'ArxivToolkit',
     'MATH_FUNCS',
     'SEARCH_FUNCS',
     'WEATHER_FUNCS',
     'DALLE_FUNCS',
+    'TWITTER_FUNCS',
 ]