camel-ai 0.1.6.5__py3-none-any.whl → 0.1.6.7__py3-none-any.whl

camel/models/samba_model.py

@@ -0,0 +1,291 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+import os
+from typing import Any, Dict, List, Optional, Union
+
+from openai import OpenAI, Stream
+
+from camel.configs import SAMBA_API_PARAMS
+from camel.messages import OpenAIMessage
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    api_keys_required,
+)
+
+
+class SambaModel:
+    r"""SambaNova service interface."""
+
+    def __init__(
+        self,
+        model_type: ModelType,
+        model_config_dict: Dict[str, Any],
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
+    ) -> None:
+        r"""Constructor for SambaNova backend.
+
+        Args:
+            model_type (ModelType): Model for which a SambaNova backend is
+                created.
+            model_config_dict (Dict[str, Any]): A dictionary that will
+                be fed into API request.
+            api_key (Optional[str]): The API key for authenticating with the
+                SambaNova service. (default: :obj:`None`)
+            url (Optional[str]): The url to the SambaNova service. (default:
+                :obj:`"https://fast-api.snova.ai/v1/chat/completions"`)
+            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._api_key = api_key or os.environ.get("SAMBA_API_KEY")
+        self._url = url or os.environ.get("SAMBA_API_BASE_URL")
+        self._token_counter = token_counter
+        self.model_config_dict = model_config_dict
+        self.check_model_config()
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            BaseTokenCounter: The token counter following the model's
+                tokenization style.
+        """
+        if not self._token_counter:
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
+        return self._token_counter
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to SambaNova API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to SambaNova API.
+        """
+        for param in self.model_config_dict:
+            if param not in SAMBA_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into SambaNova model backend."
+                )
+
+    @api_keys_required("SAMBA_API_KEY")
+    def run(  # type: ignore[misc]
+        self, messages: List[OpenAIMessage]
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs SambaNova's FastAPI service.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `Stream[ChatCompletionChunk]` in the stream mode.
+        """
+
+        if self.model_config_dict.get("stream") is True:
+            return self._run_streaming(messages)
+        else:
+            return self._run_non_streaming(messages)
+
+    def _run_streaming(  # type: ignore[misc]
+        self, messages: List[OpenAIMessage]
+    ) -> Stream[ChatCompletionChunk]:
+        r"""Handles streaming inference with SambaNova FastAPI.
+
+        Args:
+            messages (List[OpenAIMessage]): A list of messages representing the
+                chat history in OpenAI API format.
+
+        Returns:
+            Stream[ChatCompletionChunk]: A generator yielding
+                `ChatCompletionChunk` objects as they are received from the
+                API.
+
+        Raises:
+            RuntimeError: If the HTTP request fails.
+        """
+
+        import httpx
+
+        headers = {
+            "Authorization": f"Basic {self._api_key}",
+            "Content-Type": "application/json",
+        }
+
+        data = {
+            "messages": messages,
+            "max_tokens": self.token_limit,
+            "stop": self.model_config_dict.get("stop"),
+            "model": self.model_type.value,
+            "stream": True,
+            "stream_options": self.model_config_dict.get("stream_options"),
+        }
+
+        try:
+            with httpx.stream(
+                "POST",
+                self._url or "https://fast-api.snova.ai/v1/chat/completions",
+                headers=headers,
+                json=data,
+            ) as api_response:
+                stream = Stream[ChatCompletionChunk](
+                    cast_to=ChatCompletionChunk,
+                    response=api_response,
+                    client=OpenAI(),
+                )
+                for chunk in stream:
+                    yield chunk
+        except httpx.HTTPError as e:
+            raise RuntimeError(f"HTTP request failed: {e!s}")
+
+    def _run_non_streaming(
+        self, messages: List[OpenAIMessage]
+    ) -> ChatCompletion:
+        r"""Handles non-streaming inference with SambaNova FastAPI.
+
+        Args:
+            messages (List[OpenAIMessage]): A list of messages representing the
+                message in OpenAI API format.
+
+        Returns:
+            ChatCompletion: A `ChatCompletion` object containing the complete
+                response from the API.
+
+        Raises:
+            RuntimeError: If the HTTP request fails.
+            ValueError: If the JSON response cannot be decoded or is missing
+                expected data.
+        """
+
+        import json
+
+        import httpx
+
+        headers = {
+            "Authorization": f"Basic {self._api_key}",
+            "Content-Type": "application/json",
+        }
+
+        data = {
+            "messages": messages,
+            "max_tokens": self.token_limit,
+            "stop": self.model_config_dict.get("stop"),
+            "model": self.model_type.value,
+            "stream": True,
+            "stream_options": self.model_config_dict.get("stream_options"),
+        }
+
+        try:
+            with httpx.stream(
+                "POST",
+                self._url or "https://fast-api.snova.ai/v1/chat/completions",
+                headers=headers,
+                json=data,
+            ) as api_response:
+                samba_response = []
+                for chunk in api_response.iter_text():
+                    if chunk.startswith('data: '):
+                        chunk = chunk[6:]
+                    if '[DONE]' in chunk:
+                        break
+                    json_data = json.loads(chunk)
+                    samba_response.append(json_data)
+                return self._to_openai_response(samba_response)
+        except httpx.HTTPError as e:
+            raise RuntimeError(f"HTTP request failed: {e!s}")
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Failed to decode JSON response: {e!s}")
+
+    def _to_openai_response(
+        self, samba_response: List[Dict[str, Any]]
+    ) -> ChatCompletion:
+        r"""Converts SambaNova response chunks into an OpenAI-compatible
+        response.
+
+        Args:
+            samba_response (List[Dict[str, Any]]): A list of dictionaries
+                representing partial responses from the SambaNova API.
+
+        Returns:
+            ChatCompletion: A `ChatCompletion` object constructed from the
+                aggregated response data.
+
+        Raises:
+            ValueError: If the response data is invalid or incomplete.
+        """
+        # Step 1: Combine the content from each chunk
+        full_content = ""
+        for chunk in samba_response:
+            if chunk['choices']:
+                for choice in chunk['choices']:
+                    delta_content = choice['delta'].get('content', '')
+                    full_content += delta_content
+
+        # Step 2: Create the ChatCompletion object
+        # Extract relevant information from the first chunk
+        first_chunk = samba_response[0]
+
+        choices = [
+            dict(
+                index=0,  # type: ignore[index]
+                message={
+                    "role": 'assistant',
+                    "content": full_content.strip(),
+                },
+                finish_reason=samba_response[-1]['choices'][0]['finish_reason']
+                or None,
+            )
+        ]
+
+        obj = ChatCompletion.construct(
+            id=first_chunk['id'],
+            choices=choices,
+            created=first_chunk['created'],
+            model=first_chunk['model'],
+            object="chat.completion",
+            usage=None,
+        )
+
+        return obj
+
+    @property
+    def token_limit(self) -> int:
+        r"""Returns the maximum token limit for a given model.
+
+        Returns:
+            int: The maximum token limit for the given model.
+        """
+        return (
+            self.model_config_dict.get("max_tokens")
+            or self.model_type.token_limit
+        )
+
+    @property
+    def stream(self) -> bool:
+        r"""Returns whether the model is in stream mode, which sends partial
+        results each time.
+
+        Returns:
+            bool: Whether the model is in stream mode.
+        """
+        return self.model_config_dict.get('stream', False)

camel/models/togetherai_model.py

@@ -0,0 +1,148 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+
+import os
+from typing import Any, Dict, List, Optional, Union
+
+from openai import OpenAI, Stream
+
+from camel.configs import TOGETHERAI_API_PARAMS
+from camel.messages import OpenAIMessage
+from camel.types import ChatCompletion, ChatCompletionChunk, ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    api_keys_required,
+)
+
+
+class TogetherAIModel:
+    r"""Constructor for Together AI backend with OpenAI compatibility.
+    TODO: Add function calling support
+    """
+
+    def __init__(
+        self,
+        model_type: str,
+        model_config_dict: Dict[str, Any],
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
+    ) -> None:
+        r"""Constructor for TogetherAI backend.
+
+        Args:
+            model_type (str): Model for which a backend is created, supported
+                model can be found here: https://docs.together.ai/docs/chat-models
+            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
+                Together service. (default: :obj:`None`)
+            url (Optional[str]): The url to the Together AI service. (default:
+                :obj:`"https://api.together.xyz/v1"`)
+            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._token_counter = token_counter
+        self._api_key = api_key or os.environ.get("TOGETHER_API_KEY")
+        self._url = url or os.environ.get("TOGETHER_API_BASE_URL")
+
+        self._client = OpenAI(
+            timeout=60,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url or "https://api.together.xyz/v1",
+        )
+
+    @api_keys_required("TOGETHER_API_KEY")
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs inference of OpenAI chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `Stream[ChatCompletionChunk]` in the stream mode.
+        """
+        # Use OpenAI cilent as interface call Together AI
+        # Reference: https://docs.together.ai/docs/openai-api-compatibility
+        response = self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **self.model_config_dict,
+        )
+        return response
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            OpenAITokenCounter: The token counter following the model's
+                tokenization style.
+        """
+
+        if not self._token_counter:
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
+        return self._token_counter
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to TogetherAI API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to TogetherAI API.
+        """
+        for param in self.model_config_dict:
+            if param not in TOGETHERAI_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into TogetherAI model backend."
+                )
+
+    @property
+    def stream(self) -> bool:
+        r"""Returns whether the model is in stream mode, which sends partial
+        results each time.
+
+        Returns:
+            bool: Whether the model is in stream mode.
+        """
+        return self.model_config_dict.get('stream', False)
+
+    @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

camel/models/vllm_model.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 os
 from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
@@ -42,20 +43,21 @@ class VLLMModel:
             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:`None`)
+                :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_3_5_TURBO)` will be used.
+                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")
         # Use OpenAI cilent as interface call vLLM
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
-            base_url=url,
+            base_url=self._url or "http://localhost:8000/v1",
             api_key=api_key,
         )
         self._token_counter = token_counter
@@ -70,7 +72,7 @@ class VLLMModel:
                 tokenization style.
         """
         if not self._token_counter:
-            self._token_counter = OpenAITokenCounter(ModelType.GPT_3_5_TURBO)
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
         return self._token_counter
 
     def check_model_config(self):
@@ -113,7 +115,7 @@ class VLLMModel:
 
     @property
     def token_limit(self) -> int:
-        """Returns the maximum token limit for the given model.
+        r"""Returns the maximum token limit for the given model.
 
         Returns:
             int: The maximum token limit for the given model.

camel/models/zhipuai_model.py

@@ -52,7 +52,7 @@ class ZhipuAIModel(BaseModelBackend):
                 :obj:`None`)
             token_counter (Optional[BaseTokenCounter]): Token counter to use
                 for the model. If not provided, `OpenAITokenCounter(ModelType.
-                GPT_3_5_TURBO)` will be used.
+                GPT_4O_MINI)` will be used.
         """
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
@@ -105,7 +105,7 @@ class ZhipuAIModel(BaseModelBackend):
         """
 
         if not self._token_counter:
-            self._token_counter = OpenAITokenCounter(ModelType.GPT_3_5_TURBO)
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
         return self._token_counter
 
     def check_model_config(self):

camel/retrievers/auto_retriever.py

@@ -14,9 +14,7 @@
 import datetime
 import os
 import re
-from pathlib import Path
 from typing import Collection, List, Optional, Sequence, Tuple, Union
-from urllib.parse import urlparse
 
 from camel.embeddings import BaseEmbedding, OpenAIEmbedding
 from camel.retrievers.vector_retriever import VectorRetriever
@@ -28,6 +26,11 @@ from camel.storages import (
 )
 from camel.types import StorageType
 
+try:
+    from unstructured.documents.elements import Element
+except ImportError:
+    Element = None
+
 DEFAULT_TOP_K_RESULTS = 1
 DEFAULT_SIMILARITY_THRESHOLD = 0.75
 
@@ -97,41 +100,22 @@ class AutoRetriever:
             f"Unsupported vector storage type: {self.storage_type}"
         )
 
-    def _collection_name_generator(self, content: str) -> 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:
-            contents (str): Local file path, remote URL or string content.
+            content (Union[str, Element]): Local file path, remote URL,
+                string content or Element object.
 
         Returns:
             str: A sanitized, valid collection name suitable for use.
         """
-        # Check if the content is URL
-        parsed_url = urlparse(content)
-        is_url = all([parsed_url.scheme, parsed_url.netloc])
-
-        # Convert given path into a collection name, ensuring it only
-        # contains numbers, letters, and underscores
-        if is_url:
-            # For URLs, remove https://, replace /, and any characters not
-            # allowed by Milvus with _
-            collection_name = re.sub(
-                r'[^0-9a-zA-Z]+',
-                '_',
-                content.replace("https://", ""),
-            )
-        elif os.path.exists(content):
-            # For file paths, get the stem and replace spaces with _, also
-            # ensuring only allowed characters are present
-            collection_name = re.sub(r'[^0-9a-zA-Z]+', '_', Path(content).stem)
-        else:
-            # the content is string input
-            collection_name = content[:10]
 
-        # Ensure the collection name does not start or end with underscore
-        collection_name = collection_name.strip("_")
-        # Limit the maximum length of the collection name to 30 characters
-        collection_name = collection_name[:30]
+        if isinstance(content, Element):
+            content = content.metadata.file_directory
+
+        collection_name = re.sub(r'[^a-zA-Z0-9]', '', content)[:20]
+
         return collection_name
 
     def _get_file_modified_date_from_file(
@@ -193,7 +177,7 @@ class AutoRetriever:
     def run_vector_retriever(
         self,
         query: str,
-        contents: Union[str, List[str]],
+        contents: Union[str, List[str], Element, List[Element]],
         top_k: int = DEFAULT_TOP_K_RESULTS,
         similarity_threshold: float = DEFAULT_SIMILARITY_THRESHOLD,
         return_detailed_info: bool = False,
@@ -203,8 +187,8 @@ class AutoRetriever:
 
         Args:
             query (str): Query string for information retriever.
-            contents (Union[str, List[str]]): Local file paths, remote URLs or
-                string contents.
+            contents (Union[str, List[str], Element, List[Element]]): Local
+                file paths, remote URLs, string contents or Element objects.
             top_k (int, optional): The number of top results to return during
                 retrieve. Must be a positive integer. Defaults to
                 `DEFAULT_TOP_K_RESULTS`.
@@ -230,7 +214,9 @@ class AutoRetriever:
         if not contents:
             raise ValueError("content cannot be empty.")
 
-        contents = [contents] if isinstance(contents, str) else contents
+        contents = (
+            [contents] if isinstance(contents, (str, Element)) else contents
+        )
 
         all_retrieved_info = []
         for content in contents:
@@ -246,6 +232,7 @@ class AutoRetriever:
                 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

camel/retrievers/vector_retriever.py

@@ -13,7 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import os
 import warnings
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Union
 from urllib.parse import urlparse
 
 from camel.embeddings import BaseEmbedding, OpenAIEmbedding
@@ -26,6 +26,11 @@ from camel.storages import (
     VectorRecord,
 )
 
+try:
+    from unstructured.documents.elements import Element
+except ImportError:
+    Element = None
+
 DEFAULT_TOP_K_RESULTS = 1
 DEFAULT_SIMILARITY_THRESHOLD = 0.75
 
@@ -69,7 +74,7 @@ class VectorRetriever(BaseRetriever):
 
     def process(
         self,
-        content: str,
+        content: Union[str, Element],
         chunk_type: str = "chunk_by_title",
         **kwargs: Any,
     ) -> None:
@@ -78,18 +83,22 @@ class VectorRetriever(BaseRetriever):
         vector storage.
 
         Args:
-            contents (str): Local file path, remote URL or string content.
+            content (Union[str, Element]): Local file path, remote URL,
+                string content or Element object.
             chunk_type (str): Type of chunking going to apply. Defaults to
                 "chunk_by_title".
             **kwargs (Any): Additional keyword arguments for content parsing.
         """
-        # 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)
+        if isinstance(content, Element):
+            elements = [content]
         else:
-            elements = [self.uio.create_element_from_text(text=content)]
+            # 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 []
+            else:
+                elements = [self.uio.create_element_from_text(text=content)]
         if elements:
             chunks = self.uio.chunk_elements(
                 chunk_type=chunk_type, elements=elements
@@ -110,7 +119,12 @@ class VectorRetriever(BaseRetriever):
             # 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):
-                content_path_info = {"content path": content}
+                if isinstance(content, str):
+                    content_path_info = {"content path": content}
+                elif isinstance(content, Element):
+                    content_path_info = {
+                        "content path": content.metadata.file_directory
+                    }
                 chunk_metadata = {"metadata": chunk.metadata.to_dict()}
                 chunk_text = {"text": str(chunk)}
                 combined_dict = {