camel-ai 0.1.6.8__py3-none-any.whl → 0.1.7.0__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.6.8'
+__version__ = '0.1.7.0'
 
 __all__ = [
     '__version__',

camel/agents/chat_agent.py

@@ -815,7 +815,7 @@ class ChatAgent(BaseAgent):
                     # When response has not been stopped
                     # Notice that only the first chunk_dict has the "role"
                     content_dict[index] += delta.content
-                else:
+                elif choice.finish_reason:
                     finish_reasons_dict[index] = choice.finish_reason
                     chat_message = BaseMessage(
                         role_name=self.role_name,
@@ -998,7 +998,10 @@ class ChatAgent(BaseAgent):
         Returns:
             dict: Usage dictionary.
         """
-        encoding = get_model_encoding(self.model_type.value_for_tiktoken)
+        if isinstance(self.model_type, ModelType):
+            encoding = get_model_encoding(self.model_type.value_for_tiktoken)
+        else:
+            encoding = get_model_encoding("gpt-4o-mini")
         completion_tokens = 0
         for message in output_messages:
             completion_tokens += len(encoding.encode(message.content))

camel/configs/__init__.py

@@ -20,7 +20,12 @@ from .mistral_config import MISTRAL_API_PARAMS, MistralConfig
 from .ollama_config import OLLAMA_API_PARAMS, OllamaConfig
 from .openai_config import OPENAI_API_PARAMS, ChatGPTConfig, OpenSourceConfig
 from .reka_config import REKA_API_PARAMS, RekaConfig
-from .samba_config import SAMBA_API_PARAMS, SambaConfig
+from .samba_config import (
+    SAMBA_FAST_API_PARAMS,
+    SAMBA_VERSE_API_PARAMS,
+    SambaFastAPIConfig,
+    SambaVerseAPIConfig,
+)
 from .togetherai_config import TOGETHERAI_API_PARAMS, TogetherAIConfig
 from .vllm_config import VLLM_API_PARAMS, VLLMConfig
 from .zhipuai_config import ZHIPUAI_API_PARAMS, ZhipuAIConfig
@@ -48,8 +53,10 @@ __all__ = [
     'MISTRAL_API_PARAMS',
     'RekaConfig',
     'REKA_API_PARAMS',
-    'SambaConfig',
-    'SAMBA_API_PARAMS',
+    'SambaFastAPIConfig',
+    'SAMBA_FAST_API_PARAMS',
+    'SambaVerseAPIConfig',
+    'SAMBA_VERSE_API_PARAMS',
     'TogetherAIConfig',
     'TOGETHERAI_API_PARAMS',
 ]

camel/configs/samba_config.py

@@ -18,24 +18,27 @@ from typing import Any, Dict, Optional, Union
 from camel.configs.base_config import BaseConfig
 
 
-class SambaConfig(BaseConfig):
+class SambaFastAPIConfig(BaseConfig):
     r"""Defines the parameters for generating chat completions using the
-    SambaNova API.
+    SambaNova Fast API.
 
     Args:
         max_tokens (Optional[int], optional): the maximum number of tokens to
-            generate, e.g. 100. Defaults to `None`.
+            generate, e.g. 100.
+            (default: :obj:`2048`)
         stop (Optional[Union[str,list[str]]]): Stop generation if this token
             is detected. Or if one of these tokens is detected when providing
-            a string list. Defaults to `None`.
+            a string list.
+            (default: :obj:`None`)
         stream (Optional[bool]): If True, partial message deltas will be sent
             as data-only server-sent events as they become available.
-            Currently SambaNova only support stream mode. Defaults to `True`.
+            Currently SambaNova Fast API only support stream mode.
+            (default: :obj:`True`)
         stream_options (Optional[Dict]): Additional options for streaming.
-            Defaults to `{"include_usage": True}`.
+            (default: :obj:`{"include_usage": True}`)
     """
 
-    max_tokens: Optional[int] = None
+    max_tokens: Optional[int] = 2048
     stop: Optional[Union[str, list[str]]] = None
     stream: Optional[bool] = True
     stream_options: Optional[Dict] = {"include_usage": True}  # noqa: RUF012
@@ -47,4 +50,60 @@ class SambaConfig(BaseConfig):
         return config_dict
 
 
-SAMBA_API_PARAMS = {param for param in SambaConfig().model_fields.keys()}
+SAMBA_FAST_API_PARAMS = {
+    param for param in SambaFastAPIConfig().model_fields.keys()
+}
+
+
+class SambaVerseAPIConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using the
+    SambaVerse API.
+
+    Args:
+        temperature (float, optional): Sampling temperature to use, between
+            :obj:`0` and :obj:`2`. Higher values make the output more random,
+            while lower values make it more focused and deterministic.
+            (default: :obj:`0.7`)
+        top_p (float, optional): An alternative to sampling with temperature,
+            called nucleus sampling, where the model considers the results of
+            the tokens with top_p probability mass. So :obj:`0.1` means only
+            the tokens comprising the top 10% probability mass are considered.
+            (default: :obj:`0.95`)
+        top_k (int, optional): Only sample from the top K options for each
+            subsequent token. Used to remove "long tail" low probability
+            responses.
+            (default: :obj:`50`)
+        max_tokens (Optional[int], optional): The maximum number of tokens to
+            generate, e.g. 100.
+            (default: :obj:`2048`)
+        repetition_penalty (Optional[float], optional): The parameter for
+            repetition penalty. 1.0 means no penalty.
+            (default: :obj:`1.0`)
+        stop (Optional[Union[str,list[str]]]): Stop generation if this token
+            is detected. Or if one of these tokens is detected when providing
+            a string list.
+            (default: :obj:`""`)
+        stream (Optional[bool]): If True, partial message deltas will be sent
+            as data-only server-sent events as they become available.
+            Currently SambaVerse API doesn't support stream mode.
+            (default: :obj:`False`)
+    """
+
+    temperature: Optional[float] = 0.7
+    top_p: Optional[float] = 0.95
+    top_k: Optional[int] = 50
+    max_tokens: Optional[int] = 2048
+    repetition_penalty: Optional[float] = 1.0
+    stop: Optional[Union[str, list[str]]] = ""
+    stream: Optional[bool] = False
+
+    def as_dict(self) -> dict[str, Any]:
+        config_dict = super().as_dict()
+        if "tools" in config_dict:
+            del config_dict["tools"]  # SambaNova does not support tool calling
+        return config_dict
+
+
+SAMBA_VERSE_API_PARAMS = {
+    param for param in SambaVerseAPIConfig().model_fields.keys()
+}

camel/embeddings/openai_embedding.py

@@ -75,12 +75,19 @@ class OpenAIEmbedding(BaseEmbedding[str]):
                 as a list of floating-point numbers.
         """
         # TODO: count tokens
-        response = self.client.embeddings.create(
-            input=objs,
-            model=self.model_type.value,
-            dimensions=self.output_dim,
-            **kwargs,
-        )
+        if self.model_type == EmbeddingModelType.TEXT_EMBEDDING_ADA_2:
+            response = self.client.embeddings.create(
+                input=objs,
+                model=self.model_type.value,
+                **kwargs,
+            )
+        else:
+            response = self.client.embeddings.create(
+                input=objs,
+                model=self.model_type.value,
+                dimensions=self.output_dim,
+                **kwargs,
+            )
         return [data.embedding for data in response.data]
 
     def get_output_dim(self) -> int:

camel/loaders/firecrawl_reader.py

@@ -17,6 +17,8 @@ from typing import Any, Dict, Optional
 
 from pydantic import BaseModel
 
+from camel.utils import api_keys_required
+
 
 class Firecrawl:
     r"""Firecrawl allows you to turn entire websites into LLM-ready markdown.
@@ -30,6 +32,7 @@ class Firecrawl:
         https://docs.firecrawl.dev/introduction
     """
 
+    @api_keys_required("FIRECRAWL_API_KEY")
     def __init__(
         self,
         api_key: Optional[str] = None,
@@ -211,3 +214,24 @@ class Firecrawl:
             return scrape_result.get("markdown", "")
         except Exception as e:
             raise RuntimeError(f"Failed to perform tidy scrape: {e}")
+
+    def map_site(
+        self, url: str, params: Optional[Dict[str, Any]] = None
+    ) -> list:
+        r"""Map a website to retrieve all accessible URLs.
+
+        Args:
+            url (str): The URL of the site to map.
+            params (Optional[Dict[str, Any]]): Additional parameters for the
+                map request. Defaults to `None`.
+
+        Returns:
+            list: A list containing the URLs found on the site.
+
+        Raises:
+            RuntimeError: If the mapping process fails.
+        """
+        try:
+            return self.app.map_url(url=url, params=params)
+        except Exception as e:
+            raise RuntimeError(f"Failed to map the site: {e}")

camel/models/model_factory.py

@@ -96,8 +96,6 @@ class ModelFactory:
                 model_class = MistralModel
             elif model_platform.is_reka and model_type.is_reka:
                 model_class = RekaModel
-            elif model_platform.is_samba and model_type.is_samba:
-                model_class = SambaModel
             elif model_type == ModelType.STUB:
                 model_class = StubModel
             else:
@@ -117,6 +115,8 @@ class ModelFactory:
                 model_class = LiteLLMModel
             elif model_platform.is_openai_compatibility_model:
                 model_class = OpenAICompatibilityModel
+            elif model_platform.is_samba:
+                model_class = SambaModel
             elif model_platform.is_together:
                 model_class = TogetherAIModel
                 return model_class(

camel/models/ollama_model.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import os
+import subprocess
 from typing import Any, Dict, List, Optional, Union
 
 from openai import OpenAI, Stream
@@ -48,17 +49,38 @@ class OllamaModel:
         """
         self.model_type = model_type
         self.model_config_dict = model_config_dict
-        self._url = url or os.environ.get("OLLAMA_BASE_URL")
-        # Use OpenAI cilent as interface call Ollama
+        self._url = (
+            url
+            or os.environ.get("OLLAMA_BASE_URL")
+            or "http://localhost:11434/v1"
+        )
+        if not url and not os.environ.get("OLLAMA_BASE_URL"):
+            self._start_server()
+        # Use OpenAI client as interface call Ollama
         self._client = OpenAI(
             timeout=60,
             max_retries=3,
-            base_url=self._url or "http://localhost:11434/v1",
+            base_url=self._url,
             api_key="ollama",  # required but ignored
         )
         self._token_counter = token_counter
         self.check_model_config()
 
+    def _start_server(self) -> None:
+        r"""Starts the Ollama server in a subprocess."""
+        try:
+            subprocess.Popen(
+                ["ollama", "server", "--port", "11434"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+            print(
+                f"Ollama server started on http://localhost:11434/v1 "
+                f"for {self.model_type} model"
+            )
+        except Exception as e:
+            print(f"Failed to start Ollama server: {e}")
+
     @property
     def token_counter(self) -> BaseTokenCounter:
         r"""Initialize the token counter for the model backend.
@@ -111,7 +133,7 @@ class OllamaModel:
 
     @property
     def token_limit(self) -> int:
-        """Returns the maximum token limit for the given model.
+        r"""Returns the maximum token limit for the given model.
 
         Returns:
             int: The maximum token limit for the given model.