feat: integrate the llama3 (8B, 70B) served by Groq

.github/workflows/build_package.yml

@@ -34,5 +34,6 @@ jobs:
           SEARCH_ENGINE_ID: "${{ secrets.SEARCH_ENGINE_ID }}"
           OPENWEATHERMAP_API_KEY: "${{ secrets.OPENWEATHERMAP_API_KEY }}"
           ANTHROPIC_API_KEY: "${{ secrets.ANTHROPIC_API_KEY }}"
+          GROQ_API_KEY: "${{ secrets.GROQ_API_KEY }}"
           COHERE_API_KEY: "${{ secrets.COHERE_API_KEY }}"
         run: pytest --fast-test-mode ./test

.github/workflows/pytest_package.yml

@@ -28,6 +28,7 @@ jobs:
         SEARCH_ENGINE_ID: "${{ secrets.SEARCH_ENGINE_ID }}"
         OPENWEATHERMAP_API_KEY: "${{ secrets.OPENWEATHERMAP_API_KEY }}"
         ANTHROPIC_API_KEY: "${{ secrets.ANTHROPIC_API_KEY }}"
+        GROQ_API_KEY: "${{ secrets.GROQ_API_KEY }}"
         COHERE_API_KEY: "${{ secrets.COHERE_API_KEY }}"
       run: poetry run pytest --fast-test-mode test/
 
@@ -46,6 +47,7 @@ jobs:
         SEARCH_ENGINE_ID: "${{ secrets.SEARCH_ENGINE_ID }}"
         OPENWEATHERMAP_API_KEY: "${{ secrets.OPENWEATHERMAP_API_KEY }}"
         ANTHROPIC_API_KEY: "${{ secrets.ANTHROPIC_API_KEY }}"
+        GROQ_API_KEY: "${{ secrets.GROQ_API_KEY }}"
         COHERE_API_KEY: "${{ secrets.COHERE_API_KEY }}"
       run: poetry run pytest --llm-test-only test/
 
@@ -64,5 +66,6 @@ jobs:
         SEARCH_ENGINE_ID: "${{ secrets.SEARCH_ENGINE_ID }}"
         OPENWEATHERMAP_API_KEY: "${{ secrets.OPENWEATHERMAP_API_KEY }}"
         ANTHROPIC_API_KEY: "${{ secrets.ANTHROPIC_API_KEY }}"
+        GROQ_API_KEY: "${{ secrets.GROQ_API_KEY }}"
         COHERE_API_KEY: "${{ secrets.COHERE_API_KEY }}"
       run: poetry run pytest --very-slow-test-only test/

camel/configs/__init__.py

@@ -13,6 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from .anthropic_config import ANTHROPIC_API_PARAMS, AnthropicConfig
 from .base_config import BaseConfig
+from .groq_llama3_config import GROQ_LLAMA3_API_PARAMS, GroqLLAMA3Config
 from .openai_config import (
     OPENAI_API_PARAMS,
     ChatGPTConfig,
@@ -25,5 +26,7 @@
     'OPENAI_API_PARAMS',
     'AnthropicConfig',
     'ANTHROPIC_API_PARAMS',
+    'GROQ_LLAMA3_API_PARAMS',
+    'GroqLLAMA3Config',
     'OpenSourceConfig',
 ]

camel/configs/groq_llama3_config.py

@@ -0,0 +1,54 @@
+# =========== 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 __future__ import annotations
+
+from dataclasses import asdict, dataclass
+
+from anthropic._types import Literal
+
+from camel.configs.base_config import BaseConfig
+
+
+@dataclass(frozen=True)
+class GroqLLAMA3Config(BaseConfig):
+    r"""Defines the parameters for generating chat completions using the
+    Anthropic API. And Camel does not support stream mode for GroqLLAMA3.
+
+    See: https://console.groq.com/docs/text-chat
+    Args:
+        max_tokens (int, optional): The maximum number of tokens to generate
+            before stopping. Note that Anthropic models may stop before
+            reaching this maximum. This parameter only specifies the absolute
+            maximum number of tokens to generate.
+            (default: :obj:`256`)
+        temperature (float, optional): Amount of randomness injected into the
+            response. Defaults to 1. Ranges from 0 to 1. Use temp closer to 0
+            for analytical / multiple choice, and closer to 1 for creative
+            and generative tasks.
+            (default: :obj:`1`)
+        stream (bool, optional): Whether to incrementally stream the response
+            using server-sent events. Camel does not support stream mode for
+            Groq Llama3.
+            (default: :obj:`False`)
+    """
+
+    max_tokens: int = 4096  # since the Llama3 usually has a context
+    # window of 8192 tokens, the default is set to 4096
+    temperature: float = 1  # Camel does not suggest modifying the `top_p`
+    # Camel does not support stream mode for Groq Llama3, the default value of
+    # `stream` is False
+    stream: Literal[False] = False
+
+
+GROQ_LLAMA3_API_PARAMS = {param for param in asdict(GroqLLAMA3Config()).keys()}

camel/models/__init__.py

@@ -13,6 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from .anthropic_model import AnthropicModel
 from .base_model import BaseModelBackend
+from .groq_model import GroqModel
 from .model_factory import ModelFactory
 from .open_source_model import OpenSourceModel
 from .openai_audio_models import OpenAIAudioModels
@@ -23,6 +24,7 @@
     'BaseModelBackend',
     'OpenAIModel',
     'AnthropicModel',
+    'GroqModel',
     'StubModel',
     'OpenSourceModel',
     'ModelFactory',

camel/models/anthropic_model.py

@@ -20,7 +20,11 @@
 from camel.configs import ANTHROPIC_API_PARAMS
 from camel.models.base_model import BaseModelBackend
 from camel.types import ChatCompletion, ModelType
-from camel.utils import AnthropicTokenCounter, BaseTokenCounter
+from camel.utils import (
+    AnthropicTokenCounter,
+    BaseTokenCounter,
+    api_key_required,
+)
 
 
 class AnthropicModel(BaseModelBackend):
@@ -90,6 +94,7 @@ def count_tokens_from_prompt(self, prompt: str) -> int:
         """
         return self.client.count_tokens(prompt)
 
+    @api_key_required
     def run(
         self,
         messages,

camel/models/groq_model.py

@@ -0,0 +1,149 @@
+# =========== 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
+
+from groq import Groq
+
+from camel.configs import GROQ_LLAMA3_API_PARAMS
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionMessage,
+    Choice,
+    CompletionUsage,
+    ModelType,
+)
+from camel.utils import (
+    BaseTokenCounter,
+    GroqLlama3TokenCounter,
+    api_key_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,
+    ) -> None:
+        r"""Constructor for Groq 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 groq.ChatCompletion.create().
+            api_key (Optional[str]): The API key for authenticating with the
+                Anthropic service. (default: :obj:`None`).
+        """
+        super().__init__(model_type, model_config_dict)
+        url = os.environ.get('GROQ_API_BASE_URL', None)
+        api_key = os.environ.get('GROQ_API_KEY')
+        self._client = Groq(api_key=api_key, base_url=url)
+        self._token_counter: Optional[BaseTokenCounter] = None
+
+    def _convert_response_from_anthropic_to_openai(self, response):
+        # openai ^1.0.0 format, reference openai/types/chat/chat_completion.py
+        obj = ChatCompletion.construct(
+            id=response.id,
+            choices=[
+                Choice.construct(
+                    finish_reason=response.choices[0].finish_reason,
+                    index=response.choices[0].index,
+                    logprobs=response.choices[0].logprobs,
+                    message=ChatCompletionMessage.construct(
+                        content=response.choices[0].message.content,
+                        role=response.choices[0].message.role,
+                        function_call=None,  # It does not provide function call
+                        tool_calls=response.choices[0].message.tool_calls,
+                    ),
+                )
+            ],
+            created=response.created,
+            model=response.model,
+            object="chat.completion",
+            system_fingerprint=response.system_fingerprint,
+            usage=CompletionUsage.construct(
+                completion_tokens=response.usage.completion_tokens,
+                prompt_tokens=response.usage.prompt_tokens,
+                total_tokens=response.usage.total_tokens,
+            ),
+        )
+        return obj
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend. But Groq API
+        does not provide any token counter.
+
+        Returns:
+            BaseTokenCounter: The token counter following the model's
+                tokenization style.
+        """
+        if not self._token_counter:
+            self._token_counter = GroqLlama3TokenCounter(self.model_type)
+        return self._token_counter
+
+    @api_key_required
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> ChatCompletion:
+        r"""Runs inference of OpenAI chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            ChatCompletion: Response in the OpenAI API format (non-stream\
+                mode).
+        """
+        _response = self._client.chat.completions.create(
+            messages=messages,  # type: ignore[arg-type]
+            model=self.model_type.value,
+            **self.model_config_dict,
+        )
+
+        # Format response to OpenAI format
+        response = self._convert_response_from_anthropic_to_openai(_response)
+
+        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_LLAMA3_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into Groq Llama3 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/model_factory.py

@@ -15,6 +15,7 @@
 
 from camel.models.anthropic_model import AnthropicModel
 from camel.models.base_model import BaseModelBackend
+from camel.models.groq_model import GroqModel
 from camel.models.open_source_model import OpenSourceModel
 from camel.models.openai_model import OpenAIModel
 from camel.models.stub_model import StubModel
@@ -58,6 +59,8 @@ def create(
             model_class = OpenSourceModel
         elif model_type.is_anthropic:
             model_class = AnthropicModel
+        elif model_type.is_groq:
+            model_class = GroqModel
         else:
             raise ValueError(f"Unknown model type `{model_type}` is input")
 

camel/types/enums.py

@@ -30,6 +30,9 @@ class ModelType(Enum):
     GPT_4_TURBO = "gpt-4-turbo"
     GPT_4O = "gpt-4o"
 
+    GROQ_LLAMA_3_8_B = "llama3-8b-8192"
+    GROQ_LLAMA_3_70_B = "llama3-70b-8192"
+
     STUB = "stub"
 
     LLAMA_2 = "llama-2"
@@ -62,6 +65,14 @@ def is_openai(self) -> bool:
             ModelType.GPT_4O,
         }
 
+    @property
+    def is_groq(self) -> bool:
+        r"""Returns whether this type of models is served by Groq."""
+        return self in {
+            ModelType.GROQ_LLAMA_3_8_B,
+            ModelType.GROQ_LLAMA_3_70_B,
+        }
+
     @property
     def is_open_source(self) -> bool:
         r"""Returns whether this type of models is open-source."""
@@ -103,6 +114,10 @@ def token_limit(self) -> int:
             return 128000
         elif self is ModelType.GPT_4O:
             return 128000
+        elif self is ModelType.GROQ_LLAMA_3_8_B:
+            return 8192
+        elif self is ModelType.GROQ_LLAMA_3_70_B:
+            return 8192
         elif self is ModelType.STUB:
             return 4096
         elif self is ModelType.LLAMA_2:

camel/utils/__init__.py

@@ -28,6 +28,7 @@
 from .token_counting import (
     AnthropicTokenCounter,
     BaseTokenCounter,
+    GroqLlama3TokenCounter,
     OpenAITokenCounter,
     OpenSourceTokenCounter,
     get_model_encoding,
@@ -42,6 +43,7 @@
     'get_task_list',
     'check_server_running',
     'AnthropicTokenCounter',
+    'GroqLlama3TokenCounter',
     'get_system_information',
     'to_pascal',
     'PYDANTIC_V2',

camel/utils/commons.py

@@ -54,6 +54,10 @@ def wrapper(self, *args, **kwargs):
             if 'ANTHROPIC_API_KEY' not in os.environ:
                 raise ValueError('Anthropic API key not found.')
             return func(self, *args, **kwargs)
+        elif self.model_type.is_groq:
+            if "GROQ_API_KEY" not in os.environ:
+                raise ValueError('Groq API key not found.')
+            return func(self, *args, **kwargs)
         else:
             raise ValueError('Unsupported model type.')