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

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
@@ -112,35 +110,12 @@ class AutoRetriever:
         Returns:
             str: A sanitized, valid collection name suitable for use.
         """
+
         if isinstance(content, Element):
             content = content.metadata.file_directory
 
-        # 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]
+        collection_name = re.sub(r'[^a-zA-Z0-9]', '', content)[:20]
 
-        # 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]
         return collection_name
 
     def _get_file_modified_date_from_file(

camel/toolkits/__init__.py

@@ -28,6 +28,7 @@ from .twitter_toolkit import TWITTER_FUNCS, TwitterToolkit
 from .weather_toolkit import WEATHER_FUNCS, WeatherToolkit
 from .slack_toolkit import SLACK_FUNCS, SlackToolkit
 from .dalle_toolkit import DALLE_FUNCS, DalleToolkit
+from .linkedin_toolkit import LINKEDIN_FUNCS, LinkedInToolkit
 
 from .base import BaseToolkit
 from .code_execution import CodeExecutionToolkit
@@ -47,6 +48,7 @@ __all__ = [
     'WEATHER_FUNCS',
     'SLACK_FUNCS',
     'DALLE_FUNCS',
+    'LINKEDIN_FUNCS',
     'BaseToolkit',
     'GithubToolkit',
     'MathToolkit',
@@ -58,5 +60,6 @@ __all__ = [
     'WeatherToolkit',
     'RetrievalToolkit',
     'OpenAPIToolkit',
+    'LinkedInToolkit',
     'CodeExecutionToolkit',
 ]

camel/toolkits/linkedin_toolkit.py

@@ -0,0 +1,230 @@
+# =========== 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 json
+import os
+from http import HTTPStatus
+from typing import List
+
+import requests
+
+from camel.toolkits import OpenAIFunction
+from camel.toolkits.base import BaseToolkit
+from camel.utils import handle_http_error
+
+LINKEDIN_POST_LIMIT = 1300
+
+
+class LinkedInToolkit(BaseToolkit):
+    r"""A class representing a toolkit for LinkedIn operations.
+
+    This class provides methods for creating a post, deleting a post, and
+    retrieving the authenticated user's profile information.
+    """
+
+    def __init__(self):
+        self._access_token = self._get_access_token()
+
+    def create_post(self, text: str) -> dict:
+        r"""Creates a post on LinkedIn for the authenticated user.
+
+        Args:
+            text (str): The content of the post to be created.
+
+        Returns:
+            dict: A dictionary containing the post ID and the content of
+                the post. If the post creation fails, the values will be None.
+
+        Raises:
+            Exception: If the post creation fails due to
+                       an error response from LinkedIn API.
+        """
+        url = 'https://api.linkedin.com/v2/ugcPosts'
+        urn = self.get_profile(include_id=True)
+
+        headers = {
+            'X-Restli-Protocol-Version': '2.0.0',
+            'Content-Type': 'application/json',
+            'Authorization': f'Bearer {self._access_token}',
+        }
+
+        post_data = {
+            "author": urn['id'],
+            "lifecycleState": "PUBLISHED",
+            "specificContent": {
+                "com.linkedin.ugc.ShareContent": {
+                    "shareCommentary": {"text": text},
+                    "shareMediaCategory": "NONE",
+                }
+            },
+            "visibility": {
+                "com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC"
+            },
+        }
+
+        response = requests.post(
+            url, headers=headers, data=json.dumps(post_data)
+        )
+        if response.status_code == 201:
+            post_response = response.json()
+            post_id = post_response.get('id', None)  # Get the ID of the post
+            return {'Post ID': post_id, 'Text': text}
+        else:
+            raise Exception(
+                f"Failed to create post. Status code: {response.status_code}, "
+                f"Response: {response.text}"
+            )
+
+    def delete_post(self, post_id: str) -> str:
+        r"""Deletes a LinkedIn post with the specified ID
+        for an authorized user.
+
+        This function sends a DELETE request to the LinkedIn API to delete
+        a post with the specified ID. Before sending the request, it
+        prompts the user to confirm the deletion.
+
+        Args:
+            post_id (str): The ID of the post to delete.
+
+        Returns:
+            str: A message indicating the result of the deletion. If the
+                deletion was successful, the message includes the ID of the
+                deleted post. If the deletion was not successful, the message
+                includes an error message.
+
+        Reference:
+            https://docs.microsoft.com/en-us/linkedin/marketing/integrations/community-management/shares/ugc-post-api
+        """
+        print(
+            "You are going to delete a LinkedIn post "
+            f"with the following ID: {post_id}"
+        )
+
+        confirm = input(
+            "Are you sure you want to delete this post? (yes/no): "
+        )
+        if confirm.lower() != "yes":
+            return "Execution cancelled by the user."
+
+        headers = {
+            "Authorization": f"Bearer {self._access_token}",
+            "Content-Type": "application/json",
+        }
+
+        response = requests.delete(
+            f"https://api.linkedin.com/v2/ugcPosts/{post_id}",
+            headers=headers,
+        )
+
+        if response.status_code != HTTPStatus.NO_CONTENT:
+            error_type = handle_http_error(response)
+            return (
+                f"Request returned a(n) {error_type!s}: "
+                f"{response.status_code!s} {response.text}"
+            )
+
+        return f"Post deleted successfully. Post ID: {post_id}."
+
+    def get_profile(self, include_id: bool = False) -> dict:
+        r"""Retrieves the authenticated user's LinkedIn profile info.
+
+        This function sends a GET request to the LinkedIn API to retrieve the
+        authenticated user's profile information. Optionally, it also returns
+        the user's LinkedIn ID.
+
+        Args:
+            include_id (bool): Whether to include the LinkedIn profile ID in
+                the response.
+
+        Returns:
+            dict: A dictionary containing the user's LinkedIn profile
+                information. If `include_id` is True, the dictionary will also
+                include the profile ID.
+
+        Raises:
+            Exception: If the profile retrieval fails due to an error response
+                from LinkedIn API.
+        """
+        headers = {
+            "Authorization": f"Bearer {self._access_token}",
+            'Connection': 'Keep-Alive',
+            'Content-Type': 'application/json',
+            "X-Restli-Protocol-Version": "2.0.0",
+        }
+
+        response = requests.get(
+            "https://api.linkedin.com/v2/userinfo",
+            headers=headers,
+        )
+
+        if response.status_code != HTTPStatus.OK:
+            raise Exception(
+                f"Failed to retrieve profile. "
+                f"Status code: {response.status_code}, "
+                f"Response: {response.text}"
+            )
+
+        json_response = response.json()
+
+        locale = json_response.get('locale', {})
+        country = locale.get('country', 'N/A')
+        language = locale.get('language', 'N/A')
+
+        profile_report = {
+            "Country": country,
+            "Language": language,
+            "First Name": json_response.get('given_name'),
+            "Last Name": json_response.get('family_name'),
+            "Email": json_response.get('email'),
+        }
+
+        if include_id:
+            profile_report['id'] = f"urn:li:person:{json_response['sub']}"
+
+        return profile_report
+
+    def get_tools(self) -> List[OpenAIFunction]:
+        r"""Returns a list of OpenAIFunction objects representing the
+        functions in the toolkit.
+
+        Returns:
+            List[OpenAIFunction]: A list of OpenAIFunction objects
+                representing the functions in the toolkit.
+        """
+        return [
+            OpenAIFunction(self.create_post),
+            OpenAIFunction(self.delete_post),
+            OpenAIFunction(self.get_profile),
+        ]
+
+    def _get_access_token(self) -> str:
+        r"""Fetches the access token required for making LinkedIn API requests.
+
+        Returns:
+            str: The OAuth 2.0 access token or warming message if the
+                environment variable `LINKEDIN_ACCESS_TOKEN` is not set or is
+                empty.
+
+        Reference:
+            You can apply for your personal LinkedIn API access token through
+            the link below:
+            https://www.linkedin.com/developers/apps
+        """
+        token = os.getenv("LINKEDIN_ACCESS_TOKEN")
+        if not token:
+            return "Access token not found. Please set LINKEDIN_ACCESS_TOKEN."
+        return token
+
+
+LINKEDIN_FUNCS: List[OpenAIFunction] = LinkedInToolkit().get_tools()

camel/types/enums.py

@@ -81,13 +81,16 @@ class ModelType(Enum):
     MISTRAL_MIXTRAL_8x22B = "open-mixtral-8x22b"
     MISTRAL_CODESTRAL_MAMBA = "open-codestral-mamba"
 
+    # SambaNova Model
+    SAMBA_LLAMA_3_1_405B = "llama3-405b"
+    SAMBA_LLAMA_3_1_70B = "llama3-70b"
+    SAMBA_LLAMA_3_1_8B = "llama3-8b"
+
     @property
     def value_for_tiktoken(self) -> str:
-        return (
-            self.value
-            if self is not ModelType.STUB and not isinstance(self, str)
-            else "gpt-3.5-turbo"
-        )
+        if self.is_openai:
+            return self.value
+        return "gpt-3.5-turbo"
 
     @property
     def is_openai(self) -> bool:
@@ -192,6 +195,14 @@ class ModelType(Enum):
     def is_gemini(self) -> bool:
         return self in {ModelType.GEMINI_1_5_FLASH, ModelType.GEMINI_1_5_PRO}
 
+    @property
+    def is_samba(self) -> bool:
+        return self in {
+            ModelType.SAMBA_LLAMA_3_1_405B,
+            ModelType.SAMBA_LLAMA_3_1_70B,
+            ModelType.SAMBA_LLAMA_3_1_8B,
+        }
+
     @property
     def token_limit(self) -> int:
         r"""Returns the maximum token limit for a given model.
@@ -251,6 +262,9 @@ class ModelType(Enum):
             ModelType.GROQ_LLAMA_3_1_8B,
             ModelType.GROQ_LLAMA_3_1_70B,
             ModelType.GROQ_LLAMA_3_1_405B,
+            ModelType.SAMBA_LLAMA_3_1_405B,
+            ModelType.SAMBA_LLAMA_3_1_70B,
+            ModelType.SAMBA_LLAMA_3_1_8B,
         }:
             return 131_072
         elif self in {
@@ -444,7 +458,9 @@ class ModelPlatformType(Enum):
     GEMINI = "gemini"
     VLLM = "vllm"
     MISTRAL = "mistral"
+    TOGETHER = "together"
     OPENAI_COMPATIBILITY_MODEL = "openai-compatibility-model"
+    SAMBA = "samba-nova"
 
     @property
     def is_openai(self) -> bool:
@@ -476,6 +492,11 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is vllm."""
         return self is ModelPlatformType.VLLM
 
+    @property
+    def is_together(self) -> bool:
+        r"""Returns whether this platform is together."""
+        return self is ModelPlatformType.TOGETHER
+
     @property
     def is_litellm(self) -> bool:
         r"""Returns whether this platform is litellm."""
@@ -507,6 +528,11 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is Gemini."""
         return self is ModelPlatformType.GEMINI
 
+    @property
+    def is_samba(self) -> bool:
+        r"""Returns whether this platform is Samba Nova."""
+        return self is ModelPlatformType.SAMBA
+
 
 class AudioModelType(Enum):
     TTS_1 = "tts-1"

camel/utils/__init__.py

@@ -27,6 +27,7 @@ from .commons import (
     get_pydantic_object_schema,
     get_system_information,
     get_task_list,
+    handle_http_error,
     is_docker_running,
     json_to_function_code,
     print_text_animated,
@@ -76,4 +77,5 @@ __all__ = [
     'agentops_decorator',
     'AgentOpsMeta',
     'track_agent',
+    'handle_http_error',
 ]

camel/utils/commons.py

@@ -20,6 +20,7 @@ import subprocess
 import time
 import zipfile
 from functools import wraps
+from http import HTTPStatus
 from typing import (
     Any,
     Callable,
@@ -547,3 +548,24 @@ def track_agent(*args, **kwargs):
         return f
 
     return noop
+
+
+def handle_http_error(response: requests.Response) -> str:
+    r"""Handles the HTTP errors based on the status code of the response.
+
+    Args:
+        response (requests.Response): The HTTP response from the API call.
+
+    Returns:
+        str: The error type, based on the status code.
+    """
+    if response.status_code == HTTPStatus.UNAUTHORIZED:
+        return "Unauthorized. Check your access token."
+    elif response.status_code == HTTPStatus.FORBIDDEN:
+        return "Forbidden. You do not have permission to perform this action."
+    elif response.status_code == HTTPStatus.NOT_FOUND:
+        return "Not Found. The resource could not be located."
+    elif response.status_code == HTTPStatus.TOO_MANY_REQUESTS:
+        return "Too Many Requests. You have hit the rate limit."
+    else:
+        return "HTTP Error"

{camel_ai-0.1.6.6.dist-info → camel_ai-0.1.6.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: camel-ai
-Version: 0.1.6.6
+Version: 0.1.6.7
 Summary: Communicative Agents for AI Society Study
 Home-page: https://www.camel-ai.org/
 License: Apache-2.0
@@ -202,7 +202,7 @@ conda create --name camel python=3.9
 conda activate camel
 
 # Clone github repo
-git clone -b v0.1.6.6 https://github.com/camel-ai/camel.git
+git clone -b v0.1.6.7 https://github.com/camel-ai/camel.git
 
 # Change directory into project directory
 cd camel