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

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.7'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -42,8 +42,8 @@ from camel.utils import get_model_encoding
 if TYPE_CHECKING:
     from openai import Stream
 
-    from camel.functions import OpenAIFunction
     from camel.terminators import ResponseTerminator
+    from camel.toolkits import OpenAIFunction
 
 
 @dataclass(frozen=True)

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/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/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/configs/gemini_config.py

@@ -0,0 +1,98 @@
+# =========== 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 TYPE_CHECKING, Optional
+
+from camel.configs.base_config import BaseConfig
+
+if TYPE_CHECKING:
+    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
+
+
+@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.
+    """
+
+    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/configs/litellm_config.py

@@ -19,7 +19,7 @@ from typing import TYPE_CHECKING, List, Optional, Union
 from camel.configs.base_config import BaseConfig
 
 if TYPE_CHECKING:
-    from camel.functions import OpenAIFunction
+    from camel.toolkits import OpenAIFunction
 
 
 @dataclass(frozen=True)

camel/configs/openai_config.py

@@ -21,7 +21,7 @@ from openai._types import NOT_GIVEN, NotGiven
 from camel.configs.base_config import BaseConfig
 
 if TYPE_CHECKING:
-    from camel.functions import OpenAIFunction
+    from camel.toolkits import OpenAIFunction
 
 
 @dataclass(frozen=True)

camel/configs/zhipuai_config.py

@@ -21,7 +21,7 @@ from openai._types import NOT_GIVEN, NotGiven
 from camel.configs.base_config import BaseConfig
 
 if TYPE_CHECKING:
-    from camel.functions import OpenAIFunction
+    from camel.toolkits import OpenAIFunction
 
 
 @dataclass(frozen=True)

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/models/base_model.py

@@ -109,7 +109,10 @@ class BaseModelBackend(ABC):
         Returns:
             int: The maximum token limit for the given model.
         """
-        return self.model_type.token_limit
+        return (
+            self.model_config_dict.get("max_tokens")
+            or self.model_type.token_limit
+        )
 
     @property
     def stream(self) -> bool:

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/models/litellm_model.py

@@ -138,3 +138,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/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/models/ollama_model.py

@@ -104,6 +104,22 @@ class OllamaModel:
         )
         return response
 
+    @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
+
     @property
     def stream(self) -> bool:
         r"""Returns whether the model is in stream mode, which sends partial

camel/models/zhipuai_model.py

@@ -118,7 +118,6 @@ class ZhipuAIModel(BaseModelBackend):
                     f"Unexpected argument `{param}` is "
                     "input into ZhipuAI model backend."
                 )
-        pass
 
     @property
     def stream(self) -> bool:

camel/toolkits/__init__.py

@@ -11,13 +11,49 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# ruff: noqa: I001
+from .openai_function import (
+    OpenAIFunction,
+    get_openai_function_schema,
+    get_openai_tool_schema,
+)
+from .open_api_specs.security_config import openapi_security_config
+
+from .google_maps_toolkit import MAP_FUNCS, GoogleMapsToolkit
+from .math_toolkit import MATH_FUNCS, MathToolkit
+from .open_api_toolkit import OPENAPI_FUNCS, OpenAPIToolkit
+from .retrieval_toolkit import RETRIEVAL_FUNCS, RetrievalToolkit
+from .search_toolkit import SEARCH_FUNCS, SearchToolkit
+from .twitter_toolkit import TWITTER_FUNCS, TwitterToolkit
+from .weather_toolkit import WEATHER_FUNCS, WeatherToolkit
+from .slack_toolkit import SLACK_FUNCS, SlackToolkit
 
 from .base import BaseToolkit
 from .code_execution import CodeExecutionToolkit
 from .github_toolkit import GithubToolkit
 
 __all__ = [
+    'OpenAIFunction',
+    'get_openai_function_schema',
+    'get_openai_tool_schema',
+    'openapi_security_config',
+    'MATH_FUNCS',
+    'MAP_FUNCS',
+    'OPENAPI_FUNCS',
+    'RETRIEVAL_FUNCS',
+    'SEARCH_FUNCS',
+    'TWITTER_FUNCS',
+    'WEATHER_FUNCS',
+    'SLACK_FUNCS',
     'BaseToolkit',
     'GithubToolkit',
+    'MathToolkit',
+    'GoogleMapsToolkit',
+    'SearchToolkit',
+    'SlackToolkit',
+    'TwitterToolkit',
+    'WeatherToolkit',
+    'RetrievalToolkit',
+    'OpenAPIToolkit',
     'CodeExecutionToolkit',
 ]

camel/toolkits/base.py

@@ -14,7 +14,7 @@
 
 from typing import List
 
-from camel.functions import OpenAIFunction
+from .openai_function import OpenAIFunction
 
 
 class BaseToolkit:

camel/toolkits/code_execution.py

@@ -13,8 +13,8 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from typing import List, Literal
 
-from camel.functions import OpenAIFunction
 from camel.interpreters import InternalPythonInterpreter
+from camel.toolkits import OpenAIFunction
 
 from .base import BaseToolkit
 

camel/toolkits/github_toolkit.py

@@ -17,10 +17,11 @@ from dataclasses import dataclass
 from datetime import datetime, timedelta
 from typing import List, Optional
 
-from camel.functions import OpenAIFunction
-from camel.toolkits.base import BaseToolkit
 from camel.utils import dependencies_required
 
+from .base import BaseToolkit
+from .openai_function import OpenAIFunction
+
 
 @dataclass
 class GithubIssue: