camel-ai 0.2.19__py3-none-any.whl → 0.2.20a1__py3-none-any.whl

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)

camel/toolkits/__init__.py

@@ -45,6 +45,7 @@ from .human_toolkit import HumanToolkit
 from .stripe_toolkit import StripeToolkit
 from .video_toolkit import VideoDownloaderToolkit
 from .dappier_toolkit import DappierToolkit
+from .semantic_scholar_toolkit import SemanticScholarToolkit
 
 __all__ = [
     'BaseToolkit',
@@ -77,4 +78,5 @@ __all__ = [
     'MeshyToolkit',
     'OpenBBToolkit',
     'DappierToolkit',
+    'SemanticScholarToolkit',
 ]

camel/toolkits/search_toolkit.py

@@ -580,6 +580,18 @@ class SearchToolkit(BaseToolkit):
                 "image_url": image_url,
             }
 
+            # For Results pod, collect all plaintext values from subpods
+            if pod.get("@title") == "Results":
+                results_text = []
+                if isinstance(subpod_data, list):
+                    for subpod in subpod_data:
+                        if subpod.get("plaintext"):
+                            results_text.append(subpod["plaintext"])
+                else:
+                    if description:
+                        results_text.append(description)
+                pod_info["description"] = "\n".join(results_text)
+
             # Add to steps list
             output["pod_info"].append(pod_info)
 

camel/toolkits/semantic_scholar_toolkit.py

@@ -0,0 +1,308 @@
+# ========= 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 json
+from typing import List, Optional
+
+import requests
+
+from camel.toolkits import FunctionTool
+from camel.toolkits.base import BaseToolkit
+
+
+class SemanticScholarToolkit(BaseToolkit):
+    r"""A toolkit for interacting with the Semantic Scholar
+    API to fetch paper and author data.
+    """
+
+    def __init__(self):
+        r"""Initializes the SemanticScholarToolkit."""
+        self.base_url = "https://api.semanticscholar.org/graph/v1"
+
+    def fetch_paper_data_title(
+        self,
+        paper_title: str,
+        fields: Optional[List[str]] = None,
+    ) -> dict:
+        r"""Fetches a SINGLE paper from the Semantic Scholar
+        API based on a paper title.
+
+        Args:
+            paper_title (str): The title of the paper to fetch.
+            fields (Optional[List[str]], optional): The fields to include in
+                the response (default: :obj:`None`). If not provided defaults
+                to ["title", "abstract", "authors", "year", "citationCount",
+                "publicationTypes", "publicationDate", "openAccessPdf"].
+
+        Returns:
+            dict: The response data from the API or error information if the
+                 request fails.
+        """
+        if fields is None:
+            fields = [
+                "title",
+                "abstract",
+                "authors",
+                "year",
+                "citationCount",
+                "publicationTypes",
+                "publicationDate",
+                "openAccessPdf",
+            ]
+
+        url = f"{self.base_url}/paper/search"
+        query_params = {"query": paper_title, "fields": ",".join(fields)}
+        try:
+            response = requests.get(url, params=query_params)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            return {
+                "error": f"Request failed: {e!s}",
+                "message": str(e),
+            }
+        except ValueError:
+            return {
+                "error": "Response is not valid JSON",
+                "message": response.text,
+            }
+
+    def fetch_paper_data_id(
+        self,
+        paper_id: str,
+        fields: Optional[List[str]] = None,
+    ) -> dict:
+        r"""Fetches a SINGLE paper from the Semantic Scholar
+        API based on a paper ID.
+
+        Args:
+            paper_id (str): The ID of the paper to fetch.
+            fields (Optional[List[str]], optional): The fields to include in
+                the response (default: :obj:`None`). If not provided defaults
+                to ["title", "abstract", "authors", "year", "citationCount",
+                "publicationTypes", "publicationDate", "openAccessPdf"].
+
+        Returns:
+            dict: The response data from the API or error information
+                if the request fails.
+        """
+        if fields is None:
+            fields = [
+                "title",
+                "abstract",
+                "authors",
+                "year",
+                "citationCount",
+                "publicationTypes",
+                "publicationDate",
+                "openAccessPdf",
+            ]
+
+        url = f"{self.base_url}/paper/{paper_id}"
+        query_params = {"fields": ",".join(fields)}
+        try:
+            response = requests.get(url, params=query_params)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            return {
+                "error": f"Request failed: {e!s}",
+                "message": str(e),
+            }
+        except ValueError:
+            return {
+                "error": "Response is not valid JSON",
+                "message": response.text,
+            }
+
+    def fetch_bulk_paper_data(
+        self,
+        query: str,
+        year: str = "2023-",
+        fields: Optional[List[str]] = None,
+    ) -> dict:
+        r"""Fetches MULTIPLE papers at once from the Semantic Scholar
+        API based on a related topic.
+
+        Args:
+            query (str): The text query to match against the paper's title and
+                abstract. For example, you can use the following operators and
+                techniques to construct your query: Example 1: ((cloud
+                computing) | virtualization) +security -privacy This will
+                match papers whose title or abstract contains "cloud" and
+                "computing", or contains the word "virtualization". The papers
+                must also include the term "security" but exclude papers that
+                contain the word "privacy".
+            year (str, optional): The year filter for papers (default:
+                :obj:`"2023-"`).
+            fields (Optional[List[str]], optional): The fields to include in
+                the response (default: :obj:`None`). If not provided defaults
+                to ["title", "url", "publicationTypes", "publicationDate",
+                "openAccessPdf"].
+
+        Returns:
+            dict: The response data from the API or error information if the
+                request fails.
+        """
+        if fields is None:
+            fields = [
+                "title",
+                "url",
+                "publicationTypes",
+                "publicationDate",
+                "openAccessPdf",
+            ]
+
+        url = f"{self.base_url}/paper/search/bulk"
+        query_params = {
+            "query": query,
+            "fields": ",".join(fields),
+            "year": year,
+        }
+        try:
+            response = requests.get(url, params=query_params)
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            return {
+                "error": f"Request failed: {e!s}",
+                "message": str(e),
+            }
+        except ValueError:
+            return {
+                "error": "Response is not valid JSON",
+                "message": response.text,
+            }
+
+    def fetch_recommended_papers(
+        self,
+        positive_paper_ids: List[str],
+        negative_paper_ids: List[str],
+        fields: Optional[List[str]] = None,
+        limit: int = 500,
+        save_to_file: bool = False,
+    ) -> dict:
+        r"""Fetches recommended papers from the Semantic Scholar
+        API based on the positive and negative paper IDs.
+
+        Args:
+            positive_paper_ids (list): A list of paper IDs (as strings)
+                that are positively correlated to the recommendation.
+            negative_paper_ids (list): A list of paper IDs (as strings)
+                that are negatively correlated to the recommendation.
+            fields (Optional[List[str]], optional): The fields to include in
+                the response (default: :obj:`None`). If not provided defaults
+                to ["title", "url", "citationCount", "authors",
+                "publicationTypes", "publicationDate", "openAccessPdf"].
+            limit (int, optional): The maximum number of recommended papers to
+                return (default: :obj:`500`).
+            save_to_file (bool, optional): If True, saves the response data to
+                a file (default: :obj:`False`).
+
+        Returns:
+            dict: A dictionary containing recommended papers sorted by
+                citation count.
+        """
+        if fields is None:
+            fields = [
+                "title",
+                "url",
+                "citationCount",
+                "authors",
+                "publicationTypes",
+                "publicationDate",
+                "openAccessPdf",
+            ]
+
+        url = "https://api.semanticscholar.org/recommendations/v1/papers"
+        query_params = {"fields": ",".join(fields), "limit": str(limit)}
+        data = {
+            "positive_paper_ids": positive_paper_ids,
+            "negative_paper_ids": negative_paper_ids,
+        }
+        try:
+            response = requests.post(url, params=query_params, json=data)
+            response.raise_for_status()
+            papers = response.json()
+            if save_to_file:
+                with open('recommended_papers.json', 'w') as output:
+                    json.dump(papers, output)
+            return papers
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+        except ValueError:
+            return {
+                "error": "Response is not valid JSON",
+                "message": response.text,
+            }
+
+    def fetch_author_data(
+        self,
+        ids: List[str],
+        fields: Optional[List[str]] = None,
+        save_to_file: bool = False,
+    ) -> dict:
+        r"""Fetches author information from the Semantic Scholar
+        API based on author IDs.
+
+        Args:
+            ids (list): A list of author IDs (as strings) to fetch
+                data for.
+            fields (Optional[List[str]], optional): The fields to include in
+                the response (default: :obj:`None`). If not provided defaults
+                to ["name", "url", "paperCount", "hIndex", "papers"].
+            save_to_file (bool, optional): Whether to save the results to a
+                file (default: :obj:`False`).
+
+        Returns:
+            dict: The response data from the API or error information if
+                the request fails.
+        """
+        if fields is None:
+            fields = ["name", "url", "paperCount", "hIndex", "papers"]
+
+        url = f"{self.base_url}/author/batch"
+        query_params = {"fields": ",".join(fields)}
+        data = {"ids": ids}
+        try:
+            response = requests.post(url, params=query_params, json=data)
+            response.raise_for_status()
+            response_data = response.json()
+            if save_to_file:
+                with open('author_information.json', 'w') as output:
+                    json.dump(response_data, output)
+            return response_data
+        except requests.exceptions.RequestException as e:
+            return {"error": str(e)}
+        except ValueError:
+            return {
+                "error": "Response is not valid JSON",
+                "message": response.text,
+            }
+
+    def get_tools(self) -> List[FunctionTool]:
+        r"""Returns a list of FunctionTool objects representing the
+        functions in the toolkit.
+
+        Returns:
+            List[FunctionTool]: A list of FunctionTool objects
+                representing the functions in the toolkit.
+        """
+        return [
+            FunctionTool(self.fetch_paper_data_title),
+            FunctionTool(self.fetch_paper_data_id),
+            FunctionTool(self.fetch_bulk_paper_data),
+            FunctionTool(self.fetch_recommended_papers),
+            FunctionTool(self.fetch_author_data),
+        ]