🐫 CAMEL: The first and the best multi-agent framework. Finding the Scaling Law of Agents. https://www.camel-ai.org
Python agentai-societiesartificial-intelligencecommunicative-aicooperative-aideep-learninglarge-language-modelsmulti-agent-systemsnatural-language-processing
feat: Integrate siliconflow model (#1541)
Asher-hss9b4111579c1e
diff --git a/.github/workflows/build_package.yml b/.github/workflows/build_package.ymlindex d5fd5474c..449550efa 100644--- a/.github/workflows/build_package.yml+++ b/.github/workflows/build_package.yml@@ -80,6 +80,7 @@ jobs:DISCORD_BOT_TOKEN: "${{ secrets.DISCORD_BOT_TOKEN }}"INTERNLM_API_KEY: "${{ secrets.INTERNLM_API_KEY }}"JINA_API_KEY: "${{ secrets.JINA_API_KEY }}"+ SILICONFLOW_API_KEY: "${{ secrets.SILICONFLOW_API_KEY }}"MOONSHOT_API_KEY: "${{ secrets.MOONSHOT_API_KEY }}"run: |source venv/bin/activatediff --git a/.github/workflows/pytest_apps.yml b/.github/workflows/pytest_apps.ymlindex e07fdbc36..5b078d00b 100644--- a/.github/workflows/pytest_apps.yml+++ b/.github/workflows/pytest_apps.yml@@ -31,6 +31,7 @@ jobs:COHERE_API_KEY: "${{ secrets.COHERE_API_KEY }}"INTERNLM_API_KEY: "${{ secrets.INTERNLM_API_KEY }}"MOONSHOT_API_KEY: "${{ secrets.MOONSHOT_API_KEY }}"+ SILICONFLOW_API_KEY: "${{ secrets.SILICONFLOW_API_KEY }}"run: poetry run pytest -v apps/pytest_examples:@@ -51,4 +52,5 @@ jobs:COHERE_API_KEY: "${{ secrets.COHERE_API_KEY }}"INTERNLM_API_KEY: "${{ secrets.INTERNLM_API_KEY }}"MOONSHOT_API_KEY: "${{ secrets.MOONSHOT_API_KEY }}"+ SILICONFLOW_API_KEY: "${{ secrets.SILICONFLOW_API_KEY }}"run: poetry run pytest -v examples/diff --git a/.github/workflows/pytest_package.yml b/.github/workflows/pytest_package.ymlindex eb227633b..3c0526ef5 100644--- a/.github/workflows/pytest_package.yml+++ b/.github/workflows/pytest_package.yml@@ -60,6 +60,7 @@ jobs:INTERNLM_API_KEY: "${{ secrets.INTERNLM_API_KEY }}"JINA_API_KEY: "${{ secrets.JINA_API_KEY }}"MOONSHOT_API_KEY: "${{ secrets.MOONSHOT_API_KEY }}"+ SILICONFLOW_API_KEY: "${{ secrets.SILICONFLOW_API_KEY }}"run: poetry run pytest --fast-test-mode test/pytest_package_llm_test:@@ -109,6 +110,7 @@ jobs:INTERNLM_API_KEY: "${{ secrets.INTERNLM_API_KEY }}"JINA_API_KEY: "${{ secrets.JINA_API_KEY }}"MOONSHOT_API_KEY: "${{ secrets.MOONSHOT_API_KEY }}"+ SILICONFLOW_API_KEY: "${{ secrets.SILICONFLOW_API_KEY }}"run: poetry run pytest --llm-test-only test/pytest_package_very_slow_test:diff --git a/camel/configs/__init__.py b/camel/configs/__init__.pyindex 3a3250858..9b3df6039 100644--- a/camel/configs/__init__.py+++ b/camel/configs/__init__.py@@ -33,6 +33,7 @@ from .samba_config import (SambaVerseAPIConfig,)from .sglang_config import SGLANG_API_PARAMS, SGLangConfig+from .siliconflow_config import SILICONFLOW_API_PARAMS, SiliconFlowConfigfrom .togetherai_config import TOGETHERAI_API_PARAMS, TogetherAIConfigfrom .vllm_config import VLLM_API_PARAMS, VLLMConfigfrom .yi_config import YI_API_PARAMS, YiConfig@@ -82,4 +83,6 @@ __all__ = ['INTERNLM_API_PARAMS','MoonshotConfig',"MOONSHOT_API_PARAMS",+ 'SiliconFlowConfig',+ 'SILICONFLOW_API_PARAMS',]diff --git a/camel/configs/siliconflow_config.py b/camel/configs/siliconflow_config.pynew file mode 100644index 000000000..c2a76d4f2--- /dev/null+++ b/camel/configs/siliconflow_config.py@@ -0,0 +1,91 @@+# ========= 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. =========+from __future__ import annotations++from typing import Any, Sequence, Type, Union++from pydantic import BaseModel++from camel.configs.base_config import BaseConfig+from camel.types import NOT_GIVEN, NotGiven+++class SiliconFlowConfig(BaseConfig):+ r"""Defines the parameters for generating chat completions using the+ SiliconFlow API.++ Args:+ temperature (float, optional): Determines the degree of randomness+ in the response. (default: :obj:`0.7`)+ top_p (float, optional): The top_p (nucleus) parameter is used to+ dynamically adjust the number of choices for each predicted token+ based on the cumulative probabilities. (default: :obj:`0.7`)+ n (int, optional): Number of generations to return. (default::obj:`1`)+ response_format (object, optional): An object specifying the format+ that the model must output.+ stream (bool, optional): If set, tokens are returned as Server-Sent+ Events as they are made available. (default: :obj:`False`)+ stop (str or list, optional): Up to :obj:`4` sequences where the API+ will stop generating further tokens. (default: :obj:`None`)+ max_tokens (int, optional): The maximum number of tokens to generate.+ (default: :obj:`None`)+ frequency_penalty (float, optional): Number between :obj:`-2.0` and+ :obj:`2.0`. Positive values penalize new tokens based on their+ existing frequency in the text so far, decreasing the model's+ likelihood to repeat the same line verbatim. See more information+ about frequency and presence penalties. (default: :obj:`0.0`)+ tools (list[FunctionTool], optional): A list of tools the model may+ call. Currently, only functions are supported as a tool. Use this+ to provide a list of functions the model may generate JSON inputs+ for. A max of 128 functions are supported.+ """++ temperature: float = 0.7+ top_p: float = 0.7+ n: int = 1+ stream: bool = False+ stop: Union[str, Sequence[str], NotGiven] = NOT_GIVEN+ max_tokens: Union[int, NotGiven] = NOT_GIVEN+ response_format: Union[Type[BaseModel], dict, NotGiven] = NOT_GIVEN+ frequency_penalty: float = 0.0++ def as_dict(self) -> dict[str, Any]:+ r"""Convert the current configuration to a dictionary.++ This method converts the current configuration object to a dictionary+ representation, which can be used for serialization or other purposes.++ Returns:+ dict[str, Any]: A dictionary representation of the current+ configuration.+ """+ config_dict = self.model_dump()+ if self.tools:+ from camel.toolkits import FunctionTool++ tools_schema = []+ for tool in self.tools:+ if not isinstance(tool, FunctionTool):+ raise ValueError(+ f"The tool {tool} should "+ "be an instance of `FunctionTool`."+ )+ tools_schema.append(tool.get_openai_tool_schema())+ config_dict["tools"] = NOT_GIVEN+ return config_dict+++SILICONFLOW_API_PARAMS = {+ param for param in SiliconFlowConfig.model_fields.keys()+}diff --git a/camel/embeddings/jina_embedding.py b/camel/embeddings/jina_embedding.pyindex eca4473de..db13d7c5c 100644--- a/camel/embeddings/jina_embedding.py+++ b/camel/embeddings/jina_embedding.py@@ -35,6 +35,11 @@ class JinaEmbedding(BaseEmbedding[Union[str, Image.Image]]):Jina AI. (default: :obj:`None`)dimensions (Optional[int], optional): The dimension of the outputembeddings. (default: :obj:`None`)+ embedding_type (Optional[str], optional): The type of embedding format+ to generate. Options: 'int8' (binary encoding with higher storage+ and transfer efficiency), 'uint8' (unsigned binary encoding with+ higher storage and transfer efficiency), 'base64' (base64 string+ encoding with higher transfer efficiency). (default: :obj:`None`)task (Optional[str], optional): The type of task for text embeddings.Options: retrieval.query, retrieval.passage, text-matching,classification, separation. (default: :obj:`None`)@@ -120,7 +125,7 @@ class JinaEmbedding(BaseEmbedding[Union[str, Image.Image]]):else:raise ValueError(f"Input type {type(obj)} is not supported. "- "Must be either str or PIL.Image"+ "Must be either str or PIL.Image.")data = {diff --git a/camel/models/model_factory.py b/camel/models/model_factory.pyindex 8ffc83e01..560dcdc24 100644--- a/camel/models/model_factory.py+++ b/camel/models/model_factory.py@@ -32,6 +32,7 @@ from camel.models.qwen_model import QwenModelfrom camel.models.reka_model import RekaModelfrom camel.models.samba_model import SambaModelfrom camel.models.sglang_model import SGLangModel+from camel.models.siliconflow_model import SiliconFlowModelfrom camel.models.stub_model import StubModelfrom camel.models.togetherai_model import TogetherAIModelfrom camel.models.vllm_model import VLLMModel@@ -101,6 +102,8 @@ class ModelFactory:model_class = LiteLLMModelelif model_platform.is_nvidia:model_class = NvidiaModel+ elif model_platform.is_siliconflow:+ model_class = SiliconFlowModelelif model_platform.is_openai and model_type.is_openai:model_class = OpenAIModeldiff --git a/camel/models/siliconflow_model.py b/camel/models/siliconflow_model.pynew file mode 100644index 000000000..f2197a7d9--- /dev/null+++ b/camel/models/siliconflow_model.py@@ -0,0 +1,142 @@+# ========= 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 camel.configs import SILICONFLOW_API_PARAMS, SiliconFlowConfig+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 SiliconFlowModel(BaseModelBackend):+ r"""SiliconFlow API in a unified BaseModelBackend interface.++ Args:+ model_type (Union[ModelType, str]): Model for which a backend is+ created.+ model_config_dict (Optional[Dict[str, Any]], optional): A dictionary+ that will be fed into OpenAI client. If :obj:`None`,+ :obj:`SiliconFlowConfig().as_dict()` will be used.+ (default: :obj:`None`)+ api_key (Optional[str], optional): The API key for authenticating with+ the SiliconFlow service. (default: :obj:`None`)+ url (Optional[str], optional): The URL to the SiliconFlow service. If+ not provided, :obj:`https://api.siliconflow.cn/v1/` will be used.+ (default: :obj:`None`)+ token_counter (Optional[BaseTokenCounter], optional): Token counter to+ use for the model. If not provided, :obj:`OpenAITokenCounter(+ ModelType.GPT_4O_MINI)` will be used.+ (default: :obj:`None`)+ """++ @api_keys_required(+ [+ ("api_key", 'SILICONFLOW_API_KEY'),+ ]+ )+ 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 = SiliconFlowConfig().as_dict()+ api_key = api_key or os.environ.get("SILICONFLOW_API_KEY")+ url = url or os.environ.get(+ "SILICONFLOW_API_BASE_URL",+ "https://api.siliconflow.cn/v1/",+ )+ super().__init__(+ model_type, model_config_dict, api_key, url, token_counter+ )+ self._client = OpenAI(+ timeout=180,+ max_retries=3,+ api_key=self._api_key,+ base_url=self._url,+ )++ def run(+ self,+ messages: List[OpenAIMessage],+ ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:+ r"""Runs inference of SiliconFlow 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,+ **self.model_config_dict,+ )+ return response++ @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 = 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 SiliconFlow API.++ Raises:+ ValueError: If the model configuration dictionary contains any+ unexpected arguments to SiliconFlow API.+ """+ for param in self.model_config_dict:+ if param not in SILICONFLOW_API_PARAMS:+ raise ValueError(+ f"Unexpected argument `{param}` is "+ "input into SiliconFlow model backend."+ )++ @property+ def stream(self) -> bool:+ """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)diff --git a/camel/types/enums.py b/camel/types/enums.pyindex b694ad2fd..74c8efabe 100644--- a/camel/types/enums.py+++ b/camel/types/enums.py@@ -175,6 +175,20 @@ class ModelType(UnifiedModelType, Enum):MOONSHOT_V1_32K = "moonshot-v1-32k"MOONSHOT_V1_128K = "moonshot-v1-128k"+ # SiliconFlow models support tool calling+ SILICONFLOW_DEEPSEEK_V2_5 = "deepseek-ai/DeepSeek-V2.5"+ SILICONFLOW_DEEPSEEK_V3 = "deepseek-ai/DeepSeek-V3"+ SILICONFLOW_INTERN_LM2_5_20B_CHAT = "internlm/internlm2_5-20b-chat"+ SILICONFLOW_INTERN_LM2_5_7B_CHAT = "internlm/internlm2_5-7b-chat"+ SILICONFLOW_PRO_INTERN_LM2_5_7B_CHAT = "Pro/internlm/internlm2_5-7b-chat"+ SILICONFLOW_QWEN2_5_72B_INSTRUCT = "Qwen/Qwen2.5-72B-Instruct"+ SILICONFLOW_QWEN2_5_32B_INSTRUCT = "Qwen/Qwen2.5-32B-Instruct"+ SILICONFLOW_QWEN2_5_14B_INSTRUCT = "Qwen/Qwen2.5-14B-Instruct"+ SILICONFLOW_QWEN2_5_7B_INSTRUCT = "Qwen/Qwen2.5-7B-Instruct"+ SILICONFLOW_PRO_QWEN2_5_7B_INSTRUCT = "Pro/Qwen/Qwen2.5-7B-Instruct"+ SILICONFLOW_THUDM_GLM_4_9B_CHAT = "THUDM/glm-4-9b-chat"+ SILICONFLOW_PRO_THUDM_GLM_4_9B_CHAT = "Pro/THUDM/glm-4-9b-chat"+def __str__(self):return self.value@@ -207,6 +221,7 @@ class ModelType(UnifiedModelType, Enum):self.is_groq,self.is_sglang,self.is_moonshot,+ self.is_siliconflow,])@@ -292,7 +307,7 @@ class ModelType(UnifiedModelType, Enum):@propertydef is_sambanova(self) -> bool:- r"""Returns whether this type of models is served by SambaNova AI."""+ r"""Returns whether this type of model is served by SambaNova AI."""return self in {ModelType.SAMBA_LLAMA_3_1_8B,ModelType.SAMBA_LLAMA_3_1_70B,@@ -450,6 +465,23 @@ class ModelType(UnifiedModelType, Enum):ModelType.SGLANG_QWEN_2_5_72B,}+ @property+ def is_siliconflow(self) -> bool:+ return self in {+ ModelType.SILICONFLOW_DEEPSEEK_V2_5,+ ModelType.SILICONFLOW_DEEPSEEK_V3,+ ModelType.SILICONFLOW_INTERN_LM2_5_20B_CHAT,+ ModelType.SILICONFLOW_INTERN_LM2_5_7B_CHAT,+ ModelType.SILICONFLOW_PRO_INTERN_LM2_5_7B_CHAT,+ ModelType.SILICONFLOW_QWEN2_5_72B_INSTRUCT,+ ModelType.SILICONFLOW_QWEN2_5_32B_INSTRUCT,+ ModelType.SILICONFLOW_QWEN2_5_14B_INSTRUCT,+ ModelType.SILICONFLOW_QWEN2_5_7B_INSTRUCT,+ ModelType.SILICONFLOW_PRO_QWEN2_5_7B_INSTRUCT,+ ModelType.SILICONFLOW_THUDM_GLM_4_9B_CHAT,+ ModelType.SILICONFLOW_PRO_THUDM_GLM_4_9B_CHAT,+ }+@propertydef token_limit(self) -> int:r"""Returns the maximum token limit for a given model.@@ -785,6 +817,7 @@ class ModelPlatformType(Enum):SGLANG = "sglang"INTERNLM = "internlm"MOONSHOT = "moonshot"+ SILICONFLOW = "siliconflow"@propertydef is_openai(self) -> bool:@@ -897,6 +930,11 @@ class ModelPlatformType(Enum):r"""Returns whether this platform is Moonshot model."""return self is ModelPlatformType.MOONSHOT+ @property+ def is_siliconflow(self) -> bool:+ r"""Returns whether this platform is SiliconFlow."""+ return self is ModelPlatformType.SILICONFLOW+class AudioModelType(Enum):TTS_1 = "tts-1"diff --git a/examples/models/siliconflow_model_example.py b/examples/models/siliconflow_model_example.pynew file mode 100644index 000000000..f60c45442--- /dev/null+++ b/examples/models/siliconflow_model_example.py@@ -0,0 +1,47 @@+# ========= 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. =========+from camel.agents import ChatAgent+from camel.configs import SiliconFlowConfig+from camel.models import ModelFactory+from camel.types import ModelPlatformType++model = ModelFactory.create(+ model_platform=ModelPlatformType.SILICONFLOW,+ model_type="deepseek-ai/DeepSeek-R1",+ model_config_dict=SiliconFlowConfig(temperature=0.2).as_dict(),+)++# Define system message+sys_msg = "You are a helpful assistant."++# Set agent+camel_agent = ChatAgent(system_message=sys_msg, model=model)++user_msg = """Say hi to CAMEL AI, one open-source community+ dedicated to the study of autonomous and communicative agents."""++# Get response information+response = camel_agent.step(user_msg)+print(response.msgs[0].content)++'''+===============================================================================+Hello CAMEL AI community! 👋 Your dedication to advancing the study of+autonomous and communicative agents through open-source collaboration is truly+inspiring. The work you're doing to push the boundaries of AI interaction and+cooperative systems will undoubtedly shape the future of intelligent+technologies. Keep innovating, exploring, and fostering that spirit of shared+learning—the world is excited to see what you create next! 🚀+===============================================================================+'''