camel-ai 0.2.10__py3-none-any.whl → 0.2.11__py3-none-any.whl

camel/messages/conversion/alpaca.py

@@ -0,0 +1,122 @@
+# ========= Copyright 2023-2024 @ 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-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+import re
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class AlpacaItem(BaseModel):
+    r"""Represents an instruction-response item in the Alpaca format.
+
+    Appropripate for both cases where input field is empty, or populated.
+    Provides parsing from string format using the class method from_string().
+
+    Args:
+        instruction (str): The instruction/question/prompt
+        input (str): Input context or examples (put empty string if none)
+        output (str): The response/answer to the instruction
+    """
+
+    instruction: str = Field(description="The instruction/question/prompt")
+    input: str = Field(
+        description="Optional context or input for the task."
+        " For example, when the instruction is \"Summarize the "
+        "following article\", the input is the article."
+    )
+    output: str = Field(description="The response/answer to the instruction")
+
+    @field_validator('instruction', 'output')
+    def no_section_markers(cls, value: str) -> str:
+        r"""Ensures fields don't contain section markers like '###
+        Response:'
+        """
+        if (
+            '### Response' in value
+            or '### Instruction' in value
+            or '### Input' in value
+        ):
+            raise ValueError("Field cannot contain section markers")
+        return value.strip()
+
+    @classmethod
+    def from_string(cls, text: str) -> "AlpacaItem":
+        r"""Creates an AlpacaItem from a formatted string.
+
+        Args:
+            text: String in either of these formats:
+                 With input:
+                 ### Instruction:
+                 {instruction}
+                 ### Input:
+                 {input}
+                 ### Response:
+                 {response}
+
+                 Without input:
+                 ### Instruction:
+                 {instruction}
+                 ### Response:
+                 {response}
+
+        Returns:
+            AlpacaItem: Parsed instance
+
+        Raises:
+            ValueError: text doesn't match expected format or sections missing
+        """
+        # Strip and standardize newlines
+        text = text.strip().replace('\r\n', '\n')
+
+        # Try to extract sections using regex
+        instruction_match = re.search(
+            r'###\s*Instruction:\s*\n(.+?)(?=\n###|\Z)', text, re.DOTALL
+        )
+        input_match = re.search(
+            r'###\s*Input:\s*\n(.+?)(?=\n###|\Z)', text, re.DOTALL
+        )
+        response_match = re.search(
+            r'###\s*Response:\s*\n(.+?)(?=\n###|\Z)', text, re.DOTALL
+        )
+
+        if not instruction_match or not response_match:
+            raise ValueError(
+                "Text must contain '### Instruction:'"
+                " and '### Response:' sections"
+            )
+
+        return cls(
+            instruction=instruction_match.group(1).strip(),
+            input=input_match.group(1).strip() if input_match else "",
+            output=response_match.group(1).strip(),
+        )
+
+    def to_string(self) -> str:
+        r"""Converts the AlpacaItem to its string representation.
+
+        Returns:
+            str: Formatted string representation with sections markers
+        """
+        return "\n".join(
+            [
+                "### Instruction:",
+                self.instruction,
+                "",
+                "### Input:",
+                self.input,
+                "",
+                "### Response:",
+                self.output,
+            ]
+        )

camel/models/__init__.py

@@ -21,7 +21,9 @@ from .groq_model import GroqModel
 from .litellm_model import LiteLLMModel
 from .mistral_model import MistralModel
 from .model_factory import ModelFactory
+from .model_manager import ModelManager, ModelProcessingError
 from .nemotron_model import NemotronModel
+from .nvidia_model import NvidiaModel
 from .ollama_model import OllamaModel
 from .openai_audio_models import OpenAIAudioModels
 from .openai_compatible_model import OpenAICompatibleModel
@@ -46,9 +48,11 @@ __all__ = [
     'ZhipuAIModel',
     'CohereModel',
     'ModelFactory',
+    'ModelManager',
     'LiteLLMModel',
     'OpenAIAudioModels',
     'NemotronModel',
+    'NvidiaModel',
     'OllamaModel',
     'VLLMModel',
     'GeminiModel',
@@ -58,5 +62,6 @@ __all__ = [
     'TogetherAIModel',
     'YiModel',
     'QwenModel',
+    'ModelProcessingError',
     'DeepSeekModel',
 ]

camel/models/model_factory.py

@@ -22,6 +22,7 @@ from camel.models.gemini_model import GeminiModel
 from camel.models.groq_model import GroqModel
 from camel.models.litellm_model import LiteLLMModel
 from camel.models.mistral_model import MistralModel
+from camel.models.nvidia_model import NvidiaModel
 from camel.models.ollama_model import OllamaModel
 from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.models.openai_model import OpenAIModel
@@ -93,6 +94,8 @@ class ModelFactory:
             model_class = TogetherAIModel
         elif model_platform.is_litellm:
             model_class = LiteLLMModel
+        elif model_platform.is_nvidia:
+            model_class = NvidiaModel
 
         elif model_platform.is_openai and model_type.is_openai:
             model_class = OpenAIModel

camel/models/model_manager.py

@@ -0,0 +1,212 @@
+# ========= Copyright 2023-2024 @ 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-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+import logging
+from itertools import cycle
+from random import choice
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Union,
+)
+
+from openai import Stream
+
+from camel.messages import OpenAIMessage
+from camel.models.base_model import BaseModelBackend
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    UnifiedModelType,
+)
+from camel.utils import BaseTokenCounter
+
+logger = logging.getLogger(__name__)
+
+
+class ModelProcessingError(Exception):
+    r"""Raised when an error occurs during model processing."""
+
+    pass
+
+
+class ModelManager:
+    r"""ModelManager choosing a model from provided list.
+    Models are picked according to defined strategy.
+
+    Args:
+        models(Union[BaseModelBackend, List[BaseModelBackend]]):
+            model backend or list of model backends
+            (e.g., model instances, APIs)
+        scheduling_strategy (str): name of function that defines how
+            to select the next model. (default: :str:`round_robin`)
+    """
+
+    def __init__(
+        self,
+        models: Union[BaseModelBackend, List[BaseModelBackend]],
+        scheduling_strategy: str = "round_robin",
+    ):
+        if isinstance(models, list):
+            self.models = models
+        else:
+            self.models = [models]
+        self.models_cycle = cycle(self.models)
+        self.current_model = self.models[0]
+
+        # Set the scheduling strategy; default is round-robin
+        try:
+            self.scheduling_strategy = getattr(self, scheduling_strategy)
+        except AttributeError:
+            logger.warning(
+                f"Provided strategy: {scheduling_strategy} is not implemented."
+                f"Using default 'round robin'"
+            )
+            self.scheduling_strategy = self.round_robin
+
+    @property
+    def model_type(self) -> UnifiedModelType:
+        r"""Return type of the current model.
+
+        Returns:
+            Union[ModelType, str]: Current model type.
+        """
+        return self.current_model.model_type
+
+    @property
+    def model_config_dict(self) -> Dict[str, Any]:
+        r"""Return model_config_dict of the current model.
+
+        Returns:
+            Dict[str, Any]: Config dictionary of the current model.
+        """
+        return self.current_model.model_config_dict
+
+    @model_config_dict.setter
+    def model_config_dict(self, model_config_dict: Dict[str, Any]):
+        r"""Set model_config_dict to the current model.
+
+        Args:
+            model_config_dict (Dict[str, Any]): Config dictionary to be set at
+                current model.
+        """
+        self.current_model.model_config_dict = model_config_dict
+
+    @property
+    def current_model_index(self) -> int:
+        r"""Return the index of current model in self.models list.
+
+        Returns:
+            int: index of current model in given list of models.
+        """
+        return self.models.index(self.current_model)
+
+    @property
+    def token_limit(self):
+        r"""Returns the maximum token limit for current model.
+
+        This method retrieves the maximum token limit either from the
+        `model_config_dict` or from the model's default token limit.
+
+        Returns:
+            int: The maximum token limit for the given model.
+        """
+        return self.current_model.token_limit
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Return token_counter of the current model.
+
+        Returns:
+            BaseTokenCounter: The token counter following the model's
+                tokenization style.
+        """
+        return self.current_model.token_counter
+
+    def add_strategy(self, name: str, strategy_fn: Callable):
+        r"""Add a scheduling strategy method provided by user in case when none
+            of existent strategies fits.
+            When custom strategy is provided, it will be set as
+            "self.scheduling_strategy" attribute.
+
+        Args:
+            name (str): The name of the strategy.
+            strategy_fn (Callable): The scheduling strategy function.
+        """
+        if not callable(strategy_fn):
+            raise ValueError("strategy_fn must be a callable function.")
+        setattr(self, name, strategy_fn.__get__(self))
+        self.scheduling_strategy = getattr(self, name)
+        logger.info(f"Custom strategy '{name}' added.")
+
+    # Strategies
+    def round_robin(self) -> BaseModelBackend:
+        r"""Return models one by one in simple round-robin fashion.
+
+        Returns:
+             BaseModelBackend for processing incoming messages.
+        """
+        return next(self.models_cycle)
+
+    def always_first(self) -> BaseModelBackend:
+        r"""Always return the first model from self.models.
+
+        Returns:
+            BaseModelBackend for processing incoming messages.
+        """
+        return self.models[0]
+
+    def random_model(self) -> BaseModelBackend:
+        r"""Return random model from self.models list.
+
+        Returns:
+             BaseModelBackend for processing incoming messages.
+        """
+        return choice(self.models)
+
+    def run(
+        self, messages: List[OpenAIMessage]
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Process a list of messages by selecting a model based on
+            the scheduling strategy.
+            Sends the entire list of messages to the selected model,
+            and returns a single response.
+
+        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.
+        """
+        self.current_model = self.scheduling_strategy()
+
+        # Pass all messages to the selected model and get the response
+        try:
+            response = self.current_model.run(messages)
+        except Exception as exc:
+            logger.error(f"Error processing with model: {self.current_model}")
+            if self.scheduling_strategy == self.always_first:
+                self.scheduling_strategy = self.round_robin
+                logger.warning(
+                    "The scheduling strategy has been changed to 'round_robin'"
+                )
+                # Skip already used one
+                self.current_model = self.scheduling_strategy()
+            raise exc
+        return response

camel/models/nvidia_model.py

@@ -0,0 +1,141 @@
+# ========= Copyright 2023-2024 @ 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-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+import os
+from typing import Any, Dict, List, Optional, Union
+
+from openai import OpenAI, Stream
+from openai.types.chat import (
+    ChatCompletion,
+    ChatCompletionChunk,
+)
+
+from camel.configs import NVIDIA_API_PARAMS, NvidiaConfig
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.types import ModelType
+from camel.utils import BaseTokenCounter, OpenAITokenCounter, api_keys_required
+
+
+class NvidiaModel(BaseModelBackend):
+    r"""NVIDIA API in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, one of NVIDIA series.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`. If
+            :obj:`None`, :obj:`NvidiaConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the NVIDIA service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the NVIDIA service.
+            (default: :obj:`None`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter(
+            ModelType.GPT_4)` will be used.
+            (default: :obj:`None`)
+    """
+
+    def __init__(
+        self,
+        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:
+        if model_config_dict is None:
+            model_config_dict = NvidiaConfig().as_dict()
+        api_key = api_key or os.environ.get("NVIDIA_API_KEY")
+        url = url or os.environ.get(
+            "NVIDIA_API_BASE_URL", "https://integrate.api.nvidia.com/v1"
+        )
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
+        self._client = OpenAI(
+            timeout=60,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url,
+        )
+
+    @api_keys_required("NVIDIA_API_KEY")
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs inference of NVIDIA 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.
+        """
+
+        # Remove tool-related parameters if no tools are specified
+        config = dict(self.model_config_dict)
+        if not config.get('tools'):  # None or empty list
+            config.pop('tools', None)
+            config.pop('tool_choice', None)
+
+        response = self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **config,
+        )
+        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 NVIDIA API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to NVIDIA API.
+        """
+        for param in self.model_config_dict:
+            if param not in NVIDIA_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into NVIDIA 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)

camel/models/openai_model.py

@@ -158,6 +158,7 @@ class OpenAIModel(BaseModelBackend):
                 "role": response.choices[0].message.role,
                 "content": response.choices[0].message.content,
                 "tool_calls": response.choices[0].message.tool_calls,
+                "parsed": response.choices[0].message.parsed,
             },
             finish_reason=response.choices[0].finish_reason,
         )

camel/retrievers/vector_retriever.py

@@ -77,6 +77,7 @@ class VectorRetriever(BaseRetriever):
         embed_batch: int = 50,
         should_chunk: bool = True,
         extra_info: Optional[dict] = None,
+        metadata_filename: Optional[str] = None,
         **kwargs: Any,
     ) -> None:
         r"""Processes content from local file path, remote URL, string
@@ -96,6 +97,8 @@ class VectorRetriever(BaseRetriever):
                 otherwise skip chunking. Defaults to True.
             extra_info (Optional[dict]): Extra information to be added
                 to the payload. Defaults to None.
+            metadata_filename (Optional[str]): The metadata filename to be
+                used for storing metadata. Defaults to None.
             **kwargs (Any): Additional keyword arguments for content parsing.
         """
         from unstructured.documents.elements import Element
@@ -103,18 +106,32 @@ class VectorRetriever(BaseRetriever):
         if isinstance(content, Element):
             elements = [content]
         elif isinstance(content, IOBase):
-            elements = self.uio.parse_bytes(file=content, **kwargs) or []
+            elements = (
+                self.uio.parse_bytes(
+                    file=content, metadata_filename=metadata_filename, **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(input_path=content, **kwargs)
+                    self.uio.parse_file_or_url(
+                        input_path=content,
+                        metadata_filename=metadata_filename,
+                        **kwargs,
+                    )
                     or []
                 )
             else:
-                elements = [self.uio.create_element_from_text(text=content)]
+                elements = [
+                    self.uio.create_element_from_text(
+                        text=content,
+                        filename=metadata_filename,
+                    )
+                ]
 
         if not elements:
             warnings.warn(
@@ -156,13 +173,12 @@ class VectorRetriever(BaseRetriever):
                     chunk_metadata = {"metadata": chunk.metadata.to_dict()}
                     # Remove the 'orig_elements' key if it exists
                     chunk_metadata["metadata"].pop("orig_elements", "")
-                    extra_info = extra_info or {}
+                    chunk_metadata["extra_info"] = extra_info or {}
                     chunk_text = {"text": str(chunk)}
                     combined_dict = {
                         **content_path_info,
                         **chunk_metadata,
                         **chunk_text,
-                        **extra_info,
                     }
 
                     records.append(
@@ -233,6 +249,7 @@ class VectorRetriever(BaseRetriever):
                         'content path', ''
                     ),
                     'metadata': result.record.payload.get('metadata', {}),
+                    'extra_info': result.record.payload.get('extra_info', {}),
                     'text': result.record.payload.get('text', ''),
                 }
                 formatted_results.append(result_dict)

camel/societies/babyagi_playing.py

@@ -22,10 +22,13 @@ from camel.agents import (
 )
 from camel.agents.chat_agent import ChatAgentResponse
 from camel.generators import SystemMessageGenerator
+from camel.logger import get_logger
 from camel.messages import BaseMessage
 from camel.prompts import TextPrompt
 from camel.types import RoleType, TaskType
 
+logger = get_logger(__name__)
+
 
 class BabyAGI:
     r"""The BabyAGI Agent adapted from `"Task-driven Autonomous Agent"
@@ -261,7 +264,7 @@ class BabyAGI:
             )
             self.subtasks = deque(prioritized_subtask_list)
         else:
-            print("no new tasks")
+            logger.info("no new tasks")
         assistant_response.info['task_name'] = task_name
         assistant_response.info['subtasks'] = list(self.subtasks)
         if not self.subtasks:

camel/toolkits/__init__.py

@@ -27,6 +27,8 @@ from .dalle_toolkit import DalleToolkit
 from .ask_news_toolkit import AskNewsToolkit, AsyncAskNewsToolkit
 from .linkedin_toolkit import LinkedInToolkit
 from .reddit_toolkit import RedditToolkit
+from .meshy_toolkit import MeshyToolkit
+
 from .base import BaseToolkit
 from .google_maps_toolkit import GoogleMapsToolkit
 from .code_execution import CodeExecutionToolkit
@@ -68,4 +70,5 @@ __all__ = [
     'ArxivToolkit',
     'HumanToolkit',
     'VideoDownloaderToolkit',
+    'MeshyToolkit',
 ]