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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: camel-ai
-Version: 0.1.5.6
+Version: 0.1.6.1
 Summary: Communicative Agents for AI Society Study
 Home-page: https://www.camel-ai.org/
 License: Apache-2.0
@@ -24,6 +24,7 @@ Provides-Extra: tools
 Provides-Extra: vector-databases
 Requires-Dist: PyMuPDF (>=1.22.5,<2.0.0) ; extra == "tools" or extra == "all"
 Requires-Dist: accelerate (>=0,<1) ; extra == "huggingface-agent" or extra == "all"
+Requires-Dist: agentops (>=0.3.6,<0.4.0) ; extra == "tools" or extra == "all"
 Requires-Dist: anthropic (>=0.29.0,<0.30.0)
 Requires-Dist: beautifulsoup4 (>=4,<5) ; extra == "tools" or extra == "all"
 Requires-Dist: cohere (>=4.56,<5.0) ; extra == "retrievers" or extra == "all"
@@ -36,12 +37,18 @@ 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: eval-type-backport (==0.2.0)
+Requires-Dist: firecrawl-py (>=0.0.20,<0.0.21) ; 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: groq (>=0.5.0,<0.6.0)
 Requires-Dist: imageio[pyav] (>=2.34.2,<3.0.0) ; extra == "tools" or extra == "all"
+Requires-Dist: ipykernel (>=6.0.0,<7.0.0)
 Requires-Dist: jsonschema (>=4,<5)
+Requires-Dist: jupyter_client (>=8.6.2,<9.0.0) ; extra == "tools" or extra == "all"
 Requires-Dist: litellm (>=1.38.1,<2.0.0) ; extra == "model-platforms" or extra == "all"
-Requires-Dist: milvus-lite (>=2.4.0,<=2.4.7)
+Requires-Dist: mistral-common (>=1.3.3,<2.0.0) ; extra == "model-platforms" or extra == "all"
+Requires-Dist: mistralai (>=0.4.2,<0.5.0) ; extra == "model-platforms" or extra == "all"
 Requires-Dist: mock (>=5,<6) ; extra == "test"
 Requires-Dist: neo4j (>=5.18.0,<6.0.0) ; extra == "graph-storages" or extra == "all"
 Requires-Dist: newspaper3k (>=0.2.8,<0.3.0) ; extra == "tools" or extra == "all"
@@ -191,7 +198,7 @@ conda create --name camel python=3.9
 conda activate camel
 
 # Clone github repo
-git clone -b v0.1.5.6 https://github.com/camel-ai/camel.git
+git clone -b v0.1.6.1 https://github.com/camel-ai/camel.git
 
 # Change directory into project directory
 cd camel
@@ -317,6 +324,41 @@ Please note that the environment variable is session-specific. If you open a new
     print(assistant_response.msg.content)
     ```
 
+## Use Open-Source Models as Backends (ex. using vLLM to set Phi-3 locally)
+- [Install vLLM](https://docs.vllm.ai/en/latest/getting_started/installation.html)
+- After setting up vLLM, start an OpenAI compatible server for example by
+    ```bash
+    python -m vllm.entrypoints.openai.api_server --model microsoft/Phi-3-mini-4k-instruct --api-key vllm --dtype bfloat16
+    ```
+- Create and run following script (more details please refer to this [example](https://github.com/camel-ai/camel/blob/master/examples/models/vllm_model_example.py))
+    ```python
+    from camel.agents import ChatAgent
+    from camel.messages import BaseMessage
+    from camel.models import ModelFactory
+    from camel.types import ModelPlatformType
+
+    vllm_model = ModelFactory.create(
+        model_platform=ModelPlatformType.VLLM,
+        model_type="microsoft/Phi-3-mini-4k-instruct",
+        url="http://localhost:8000/v1",
+        model_config_dict={"temperature": 0.0},
+        api_key="vllm",
+    )
+
+    assistant_sys_msg = BaseMessage.make_assistant_message(
+        role_name="Assistant",
+        content="You are a helpful assistant.",
+    )
+    agent = ChatAgent(assistant_sys_msg, model=vllm_model, token_limit=4096)
+
+    user_msg = BaseMessage.make_user_message(
+        role_name="User",
+        content="Say hi to CAMEL AI",
+    )
+    assistant_response = agent.step(user_msg)
+    print(assistant_response.msg.content)
+    ```
+
 ## Data (Hosted on Hugging Face)
 | Dataset        | Chat format                                                                                         | Instruction format                                                                                               | Chat format (translated)                                                                   |
 |----------------|-----------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|

{camel_ai-0.1.5.6 → camel_ai-0.1.6.1}/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.6 https://github.com/camel-ai/camel.git
+git clone -b v0.1.6.1 https://github.com/camel-ai/camel.git
 
 # Change directory into project directory
 cd camel
@@ -236,6 +236,41 @@ Please note that the environment variable is session-specific. If you open a new
     print(assistant_response.msg.content)
     ```
 
+## Use Open-Source Models as Backends (ex. using vLLM to set Phi-3 locally)
+- [Install vLLM](https://docs.vllm.ai/en/latest/getting_started/installation.html)
+- After setting up vLLM, start an OpenAI compatible server for example by
+    ```bash
+    python -m vllm.entrypoints.openai.api_server --model microsoft/Phi-3-mini-4k-instruct --api-key vllm --dtype bfloat16
+    ```
+- Create and run following script (more details please refer to this [example](https://github.com/camel-ai/camel/blob/master/examples/models/vllm_model_example.py))
+    ```python
+    from camel.agents import ChatAgent
+    from camel.messages import BaseMessage
+    from camel.models import ModelFactory
+    from camel.types import ModelPlatformType
+
+    vllm_model = ModelFactory.create(
+        model_platform=ModelPlatformType.VLLM,
+        model_type="microsoft/Phi-3-mini-4k-instruct",
+        url="http://localhost:8000/v1",
+        model_config_dict={"temperature": 0.0},
+        api_key="vllm",
+    )
+
+    assistant_sys_msg = BaseMessage.make_assistant_message(
+        role_name="Assistant",
+        content="You are a helpful assistant.",
+    )
+    agent = ChatAgent(assistant_sys_msg, model=vllm_model, token_limit=4096)
+
+    user_msg = BaseMessage.make_user_message(
+        role_name="User",
+        content="Say hi to CAMEL AI",
+    )
+    assistant_response = agent.step(user_msg)
+    print(assistant_response.msg.content)
+    ```
+
 ## Data (Hosted on Hugging Face)
 | Dataset        | Chat format                                                                                         | Instruction format                                                                                               | Chat format (translated)                                                                   |
 |----------------|-----------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------|

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

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

{camel_ai-0.1.5.6 → camel_ai-0.1.6.1}/camel/agents/chat_agent.py

@@ -15,8 +15,18 @@ from __future__ import annotations
 
 import json
 from collections import defaultdict
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Union,
+)
+
+from pydantic import BaseModel
 
 from camel.agents.base import BaseAgent
 from camel.configs import ChatGPTConfig
@@ -37,17 +47,33 @@ from camel.types import (
     OpenAIBackendRole,
     RoleType,
 )
-from camel.utils import get_model_encoding
+from camel.utils import (
+    Constants,
+    func_string_to_callable,
+    get_model_encoding,
+    get_pydantic_object_schema,
+    json_to_function_code,
+)
 
 if TYPE_CHECKING:
     from openai import Stream
 
-    from camel.functions import OpenAIFunction
     from camel.terminators import ResponseTerminator
+    from camel.toolkits import OpenAIFunction
+
+# AgentOps decorator setting
+try:
+    from agentops import track_agent
+except ImportError:
 
+    def track_agent():
+        def noop(f):
+            return f
 
-@dataclass(frozen=True)
-class FunctionCallingRecord:
+        return noop
+
+
+class FunctionCallingRecord(BaseModel):
     r"""Historical records of functions called in the conversation.
 
     Attributes:
@@ -67,14 +93,17 @@ class FunctionCallingRecord:
         Returns:
             str: Modified string to represent the function calling.
         """
-
         return (
             f"Function Execution: {self.func_name}\n"
             f"\tArgs: {self.args}\n"
             f"\tResult: {self.result}"
         )
 
+    def as_dict(self) -> dict[str, Any]:
+        return self.model_dump()
 
+
+@track_agent(name="ChatAgent")
 class ChatAgent(BaseAgent):
     r"""Class for managing conversations of CAMEL Chat Agents.
 
@@ -82,7 +111,7 @@ class ChatAgent(BaseAgent):
         system_message (BaseMessage): The system message for the chat agent.
         model (BaseModelBackend, optional): The model backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_3_5_TURBO`)
+            `GPT_4O_MINI`)
         api_key (str, optional): The API key for authenticating with the
             LLM service. Only OpenAI and Anthropic model supported (default:
             :obj:`None`)
@@ -127,8 +156,8 @@ class ChatAgent(BaseAgent):
             if model is not None
             else ModelFactory.create(
                 model_platform=ModelPlatformType.OPENAI,
-                model_type=ModelType.GPT_3_5_TURBO,
-                model_config_dict=ChatGPTConfig().__dict__,
+                model_type=ModelType.GPT_4O_MINI,
+                model_config_dict=ChatGPTConfig().as_dict(),
                 api_key=self._api_key,
             )
         )
@@ -209,7 +238,9 @@ class ChatAgent(BaseAgent):
                 messages.
             role (OpenAIBackendRole): The backend role type.
         """
-        self.memory.write_record(MemoryRecord(message, role))
+        self.memory.write_record(
+            MemoryRecord(message=message, role_at_backend=role)
+        )
 
     def set_output_language(self, output_language: str) -> BaseMessage:
         r"""Sets the output language for the system message. This method
@@ -268,7 +299,8 @@ class ChatAgent(BaseAgent):
         message.
         """
         system_record = MemoryRecord(
-            self.system_message, OpenAIBackendRole.SYSTEM
+            message=self.system_message,
+            role_at_backend=OpenAIBackendRole.SYSTEM,
         )
         self.memory.clear()
         self.memory.write_record(system_record)
@@ -287,6 +319,7 @@ class ChatAgent(BaseAgent):
     def step(
         self,
         input_message: BaseMessage,
+        output_schema: Optional[BaseModel] = None,
     ) -> ChatAgentResponse:
         r"""Performs a single step in the chat session by generating a response
         to the input message.
@@ -297,6 +330,10 @@ class ChatAgent(BaseAgent):
                 either `user` or `assistant` but it will be set to `user`
                 anyway since for the self agent any incoming message is
                 external.
+            output_schema (Optional[BaseModel]): An optional pydantic model
+                that includes value types and field descriptions used to
+                generate a structured response by LLM. This schema helps
+                in defining the expected output format.
 
         Returns:
             ChatAgentResponse: A struct containing the output messages,
@@ -310,7 +347,7 @@ class ChatAgent(BaseAgent):
         tool_calls: List[FunctionCallingRecord] = []
         while True:
             # Format messages and get the token number
-            openai_messages: list[OpenAIMessage] | None
+            openai_messages: Optional[List[OpenAIMessage]]
 
             try:
                 openai_messages, num_tokens = self.memory.get_context()
@@ -318,6 +355,15 @@ class ChatAgent(BaseAgent):
                 return self.step_token_exceed(
                     e.args[1], tool_calls, "max_tokens_exceeded"
                 )
+            # use structed output response without tools
+            # If the user provides the output_schema parameter and does not
+            # specify the use of tools, then in the model config of the
+            # chatgent, call the model specified by tools with
+            # return_json_response of OpenAIFunction format, and return a
+            # structured response with the user-specified output schema.
+            if output_schema is not None and len(self.func_dict) == 0:
+                self._add_output_schema_to_tool_list(output_schema)
+
             (
                 response,
                 output_messages,
@@ -333,9 +379,8 @@ class ChatAgent(BaseAgent):
             ):
                 # Tools added for function calling and not in stream mode
 
-                # Do function calling
-                func_assistant_msg, func_result_msg, func_record = (
-                    self.step_tool_call(response)
+                tool_calls, func_assistant_msg, func_result_msg = (
+                    self._add_tools_for_func_call(response, tool_calls)
                 )
 
                 # Update the messages
@@ -344,11 +389,44 @@ class ChatAgent(BaseAgent):
                 )
                 self.update_memory(func_result_msg, OpenAIBackendRole.FUNCTION)
 
-                # Record the function calling
-                tool_calls.append(func_record)
-
             else:
-                # Function calling disabled or not a function calling
+                # If the user specifies tools, it is necessary to wait for the
+                # model to complete all tools' calls. Finally, use the
+                # generated response as the input for the structure,
+                # simultaneously calling the return_json_response function.
+                # Call the model again with return_json_response in the format
+                # of OpenAIFunction as the last tool, returning a structured
+                # response with the user-specified output schema.
+                if output_schema is not None and all(
+                    record.func_name
+                    != Constants.FUNC_NAME_FOR_STRUCTURE_OUTPUT
+                    for record in tool_calls
+                ):
+                    self._add_output_schema_to_tool_list(output_schema)
+
+                    (
+                        response,
+                        output_messages,
+                        finish_reasons,
+                        usage_dict,
+                        response_id,
+                    ) = self._step_model_response(openai_messages, num_tokens)
+
+                    if isinstance(response, ChatCompletion):
+                        # Tools added for function calling and not in stream
+                        # mode
+                        tool_calls, func_assistant_msg, func_result_msg = (
+                            self._add_tools_for_func_call(response, tool_calls)
+                        )
+
+                        # Update the messages
+                        self.update_memory(
+                            func_assistant_msg, OpenAIBackendRole.ASSISTANT
+                        )
+                        self.update_memory(
+                            func_result_msg, OpenAIBackendRole.FUNCTION
+                        )
+
                 info = self._step_get_info(
                     output_messages,
                     finish_reasons,
@@ -359,20 +437,34 @@ class ChatAgent(BaseAgent):
                 )
                 break
 
-        return ChatAgentResponse(output_messages, self.terminated, info)
+        # if use structure response, set structure result as content of
+        # BaseMessage
+        if output_schema and self.model_type.is_openai:
+            for base_message_item in output_messages:
+                base_message_item.content = str(info['tool_calls'][-1].result)
+
+        return ChatAgentResponse(
+            msgs=output_messages, terminated=self.terminated, info=info
+        )
 
     async def step_async(
         self,
         input_message: BaseMessage,
+        output_schema: Optional[BaseModel] = None,
     ) -> ChatAgentResponse:
         r"""Performs a single step in the chat session by generating a response
         to the input message. This agent step can call async function calls.
 
         Args:
             input_message (BaseMessage): The input message to the agent.
-            Its `role` field that specifies the role at backend may be either
-            `user` or `assistant` but it will be set to `user` anyway since
-            for the self agent any incoming message is external.
+                Its `role` field that specifies the role at backend may be
+                either `user` or `assistant` but it will be set to `user`
+                anyway since for the self agent any incoming message is
+                external.
+            output_schema (Optional[BaseModel]): An optional pydantic model
+                that includes value types and field descriptions used to
+                generate a structured response by LLM. This schema helps
+                in defining the expected output format.
 
         Returns:
             ChatAgentResponse: A struct containing the output messages,
@@ -386,7 +478,7 @@ class ChatAgent(BaseAgent):
         tool_calls: List[FunctionCallingRecord] = []
         while True:
             # Format messages and get the token number
-            openai_messages: list[OpenAIMessage] | None
+            openai_messages: Optional[List[OpenAIMessage]]
 
             try:
                 openai_messages, num_tokens = self.memory.get_context()
@@ -394,6 +486,9 @@ class ChatAgent(BaseAgent):
                 return self.step_token_exceed(
                     e.args[1], tool_calls, "max_tokens_exceeded"
                 )
+            if output_schema is not None:
+                self._add_output_schema_to_tool_list(output_schema)
+
             (
                 response,
                 output_messages,
@@ -426,6 +521,37 @@ class ChatAgent(BaseAgent):
                 tool_calls.append(func_record)
 
             else:
+                # use structed output response without tools
+                if output_schema is not None and all(
+                    record.func_name
+                    != Constants.FUNC_NAME_FOR_STRUCTURE_OUTPUT
+                    for record in tool_calls
+                ):
+                    self._add_output_schema_to_tool_list(output_schema)
+
+                    (
+                        response,
+                        output_messages,
+                        finish_reasons,
+                        usage_dict,
+                        response_id,
+                    ) = self._step_model_response(openai_messages, num_tokens)
+
+                    if isinstance(response, ChatCompletion):
+                        # Tools added for function calling and not in stream
+                        # mode
+                        tool_calls, func_assistant_msg, func_result_msg = (
+                            self._add_tools_for_func_call(response, tool_calls)
+                        )
+
+                        # Update the messages
+                        self.update_memory(
+                            func_assistant_msg, OpenAIBackendRole.ASSISTANT
+                        )
+                        self.update_memory(
+                            func_result_msg, OpenAIBackendRole.FUNCTION
+                        )
+
                 # Function calling disabled or not a function calling
                 info = self._step_get_info(
                     output_messages,
@@ -437,17 +563,100 @@ class ChatAgent(BaseAgent):
                 )
                 break
 
-        return ChatAgentResponse(output_messages, self.terminated, info)
+        # if use structure response, set structure result as content of
+        # BaseMessage
+        if output_schema and self.model_type.is_openai:
+            for base_message_item in output_messages:
+                base_message_item.content = str(info['tool_calls'][0].result)
+
+        return ChatAgentResponse(
+            msgs=output_messages, terminated=self.terminated, info=info
+        )
+
+    def _add_tools_for_func_call(
+        self,
+        response: ChatCompletion,
+        tool_calls: List[FunctionCallingRecord],
+    ) -> tuple[
+        List[FunctionCallingRecord],
+        FunctionCallingMessage,
+        FunctionCallingMessage,
+    ]:
+        r"""
+        Handles adding tools for function calls based on the response.
+        This method processes a function call within the chat completion
+        response, and records the function call in the provided
+        list of tool calls.
+        Args:
+            response (ChatCompletion): The response object from the chat
+                completion.
+            tool_calls (List[FunctionCallingRecord]): The list to record
+                function calls.
+        Returns:
+            tuple: A tuple containing:
+                - List[FunctionCallingRecord]: The updated list of function
+                  call records.
+                - FunctionCallingMessage: The assistant's message regarding the
+                  function call.
+                - FunctionCallingMessage: The result message of the function
+                  call.
+        """
+
+        # Perform function calling
+        func_assistant_msg, func_result_msg, func_record = self.step_tool_call(
+            response
+        )
+
+        # Record the function call in the list of tool calls
+        tool_calls.append(func_record)
+
+        # Return updated tool calls list, assistant's message, and function
+        # result message
+        return tool_calls, func_assistant_msg, func_result_msg
+
+    def _add_output_schema_to_tool_list(self, output_schema: BaseModel):
+        r"""Handles the structured output response for OpenAI.
+        This method processes the given output schema and integrates the
+        resulting function into the tools for the OpenAI model configuration.
+        Args:
+            output_schema (BaseModel): The schema representing the expected
+                output structure.
+        """
+        from camel.toolkits import OpenAIFunction
+
+        # step 1 extract the output_schema info as json.
+        schema_json = get_pydantic_object_schema(output_schema)
+
+        # step 2 convert output schema json as callable string
+        func_str = json_to_function_code(schema_json)
+
+        # step 3 get callable function from string
+        func_callable = func_string_to_callable(func_str)
+
+        # step 4 add return_json_func into tools
+        func = OpenAIFunction(func_callable)
+        tools = [func]
+        self.func_dict[func.get_function_name()] = func.func
+        if self.model_type.is_openai:
+            self.model_backend.model_config_dict = ChatGPTConfig(
+                tools=tools
+            ).as_dict()
+        elif self.model_type.is_gemini:
+            from camel.configs.gemini_config import GeminiConfig
+
+            self.model_backend.model_config_dict = GeminiConfig(
+                tools=tools
+            ).as_dict()
 
     def _step_model_response(
         self,
-        openai_messages: list[OpenAIMessage],
+        openai_messages: List[OpenAIMessage],
         num_tokens: int,
     ) -> tuple[
-        ChatCompletion | Stream[ChatCompletionChunk],
-        list[BaseMessage],
-        list[str],
-        dict[str, int],
+        Union[ChatCompletion, Stream],
+        List[BaseMessage],
+        List[str],
+        Dict[str, int],
         str,
     ]:
         r"""Internal function for agent step model response."""
@@ -617,9 +826,9 @@ class ChatAgent(BaseAgent):
         )
 
         return ChatAgentResponse(
-            output_messages,
-            self.terminated,
-            info,
+            msgs=output_messages,
+            terminated=self.terminated,
+            info=info,
         )
 
     def step_tool_call(
@@ -676,7 +885,9 @@ class ChatAgent(BaseAgent):
         )
 
         # Record information about this function call
-        func_record = FunctionCallingRecord(func_name, args, result)
+        func_record = FunctionCallingRecord(
+            func_name=func_name, args=args, result=result
+        )
         return assist_msg, func_msg, func_record
 
     async def step_tool_call_async(
@@ -735,7 +946,9 @@ class ChatAgent(BaseAgent):
         )
 
         # Record information about this function call
-        func_record = FunctionCallingRecord(func_name, args, result)
+        func_record = FunctionCallingRecord(
+            func_name=func_name, args=args, result=result
+        )
         return assist_msg, func_msg, func_record
 
     def get_usage_dict(

{camel_ai-0.1.5.6 → camel_ai-0.1.6.1}/camel/agents/critic_agent.py

@@ -24,7 +24,19 @@ from camel.models import BaseModelBackend
 from camel.responses import ChatAgentResponse
 from camel.utils import get_first_int, print_text_animated
 
+# AgentOps decorator setting
+try:
+    from agentops import track_agent
+except ImportError:
 
+    def track_agent():
+        def noop(f):
+            return f
+
+        return noop
+
+
+@track_agent(name="CriticAgent")
 class CriticAgent(ChatAgent):
     r"""A class for the critic agent that assists in selecting an option.
 
@@ -33,7 +45,7 @@ class CriticAgent(ChatAgent):
             agent.
         model (BaseModelBackend, optional): The model backend to use for
             generating responses. (default: :obj:`OpenAIModel` with
-            `GPT_3_5_TURBO`)
+            `GPT_4O_MINI`)
         message_window_size (int, optional): The maximum number of previous
             messages to include in the context window. If `None`, no windowing
             is performed. (default: :obj:`6`)
@@ -184,4 +196,8 @@ class CriticAgent(ChatAgent):
         output_msg = meta_chat_message.create_new_instance(option)
 
         # TODO: The return `info` can be improved.
-        return ChatAgentResponse([output_msg], terminated=False, info={})
+        return ChatAgentResponse(
+            msgs=[output_msg],
+            terminated=False,
+            info={},
+        )