camel-ai 0.1.5.5__py3-none-any.whl → 0.1.5.9__py3-none-any.whl

camel/models/gemini_model.py

@@ -0,0 +1,215 @@
+# =========== 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. ===========
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from camel.configs import Gemini_API_PARAMS
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionMessage,
+    Choice,
+    ModelType,
+)
+from camel.utils import (
+    BaseTokenCounter,
+    GeminiTokenCounter,
+    api_keys_required,
+)
+
+if TYPE_CHECKING:
+    from google.generativeai.types import ContentsType, GenerateContentResponse
+
+
+class GeminiModel(BaseModelBackend):
+    r"""Gemini API in a unified BaseModelBackend interface."""
+
+    # NOTE: Currently "stream": True is not supported with Gemini due to the
+    # limitation of the current camel design.
+
+    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 Gemini backend.
+
+        Args:
+            model_type (ModelType): Model for which a backend is created.
+            model_config_dict (Dict[str, Any]): A dictionary that will
+                be fed into generate_content().
+            api_key (Optional[str]): The API key for authenticating with the
+                gemini service. (default: :obj:`None`)
+            url (Optional[str]): The url to the gemini service.
+            token_counter (Optional[BaseTokenCounter]): Token counter to use
+                for the model. If not provided, `GeminiTokenCounter` will be
+                used.
+        """
+        import os
+
+        import google.generativeai as genai
+        from google.generativeai.types.generation_types import GenerationConfig
+
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
+        self._api_key = api_key or os.environ.get("GOOGLE_API_KEY")
+        genai.configure(api_key=self._api_key)
+        self._client = genai.GenerativeModel(self.model_type.value)
+
+        keys = list(self.model_config_dict.keys())
+        generation_config_dict = {
+            k: self.model_config_dict.pop(k)
+            for k in keys
+            if hasattr(GenerationConfig, k)
+        }
+        generation_config = genai.types.GenerationConfig(
+            **generation_config_dict
+        )
+        self.model_config_dict["generation_config"] = generation_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 = GeminiTokenCounter(self.model_type)
+        return self._token_counter
+
+    @api_keys_required("GOOGLE_API_KEY")
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> ChatCompletion:
+        r"""Runs inference of Gemini model.
+        This method can handle multimodal input
+
+        Args:
+            messages: Message list or Message with the chat history
+                in OpenAi format.
+
+        Returns:
+            response: A ChatCompletion object formatted for the OpenAI API.
+        """
+        response = self._client.generate_content(
+            contents=self.to_gemini_req(messages),
+            **self.model_config_dict,
+        )
+        response.resolve()
+        return self.to_openai_response(response)
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to Gemini API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to OpenAI API.
+        """
+        if self.model_config_dict is not None:
+            for param in self.model_config_dict:
+                if param not in Gemini_API_PARAMS:
+                    raise ValueError(
+                        f"Unexpected argument `{param}` is "
+                        "input into Gemini 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)
+
+    def to_gemini_req(self, messages: List[OpenAIMessage]) -> 'ContentsType':
+        r"""Converts the request from the OpenAI API format to
+            the Gemini API request format.
+
+        Args:
+            messages: The request object from the OpenAI API.
+
+        Returns:
+            converted_messages: A list of messages formatted for Gemini API.
+        """
+        # role reference
+        # https://ai.google.dev/api/python/google/generativeai/protos/Content
+        converted_messages = []
+        for message in messages:
+            role = message.get('role')
+            if role == 'assistant':
+                role_to_gemini = 'model'
+            else:
+                role_to_gemini = 'user'
+            converted_message = {
+                "role": role_to_gemini,
+                "parts": message.get("content"),
+            }
+            converted_messages.append(converted_message)
+        return converted_messages
+
+    def to_openai_response(
+        self,
+        response: 'GenerateContentResponse',
+    ) -> ChatCompletion:
+        r"""Converts the response from the Gemini API to the OpenAI API
+        response format.
+
+        Args:
+            response: The response object returned by the Gemini API
+
+        Returns:
+            openai_response: A ChatCompletion object formatted for
+                the OpenAI API.
+        """
+        import time
+        import uuid
+
+        openai_response = ChatCompletion(
+            id=f"chatcmpl-{uuid.uuid4().hex!s}",
+            object="chat.completion",
+            created=int(time.time()),
+            model=self.model_type.value,
+            choices=[],
+        )
+        for i, candidate in enumerate(response.candidates):
+            content = ""
+            if candidate.content and len(candidate.content.parts) > 0:
+                content = candidate.content.parts[0].text
+            finish_reason = candidate.finish_reason
+            finish_reason_mapping = {
+                "FinishReason.STOP": "stop",
+                "FinishReason.SAFETY": "content_filter",
+                "FinishReason.RECITATION": "content_filter",
+                "FinishReason.MAX_TOKENS": "length",
+            }
+            finish_reason = finish_reason_mapping.get(finish_reason, "stop")
+            choice = Choice(
+                index=i,
+                message=ChatCompletionMessage(
+                    role="assistant", content=content
+                ),
+                finish_reason=finish_reason,
+            )
+        openai_response.choices.append(choice)
+        return openai_response

camel/models/groq_model.py

@@ -0,0 +1,131 @@
+# =========== 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 GROQ_API_PARAMS
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+)
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    api_keys_required,
+)
+
+
+class GroqModel(BaseModelBackend):
+    r"""LLM API served by Groq in a unified BaseModelBackend 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 Groq backend.
+
+        Args:
+            model_type (str): Model for which a backend is created.
+            model_config_dict (Dict[str, Any]): A dictionary of parameters for
+                the model configuration.
+            api_key (Optional[str]): The API key for authenticating with the
+                Groq service. (default: :obj:`None`).
+            url (Optional[str]): The url to the Groq service. (default:
+                :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.
+        """
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
+        self._url = url or "https://api.groq.com/openai/v1"
+        self._api_key = api_key or os.environ.get("GROQ_API_KEY")
+        self._client = OpenAI(
+            timeout=60,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url,
+        )
+        self._token_counter = token_counter
+
+    @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.
+        """
+        # Make sure you have the access to these open-source model in
+        # HuggingFace
+        if not self._token_counter:
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_3_5_TURBO)
+        return self._token_counter
+
+    @api_keys_required("GROQ_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.
+        """
+        response = self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type.value,
+            **self.model_config_dict,
+        )
+
+        return response
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any unexpected
+        arguments to Groq API. But Groq API does not have any additional
+        arguments to check.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to Groq API.
+        """
+        for param in self.model_config_dict:
+            if param not in GROQ_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into Groq model backend."
+                )
+
+    @property
+    def stream(self) -> bool:
+        r"""Returns whether the model supports streaming. But Groq API does
+        not support streaming.
+        """
+        return False

camel/models/litellm_model.py

@@ -16,7 +16,7 @@ from typing import Any, Dict, List, Optional
 from camel.configs import LITELLM_API_PARAMS
 from camel.messages import OpenAIMessage
 from camel.types import ChatCompletion
-from camel.utils import LiteLLMTokenCounter
+from camel.utils import BaseTokenCounter, LiteLLMTokenCounter
 
 
 class LiteLLMModel:
@@ -30,6 +30,7 @@ class LiteLLMModel:
         model_config_dict: Dict[str, Any],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
         r"""Constructor for LiteLLM backend.
 
@@ -42,11 +43,14 @@ class LiteLLMModel:
                 model service. (default: :obj:`None`)
             url (Optional[str]): The url to the model service. (default:
                 :obj:`None`)
+            token_counter (Optional[BaseTokenCounter]): Token counter to use
+                for the model. If not provided, `LiteLLMTokenCounter` will
+                be used.
         """
         self.model_type = model_type
         self.model_config_dict = model_config_dict
         self._client = None
-        self._token_counter: Optional[LiteLLMTokenCounter] = None
+        self._token_counter = token_counter
         self.check_model_config()
         self._url = url
         self._api_key = api_key
@@ -98,8 +102,10 @@ class LiteLLMModel:
                 tokenization style.
         """
         if not self._token_counter:
-            self._token_counter = LiteLLMTokenCounter(self.model_type)
-        return self._token_counter
+            self._token_counter = LiteLLMTokenCounter(  # type: ignore[assignment]
+                self.model_type
+            )
+        return self._token_counter  # type: ignore[return-value]
 
     def run(
         self,
@@ -138,3 +144,19 @@ class LiteLLMModel:
                     f"Unexpected argument `{param}` is "
                     "input into LiteLLM model backend."
                 )
+
+    @property
+    def token_limit(self) -> int:
+        """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/mistral_model.py

@@ -0,0 +1,169 @@
+# =========== 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 TYPE_CHECKING, Any, Dict, List, Optional
+
+if TYPE_CHECKING:
+    from mistralai.models.chat_completion import ChatCompletionResponse
+
+from camel.configs import MISTRAL_API_PARAMS
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.types import ChatCompletion, ModelType
+from camel.utils import (
+    BaseTokenCounter,
+    MistralTokenCounter,
+    api_keys_required,
+)
+
+
+class MistralModel(BaseModelBackend):
+    r"""Mistral API in a unified BaseModelBackend interface."""
+
+    # TODO: Support tool calling.
+
+    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 Mistral backend.
+
+        Args:
+            model_type (ModelType): Model for which a backend is created,
+                one of MISTRAL_* series.
+            model_config_dict (Dict[str, Any]): A dictionary that will
+                be fed into `MistralClient.chat`.
+            api_key (Optional[str]): The API key for authenticating with the
+                mistral service. (default: :obj:`None`)
+            url (Optional[str]): The url to the mistral service.
+            token_counter (Optional[BaseTokenCounter]): Token counter to use
+                for the model. If not provided, `MistralTokenCounter` will be
+                used.
+        """
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
+        self._api_key = api_key or os.environ.get("MISTRAL_API_KEY")
+
+        from mistralai.client import MistralClient
+
+        self._client = MistralClient(api_key=self._api_key)
+        self._token_counter: Optional[BaseTokenCounter] = None
+
+    def _convert_response_from_mistral_to_openai(
+        self, response: 'ChatCompletionResponse'
+    ) -> ChatCompletion:
+        tool_calls = None
+        if response.choices[0].message.tool_calls is not None:
+            tool_calls = [
+                dict(
+                    id=tool_call.id,
+                    function={
+                        "name": tool_call.function.name,
+                        "arguments": tool_call.function.arguments,
+                    },
+                    type=tool_call.type.value,
+                )
+                for tool_call in response.choices[0].message.tool_calls
+            ]
+
+        obj = ChatCompletion.construct(
+            id=response.id,
+            choices=[
+                dict(
+                    index=response.choices[0].index,
+                    message={
+                        "role": response.choices[0].message.role,
+                        "content": response.choices[0].message.content,
+                        "tool_calls": tool_calls,
+                    },
+                    finish_reason=response.choices[0].finish_reason.value
+                    if response.choices[0].finish_reason
+                    else None,
+                )
+            ],
+            created=response.created,
+            model=response.model,
+            object="chat.completion",
+            usage=response.usage,
+        )
+
+        return obj
+
+    @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 = MistralTokenCounter(
+                model_type=self.model_type
+            )
+        return self._token_counter
+
+    @api_keys_required("MISTRAL_API_KEY")
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> ChatCompletion:
+        r"""Runs inference of Mistral chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            ChatCompletion
+        """
+        response = self._client.chat(
+            messages=messages,
+            model=self.model_type.value,
+            **self.model_config_dict,
+        )
+
+        response = self._convert_response_from_mistral_to_openai(response)  # type:ignore[assignment]
+
+        return response  # type:ignore[return-value]
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to Mistral API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to Mistral API.
+        """
+        for param in self.model_config_dict:
+            if param not in MISTRAL_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into Mistral model backend."
+                )
+
+    @property
+    def stream(self) -> bool:
+        r"""Returns whether the model is in stream mode, which sends partial
+        results each time. Mistral doesn't support stream mode.
+
+        Returns:
+            bool: Whether the model is in stream mode.
+        """
+        return False

camel/models/model_factory.py

@@ -14,14 +14,20 @@
 from typing import Any, Dict, Optional, Union
 
 from camel.models.anthropic_model import AnthropicModel
+from camel.models.azure_openai_model import AzureOpenAIModel
 from camel.models.base_model import BaseModelBackend
+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.ollama_model import OllamaModel
 from camel.models.open_source_model import OpenSourceModel
 from camel.models.openai_model import OpenAIModel
 from camel.models.stub_model import StubModel
+from camel.models.vllm_model import VLLMModel
 from camel.models.zhipuai_model import ZhipuAIModel
 from camel.types import ModelPlatformType, ModelType
+from camel.utils import BaseTokenCounter
 
 
 class ModelFactory:
@@ -36,6 +42,7 @@ class ModelFactory:
         model_platform: ModelPlatformType,
         model_type: Union[ModelType, str],
         model_config_dict: Dict,
+        token_counter: Optional[BaseTokenCounter] = None,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
     ) -> BaseModelBackend:
@@ -48,6 +55,10 @@ class ModelFactory:
                 created can be a `str` for open source platforms.
             model_config_dict (Dict): A dictionary that will be fed into
                 the backend constructor.
+            token_counter (Optional[BaseTokenCounter]): Token counter to use
+                for the model. If not provided, OpenAITokenCounter(ModelType.
+                GPT_3_5_TURBO) will be used if the model platform didn't
+                provide official token counter.
             api_key (Optional[str]): The API key for authenticating with the
                 model service.
             url (Optional[str]): The url to the model service.
@@ -59,17 +70,26 @@ class ModelFactory:
             BaseModelBackend: The initialized backend.
         """
         model_class: Any
-
         if isinstance(model_type, ModelType):
             if model_platform.is_open_source and model_type.is_open_source:
                 model_class = OpenSourceModel
-                return model_class(model_type, model_config_dict, url)
+                return model_class(
+                    model_type, model_config_dict, url, token_counter
+                )
             if model_platform.is_openai and model_type.is_openai:
                 model_class = OpenAIModel
+            elif model_platform.is_azure and model_type.is_azure_openai:
+                model_class = AzureOpenAIModel
             elif model_platform.is_anthropic and model_type.is_anthropic:
                 model_class = AnthropicModel
+            elif model_type.is_groq:
+                model_class = GroqModel
             elif model_platform.is_zhipuai and model_type.is_zhipuai:
                 model_class = ZhipuAIModel
+            elif model_platform.is_gemini and model_type.is_gemini:
+                model_class = GeminiModel
+            elif model_platform.is_mistral and model_type.is_mistral:
+                model_class = MistralModel
             elif model_type == ModelType.STUB:
                 model_class = StubModel
             else:
@@ -80,7 +100,14 @@ class ModelFactory:
         elif isinstance(model_type, str):
             if model_platform.is_ollama:
                 model_class = OllamaModel
-                return model_class(model_type, model_config_dict, url)
+                return model_class(
+                    model_type, model_config_dict, url, token_counter
+                )
+            elif model_platform.is_vllm:
+                model_class = VLLMModel
+                return model_class(
+                    model_type, model_config_dict, url, api_key, token_counter
+                )
             elif model_platform.is_litellm:
                 model_class = LiteLLMModel
             else:
@@ -90,5 +117,6 @@ class ModelFactory:
                 )
         else:
             raise ValueError(f"Invalid model type `{model_type}` provided.")
-
-        return model_class(model_type, model_config_dict, api_key, url)
+        return model_class(
+            model_type, model_config_dict, api_key, url, token_counter
+        )