camel-ai 0.1.5.5__tar.gz → 0.1.5.6__tar.gz

{camel_ai-0.1.5.5 → camel_ai-0.1.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: camel-ai
-Version: 0.1.5.5
+Version: 0.1.5.6
 Summary: Communicative Agents for AI Society Study
 Home-page: https://www.camel-ai.org/
 License: Apache-2.0
@@ -36,6 +36,7 @@ Requires-Dist: docker (>=7.1.0,<8.0.0) ; extra == "tools" or extra == "all"
 Requires-Dist: docstring-parser (>=0.15,<0.16)
 Requires-Dist: docx2txt (>=0.8,<0.9) ; extra == "tools" or extra == "all"
 Requires-Dist: duckduckgo-search (>=6.1.0,<7.0.0) ; extra == "tools" or extra == "all"
+Requires-Dist: google-generativeai (>=0.6.0,<0.7.0) ; extra == "model-platforms" or extra == "all"
 Requires-Dist: googlemaps (>=4.10.0,<5.0.0) ; extra == "tools" or extra == "all"
 Requires-Dist: imageio[pyav] (>=2.34.2,<3.0.0) ; extra == "tools" or extra == "all"
 Requires-Dist: jsonschema (>=4,<5)
@@ -190,7 +191,7 @@ conda create --name camel python=3.9
 conda activate camel
 
 # Clone github repo
-git clone -b v0.1.5.5 https://github.com/camel-ai/camel.git
+git clone -b v0.1.5.6 https://github.com/camel-ai/camel.git
 
 # Change directory into project directory
 cd camel

{camel_ai-0.1.5.5 → camel_ai-0.1.5.6}/README.md

@@ -110,7 +110,7 @@ conda create --name camel python=3.9
 conda activate camel
 
 # Clone github repo
-git clone -b v0.1.5.5 https://github.com/camel-ai/camel.git
+git clone -b v0.1.5.6 https://github.com/camel-ai/camel.git
 
 # Change directory into project directory
 cd camel

{camel_ai-0.1.5.5 → camel_ai-0.1.5.6}/camel/__init__.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
-__version__ = '0.1.5.5'
+__version__ = '0.1.5.6'
 
 __all__ = [
     '__version__',

{camel_ai-0.1.5.5 → camel_ai-0.1.5.6}/camel/agents/knowledge_graph_agent.py

@@ -78,17 +78,16 @@ Expected Output:
 
 Nodes:
 
-Node(id='John', type='Person', properties={'agent_generated'})
-Node(id='XYZ Corporation', type='Organization', properties={'agent_generated'})
-Node(id='New York City', type='Location', properties={'agent_generated'})
+Node(id='John', type='Person')
+Node(id='XYZ Corporation', type='Organization')
+Node(id='New York City', type='Location')
 
 Relationships:
 
 Relationship(subj=Node(id='John', type='Person'), obj=Node(id='XYZ 
-Corporation', type='Organization'), type='WorksAt', properties=
-{'agent_generated'})
+Corporation', type='Organization'), type='WorksAt')
 Relationship(subj=Node(id='John', type='Person'), obj=Node(id='New York City', 
-type='Location'), type='ResidesIn', properties={'agent_generated'})
+type='Location'), type='ResidesIn')
 
 ===== TASK =====
 Please extracts nodes and relationships from given content and structures them 
@@ -211,11 +210,10 @@ class KnowledgeGraphAgent(ChatAgent):
         import re
 
         # Regular expressions to extract nodes and relationships
-        node_pattern = r"Node\(id='(.*?)', type='(.*?)', properties=(.*?)\)"
+        node_pattern = r"Node\(id='(.*?)', type='(.*?)'\)"
         rel_pattern = (
             r"Relationship\(subj=Node\(id='(.*?)', type='(.*?)'\), "
-            r"obj=Node\(id='(.*?)', type='(.*?)'\), type='(.*?)', "
-            r"properties=\{(.*?)\}\)"
+            r"obj=Node\(id='(.*?)', type='(.*?)'\), type='(.*?)'\)"
         )
 
         nodes = {}
@@ -223,8 +221,8 @@ class KnowledgeGraphAgent(ChatAgent):
 
         # Extract nodes
         for match in re.finditer(node_pattern, input_string):
-            id, type, properties = match.groups()
-            properties = eval(properties)
+            id, type = match.groups()
+            properties = {'source': 'agent_created'}
             if id not in nodes:
                 node = Node(id, type, properties)
                 if self._validate_node(node):
@@ -232,10 +230,8 @@ class KnowledgeGraphAgent(ChatAgent):
 
         # Extract relationships
         for match in re.finditer(rel_pattern, input_string):
-            subj_id, subj_type, obj_id, obj_type, rel_type, properties_str = (
-                match.groups()
-            )
-            properties = eval(properties_str)
+            subj_id, subj_type, obj_id, obj_type, rel_type = match.groups()
+            properties = {'source': 'agent_created'}
             if subj_id in nodes and obj_id in nodes:
                 subj = nodes[subj_id]
                 obj = nodes[obj_id]

{camel_ai-0.1.5.5 → camel_ai-0.1.5.6}/camel/agents/task_agent.py

@@ -100,7 +100,6 @@ class TaskSpecifyAgent(ChatAgent):
 
         if meta_dict is not None:
             task_specify_prompt = task_specify_prompt.format(**meta_dict)
-
         task_msg = BaseMessage.make_user_message(
             role_name="Task Specifier", content=task_specify_prompt
         )

{camel_ai-0.1.5.5 → camel_ai-0.1.5.6}/camel/configs/__init__.py

@@ -13,6 +13,10 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from .anthropic_config import ANTHROPIC_API_PARAMS, AnthropicConfig
 from .base_config import BaseConfig
+from .gemini_config import (
+    Gemini_API_PARAMS,
+    GeminiConfig,
+)
 from .litellm_config import LITELLM_API_PARAMS, LiteLLMConfig
 from .ollama_config import OLLAMA_API_PARAMS, OllamaConfig
 from .openai_config import (
@@ -35,4 +39,6 @@ __all__ = [
     'OLLAMA_API_PARAMS',
     'ZhipuAIConfig',
     'ZHIPUAI_API_PARAMS',
+    'GeminiConfig',
+    'Gemini_API_PARAMS',
 ]

camel_ai-0.1.5.6/camel/configs/gemini_config.py

@@ -0,0 +1,97 @@
+# =========== 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 collections.abc import Iterable
+from dataclasses import asdict, dataclass
+from typing import Optional
+
+from camel.configs.base_config import BaseConfig
+
+
+@dataclass(frozen=True)
+class GeminiConfig(BaseConfig):
+    r"""A simple dataclass used to configure the generation parameters of
+    `GenerativeModel.generate_content`.
+
+    Args:
+        candidate_count (int, optional): Number of responses to return.
+        stop_sequences (Iterable[str], optional): The set of character
+            sequences (up to 5) that will stop output generation. If specified
+            the API will stop at the first appearance of a stop sequence.
+            The stop sequence will not be included as part of the response.
+        max_output_tokens (int, optional): The maximum number of tokens to
+            include in a candidate. If unset, this will default to
+            output_token_limit specified in the model's specification.
+        temperature (float, optional): Controls the randomness of the output.
+            Note: The default value varies by model, see the
+            `Model.temperature` attribute of the `Model` returned
+            the `genai.get_model` function. Values can range from [0.0,1.0],
+            inclusive. A value closer to 1.0 will produce responses that are
+            more varied and creative, while a value closer to 0.0 will
+            typically result in more straightforward responses from the model.
+        top_p (int, optional): The maximum cumulative probability of tokens to
+            consider when sampling. The model uses combined Top-k and nucleus
+            sampling. Tokens are sorted based on their assigned probabilities
+            so that only the most likely tokens are considered. Top-k sampling
+            directly limits the maximum number of tokens to consider, while
+            Nucleus sampling limits number of tokens
+            based on the cumulative probability. Note: The default value varies
+            by model, see the `Model.top_p` attribute of the `Model` returned
+            the `genai.get_model` function.
+        top_k (int, optional): The maximum number of tokens to consider when
+            sampling. The model uses combined Top-k and nucleus sampling.Top-k
+            sampling considers the set of `top_k` most probable tokens.
+            Defaults to 40. Note: The default value varies by model, see the
+            `Model.top_k` attribute of the `Model` returned the
+            `genai.get_model` function.
+        response_mime_type (str, optional): Output response mimetype of the
+            generated candidate text. Supported mimetype:
+            `text/plain`: (default) Text output.
+            `application/json`: JSON response in the candidates.
+        response_schema (Schema, optional): Specifies the format of the
+            JSON requested if response_mime_type is `application/json`.
+        safety_settings (SafetySettingOptions, optional):
+            Overrides for the model's safety settings.
+        tools (FunctionLibraryType, optional):
+            `protos.Tools` more info coming soon.
+        tool_config (ToolConfigType, optional):
+            more info coming soon.
+        request_options (RequestOptionsType, optional):
+            Options for the request.
+    """
+
+    from google.generativeai.protos import Schema
+    from google.generativeai.types.content_types import (
+        FunctionLibraryType,
+        ToolConfigType,
+    )
+    from google.generativeai.types.helper_types import RequestOptionsType
+    from google.generativeai.types.safety_types import SafetySettingOptions
+
+    candidate_count: Optional[int] = None
+    stop_sequences: Optional[Iterable[str]] = None
+    max_output_tokens: Optional[int] = None
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    top_k: Optional[int] = None
+    response_mime_type: Optional[str] = None
+    response_schema: Optional[Schema] = None
+    safety_settings: Optional[SafetySettingOptions] = None
+    tools: Optional[FunctionLibraryType] = None
+    tool_config: Optional[ToolConfigType] = None
+    request_options: Optional[RequestOptionsType] = None
+
+
+Gemini_API_PARAMS = {param for param in asdict(GeminiConfig()).keys()}

{camel_ai-0.1.5.5 → camel_ai-0.1.5.6}/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 .gemini_model import GeminiModel
 from .litellm_model import LiteLLMModel
 from .model_factory import ModelFactory
 from .nemotron_model import NemotronModel
@@ -35,4 +36,5 @@ __all__ = [
     'OpenAIAudioModels',
     'NemotronModel',
     'OllamaModel',
+    'GeminiModel',
 ]

camel_ai-0.1.5.6/camel/models/gemini_model.py

@@ -0,0 +1,203 @@
+# =========== 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,
+    ) -> 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.
+        """
+        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)
+        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)
+        self._token_counter: Optional[BaseTokenCounter] = None
+        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:
+        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_ai-0.1.5.5 → camel_ai-0.1.5.6}/camel/models/model_factory.py

@@ -15,6 +15,7 @@ from typing import Any, Dict, Optional, Union
 
 from camel.models.anthropic_model import AnthropicModel
 from camel.models.base_model import BaseModelBackend
+from camel.models.gemini_model import GeminiModel
 from camel.models.litellm_model import LiteLLMModel
 from camel.models.ollama_model import OllamaModel
 from camel.models.open_source_model import OpenSourceModel
@@ -59,7 +60,6 @@ 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
@@ -70,6 +70,8 @@ class ModelFactory:
                 model_class = AnthropicModel
             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_type == ModelType.STUB:
                 model_class = StubModel
             else:
@@ -90,5 +92,4 @@ class ModelFactory:
                 )
         else:
             raise ValueError(f"Invalid model type `{model_type}` provided.")
-
         return model_class(model_type, model_config_dict, api_key, url)

{camel_ai-0.1.5.5 → camel_ai-0.1.5.6}/camel/types/enums.py

@@ -58,6 +58,10 @@ class ModelType(Enum):
     # Nvidia models
     NEMOTRON_4_REWARD = "nvidia/nemotron-4-340b-reward"
 
+    # Gemini models
+    GEMINI_1_5_FLASH = "gemini-1.5-flash"
+    GEMINI_1_5_PRO = "gemini-1.5-pro"
+
     @property
     def value_for_tiktoken(self) -> str:
         return (
@@ -126,6 +130,10 @@ class ModelType(Enum):
             ModelType.NEMOTRON_4_REWARD,
         }
 
+    @property
+    def is_gemini(self) -> bool:
+        return self in {ModelType.GEMINI_1_5_FLASH, ModelType.GEMINI_1_5_PRO}
+
     @property
     def token_limit(self) -> int:
         r"""Returns the maximum token limit for a given model.
@@ -142,6 +150,10 @@ class ModelType(Enum):
             return 128000
         elif self is ModelType.GPT_4O:
             return 128000
+        elif self == ModelType.GEMINI_1_5_FLASH:
+            return 1048576
+        elif self == ModelType.GEMINI_1_5_PRO:
+            return 1048576
         elif self == ModelType.GLM_4_OPEN_SOURCE:
             return 8192
         elif self == ModelType.GLM_3_TURBO:
@@ -331,6 +343,7 @@ class ModelPlatformType(Enum):
     LITELLM = "litellm"
     ZHIPU = "zhipuai"
     DEFAULT = "default"
+    GEMINI = "gemini"
 
     @property
     def is_openai(self) -> bool:
@@ -367,6 +380,11 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is opensource."""
         return self is ModelPlatformType.OPENSOURCE
 
+    @property
+    def is_gemini(self) -> bool:
+        r"""Returns whether this platform is Gemini."""
+        return self is ModelPlatformType.GEMINI
+
 
 class AudioModelType(Enum):
     TTS_1 = "tts-1"

{camel_ai-0.1.5.5 → camel_ai-0.1.5.6}/camel/utils/__init__.py

@@ -32,6 +32,7 @@ from .constants import Constants
 from .token_counting import (
     AnthropicTokenCounter,
     BaseTokenCounter,
+    GeminiTokenCounter,
     LiteLLMTokenCounter,
     OpenAITokenCounter,
     OpenSourceTokenCounter,
@@ -60,4 +61,5 @@ __all__ = [
     'dependencies_required',
     'api_keys_required',
     'is_docker_running',
+    'GeminiTokenCounter',
 ]

{camel_ai-0.1.5.5 → camel_ai-0.1.5.6}/camel/utils/token_counting.py

@@ -342,6 +342,40 @@ class AnthropicTokenCounter(BaseTokenCounter):
         return num_tokens
 
 
+class GeminiTokenCounter(BaseTokenCounter):
+    def __init__(self, model_type: ModelType):
+        r"""Constructor for the token counter for Gemini models."""
+        import google.generativeai as genai
+
+        self.model_type = model_type
+        self._client = genai.GenerativeModel(self.model_type.value)
+
+    def count_tokens_from_messages(self, messages: List[OpenAIMessage]) -> int:
+        r"""Count number of tokens in the provided message list using
+        loaded tokenizer specific for this type of model.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            int: Number of tokens in the messages.
+        """
+        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 self._client.count_tokens(converted_messages).total_tokens
+
+
 class LiteLLMTokenCounter:
     def __init__(self, model_type: str):
         r"""Constructor for the token counter for LiteLLM models.

{camel_ai-0.1.5.5 → camel_ai-0.1.5.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "camel-ai"
-version = "0.1.5.5"
+version = "0.1.5.6"
 authors = ["CAMEL-AI.org"]
 description = "Communicative Agents for AI Society Study"
 readme = "README.md"
@@ -43,6 +43,7 @@ pillow ="^10.2.0"
 
 # model-platforms
 litellm = { version = "^1.38.1", optional = true }
+google-generativeai = { version = "^0.6.0", optional = true }
 
 # huggingface-agent
 transformers = { version = "^4", optional = true }
@@ -104,6 +105,7 @@ test = ["pytest", "mock", "pytest-asyncio"]
 
 model-platforms = [
     "litellm",
+    "google-generativeai",
 ]
 
 huggingface-agent = [
@@ -210,6 +212,7 @@ all = [
     "litellm",
     # kv-storages
     "redis",
+    "google-generativeai",
 ]
 
 [tool.poetry.group.dev]
@@ -335,5 +338,7 @@ module = [
     "pyTelegramBotAPI",
     "discord.py",
     "docker.*",
+    "google.*",
+    "google-generativeai",
 ]
 ignore_missing_imports = true