agentica 0.2.2__tar.gz → 0.2.3__tar.gz

{agentica-0.2.2/agentica.egg-info → agentica-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: agentica
-Version: 0.2.2
+Version: 0.2.3
 Summary: LLM agents
 Home-page: https://github.com/shibing624/agentica
 Author: XuMing
@@ -49,14 +49,11 @@ Requires-Dist: rich
 [![Wechat Group](https://img.shields.io/badge/wechat-group-green.svg?logo=wechat)](#Contact)
 
 
-**Agentica**: Build Smarter, Reflective, and Collaborative AI Agents with Ease!
+**Agentica**: 轻松构建智能、具备反思能力、可协作的多模态AI Agent。
 
-**Agentica**: 快速打造智能、能反思、协作的AI Agent。
 
 ## 📖 Introduction
 
-**Agentica** can build AI agent, which have the components of planning, memory, and tool use. 
-
 **Agentica** 可以构建AI Agent，包括规划、记忆和工具使用、执行等组件。
 
 #### Agent Components
@@ -79,6 +76,8 @@ Requires-Dist: rich
 - **Solver**：求解器将所有这些输出整合为最终答案
 
 ## 🔥 News
+[2024/12/29] v0.2.3版本: 支持了`ZhipuAI`的api调用，包括免费模型和工具使用，详见[Release-v0.2.3](https://github.com/shibing624/agentica/releases/tag/0.2.3)
+
 [2024/12/25] v0.2.0版本: 支持了多模态模型，输入可以是文本、图片、音频、视频，升级Assistant为Agent，Workflow支持拆解并实现复杂任务，详见[Release-v0.2.0](https://github.com/shibing624/agentica/releases/tag/0.2.0)
 
 [2024/07/02] v0.1.0版本：实现了基于LLM的Assistant，可以快速用function call搭建大语言模型助手，详见[Release-v0.1.0](https://github.com/shibing624/agentica/releases/tag/0.1.0)
@@ -121,7 +120,7 @@ cd examples
 python web_search_moonshot_demo.py
 ```
 
-1. 复制[.env.example](https://github.com/shibing624/agentica/blob/main/.env.example)文件为`~/.agentica/.env`，并填写LLM api key(选填DEEPSEEK_API_KEY、MOONSHOT_API_KEY、OPENAI_API_KEY等任一个即可)。或者使用`export`命令设置环境变量：
+1. 复制[.env.example](https://github.com/shibing624/agentica/blob/main/.env.example)文件为`~/.agentica/.env`，并填写LLM api key(选填DEEPSEEK_API_KEY、MOONSHOT_API_KEY、OPENAI_API_KEY、ZHIPUAI_API_KEY等任一个即可)。或者使用`export`命令设置环境变量：
     
     ```shell
     export MOONSHOT_API_KEY=your_moonshot_api_key

{agentica-0.2.2 → agentica-0.2.3}/README.md

@@ -18,14 +18,11 @@
 [![Wechat Group](https://img.shields.io/badge/wechat-group-green.svg?logo=wechat)](#Contact)
 
 
-**Agentica**: Build Smarter, Reflective, and Collaborative AI Agents with Ease!
+**Agentica**: 轻松构建智能、具备反思能力、可协作的多模态AI Agent。
 
-**Agentica**: 快速打造智能、能反思、协作的AI Agent。
 
 ## 📖 Introduction
 
-**Agentica** can build AI agent, which have the components of planning, memory, and tool use. 
-
 **Agentica** 可以构建AI Agent，包括规划、记忆和工具使用、执行等组件。
 
 #### Agent Components
@@ -48,6 +45,8 @@
 - **Solver**：求解器将所有这些输出整合为最终答案
 
 ## 🔥 News
+[2024/12/29] v0.2.3版本: 支持了`ZhipuAI`的api调用，包括免费模型和工具使用，详见[Release-v0.2.3](https://github.com/shibing624/agentica/releases/tag/0.2.3)
+
 [2024/12/25] v0.2.0版本: 支持了多模态模型，输入可以是文本、图片、音频、视频，升级Assistant为Agent，Workflow支持拆解并实现复杂任务，详见[Release-v0.2.0](https://github.com/shibing624/agentica/releases/tag/0.2.0)
 
 [2024/07/02] v0.1.0版本：实现了基于LLM的Assistant，可以快速用function call搭建大语言模型助手，详见[Release-v0.1.0](https://github.com/shibing624/agentica/releases/tag/0.1.0)
@@ -90,7 +89,7 @@ cd examples
 python web_search_moonshot_demo.py
 ```
 
-1. 复制[.env.example](https://github.com/shibing624/agentica/blob/main/.env.example)文件为`~/.agentica/.env`，并填写LLM api key(选填DEEPSEEK_API_KEY、MOONSHOT_API_KEY、OPENAI_API_KEY等任一个即可)。或者使用`export`命令设置环境变量：
+1. 复制[.env.example](https://github.com/shibing624/agentica/blob/main/.env.example)文件为`~/.agentica/.env`，并填写LLM api key(选填DEEPSEEK_API_KEY、MOONSHOT_API_KEY、OPENAI_API_KEY、ZHIPUAI_API_KEY等任一个即可)。或者使用`export`命令设置环境变量：
     
     ```shell
     export MOONSHOT_API_KEY=your_moonshot_api_key

{agentica-0.2.2 → agentica-0.2.3}/agentica/__init__.py

@@ -21,6 +21,7 @@ from agentica.model.doubao.chat import DoubaoChat
 from agentica.model.together.togetherchat import TogetherChat
 from agentica.model.xai.grok import GrokChat
 from agentica.model.yi.chat import YiChat
+from agentica.model.zhipuai.chat import ZhipuAIChat
 
 # memory
 from agentica.model.base import Model
@@ -72,6 +73,7 @@ from agentica.emb.hash_emb import HashEmb
 from agentica.emb.ollama_emb import OllamaEmb
 from agentica.emb.together_emb import TogetherEmb
 from agentica.emb.fireworks_emb import FireworksEmb
+from agentica.emb.zhipuai_emb import ZhipuAIEmb
 
 # file
 from agentica.file.base import File
@@ -94,7 +96,7 @@ from agentica.tools.search_serper_tool import SearchSerperTool
 from agentica.tools.run_python_code_tool import RunPythonCodeTool
 from agentica.tools.analyze_image_tool import AnalyzeImageTool
 from agentica.tools.calculator_tool import CalculatorTool
-from agentica.tools.create_image_tool import CreateImageTool
+from agentica.tools.dalle_tool import DalleTool
 from agentica.tools.file_tool import FileTool
 from agentica.tools.hackernews_tool import HackerNewsTool
 from agentica.tools.jina_tool import JinaTool

{agentica-0.2.2 → agentica-0.2.3}/agentica/agent.py

@@ -1998,7 +1998,8 @@ class Agent(BaseModel):
                         logger.warning(f"Failed to convert response to pydantic model: {exc}")
                         # Check if response starts with ```json
                         if run_response.content.startswith("```json"):
-                            run_response.content = run_response.content.replace("```json\n", "").replace("\n```", "")
+                            run_response.content = run_response.content.replace(
+                                "```json\n", "").replace("\n```", "")
                             try:
                                 structured_output = self.response_model.model_validate_json(run_response.content)
                             except ValidationError as exc:
@@ -2307,7 +2308,8 @@ class Agent(BaseModel):
                         logger.warning(f"Failed to convert response to pydantic model: {exc}")
                         # Check if response starts with ```json
                         if run_response.content.startswith("```json"):
-                            run_response.content = run_response.content.replace("```json\n", "").replace("\n```", "")
+                            run_response.content = run_response.content.replace(
+                                "```json\n", "").replace("\n```", "")
                             try:
                                 structured_output = self.response_model.model_validate_json(run_response.content)
                             except ValidationError as exc:

agentica-0.2.3/agentica/emb/zhipuai_emb.py

@@ -0,0 +1,15 @@
+"""
+@author:XuMing(xuming624@qq.com)
+@description:
+"""
+from os import getenv
+from typing import Optional
+
+from agentica.emb.openai_emb import OpenAIEmb
+
+
+class ZhipuAIEmb(OpenAIEmb):
+    model: str = "embedding-3"
+    dimensions: int = 2048
+    api_key: Optional[str] = getenv("ZHIPUAI_API_KEY")
+    base_url: str = "https://open.bigmodel.cn/api/paas/v4"

{agentica-0.2.2 → agentica-0.2.3}/agentica/model/doubao/chat.py

@@ -18,7 +18,7 @@ class DoubaoChat(OpenAILike):
 
     id: str = "ep-20241012172611-btlgr"
     name: str = "DoubaoChat"
-    provider: str = "Doubao"
+    provider: str = "ByteDance"
 
     api_key: Optional[str] = getenv("ARK_API_KEY", None)
     base_url: str = "https://ark.cn-beijing.volces.com/api/v3"

{agentica-0.2.2 → agentica-0.2.3}/agentica/model/message.py

@@ -85,7 +85,8 @@ class Message(BaseModel):
         @param level: The level to log the message at. One of debug, info, warning, or error.
             Defaults to debug.
         """
-        _logger = logger.debug
+        level = level or "debug"
+        level = level.lower()
         if level == "debug":
             _logger = logger.debug
         elif level == "info":
@@ -94,6 +95,8 @@ class Message(BaseModel):
             _logger = logger.warning
         elif level == "error":
             _logger = logger.error
+        else:
+            _logger = logger.debug
 
         _logger(f"============== {self.role} ==============")
         if self.name:
@@ -120,8 +123,6 @@ class Message(BaseModel):
                     _logger("Message contains raw audio data")
             else:
                 _logger(f"Audio file added: {self.audio}")
-        # if self.model_extra and "images" in self.model_extra:
-        #     _logger("images: {}".format(self.model_extra["images"]))
 
     def content_is_valid(self) -> bool:
         """Check if the message content is valid."""

agentica-0.2.3/agentica/model/zhipuai/__init__.py

@@ -0,0 +1 @@
+from agentica.model.zhipuai.chat import ZhipuAIChat

agentica-0.2.3/agentica/model/zhipuai/chat.py

@@ -0,0 +1,24 @@
+from typing import Optional
+from os import getenv
+
+from agentica.model.openai.like import OpenAILike
+
+
+class ZhipuAIChat(OpenAILike):
+    """
+    A model class for ZhipuAI Chat API.
+
+    Attributes:
+    - id: str: The unique identifier of the model, model_name.
+    - name: str: The name of the class.
+    - provider: str: The provider of the model.
+    - api_key: Optional[str]: The API key for the model.
+    - base_url: str: The base URL for the model.
+    """
+
+    id: str = "glm-4-flash"
+    name: str = "ZhipuAIChat"
+    provider: str = "ZhipuAI"
+
+    api_key: Optional[str] = getenv("ZHIPUAI_API_KEY", None)
+    base_url: str = "https://open.bigmodel.cn/api/paas/v4"

{agentica-0.2.2 → agentica-0.2.3}/agentica/python_agent.py

@@ -1,3 +1,8 @@
+# -*- coding: utf-8 -*-
+"""
+@author:XuMing(xuming624@qq.com)
+@description:
+"""
 from typing import Optional, List, Dict, Any
 from pathlib import Path
 import json

agentica-0.2.3/agentica/react_agent.py

@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+"""
+A minimal implementation of a ReACT agent with support for multiple tools.
+"""
+import re
+from loguru import logger
+from openai import OpenAI
+
+# Registry to hold available actions
+action_registry = {}
+
+
+def register_action(action_name):
+    """Decorator to register an action in the action registry."""
+
+    def decorator(func):
+        action_registry[action_name] = func
+        return func
+
+    return decorator
+
+
+def parse_response(response):
+    """Parse the model's response into thoughts and actions."""
+    thoughts = []
+    actions = []
+    lines = response.split('\n')
+    for line in lines:
+        if line.startswith("Thought:"):
+            thoughts.append(line[len("Thought:"):].strip())
+        elif line.startswith("Action:"):
+            actions.append(line[len("Action:"):].strip())
+    return thoughts, actions
+
+
+def parse_action(action_str):
+    """Parse an action string into action name and parameters."""
+    match = re.match(r'^(\w+)\((.*)\)$', action_str)
+    if match:
+        action_name = match.group(1)
+        params = match.group(2)
+        # Remove parameter names and keep only values
+        params = re.sub(r'\w+=', '', params)
+        logger.debug(f"Action name: {action_name}, Params: {params}")
+        return action_name, params
+    else:
+        logger.warning(f"Invalid action string: {action_str}")
+        return None, None
+
+
+TOOL_DESC = """{name_for_model}: Call this tool to interact with the {name_for_human} API. What is the {name_for_human} API useful for? {description_for_model} Parameters: {parameters}"""
+
+PROMPT_REACT = """You are an assistant that uses the ReACT framework to answer questions. 
+
+First, describe your thought process in the "Thought:" section, then describe the action you will take in the "Action:" section. 
+Each section should start with its respective label. 
+Adjust your thoughts and actions based on the results of previous actions until you arrive at the final answer. 
+Ensure that each action is described in the format "Action: action_name(parameters)".
+Available actions include: 
+
+{tools_text}
+
+Begin!
+"""
+
+
+class ReactAgent:
+    """A ReACT agent that interacts with the OpenAI API to perform actions based on user queries."""
+
+    def __init__(self, model_name="gpt-4o", tools=None):
+        self.model_name = model_name
+        self.tools = tools or []
+        self.action_registry = action_registry
+        self.client = OpenAI()
+        self.logger = logger
+        self.system_prompt = self._generate_system_prompt()
+
+    def _generate_system_prompt(self):
+        tools_text = "\n".join([TOOL_DESC.format(**tool) for tool in self.tools])
+        return PROMPT_REACT.format(tools_text=tools_text)
+
+    def get_model_response(self, messages):
+        """Get a response from the OpenAI model."""
+        response = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=messages
+        )
+        return response.choices[0].message.content
+
+    def run(self, user_query, max_iterations=5):
+        """Run the agent with the given user query."""
+        context = []
+        for _ in range(max_iterations):
+            messages = [
+                {"role": "system", "content": self.system_prompt.format(query=user_query)},
+                {"role": "user", "content": user_query},
+                *context
+            ]
+            self.logger.info(f"Messages: {messages}")
+            response = self.get_model_response(messages)
+            self.logger.info(f"Model response: {response}")
+            thoughts, actions = parse_response(response)
+            if not actions:
+                break
+            action_str = actions[0]
+            self.logger.info(f"Executing action: {action_str}")
+            action_result = self.execute_action(action_str)
+            if action_result.startswith("Action"):
+                action_result = action_result.split("Result: ")[-1]
+            self.logger.info(f"Action result: {action_result}")
+            context.append({
+                "role": "assistant",
+                "content": f"Thought: {thoughts}\nAction: {action_str}\nResult: {action_result}"
+            })
+        return response
+
+    def execute_action(self, action_str):
+        """Execute an action based on the action string."""
+        action_name, params = parse_action(action_str)
+        if action_name in self.action_registry:
+            try:
+                self.logger.debug(f"Executing action: {action_name} with params: {params}")
+                result = self.action_registry[action_name](params)
+                self.logger.debug(f"Action '{action_name}' executed successfully, Result: {result}")
+                return f"Action '{action_name}' executed successfully, Result: {result}"
+            except Exception as e:
+                self.logger.warning(f"Action '{action_name}' failed, Error: {str(e)}")
+                return f"Action '{action_name}' failed, Error: {str(e)}"
+        else:
+            return f"Unknown action '{action_name}'"
+
+
+if __name__ == '__main__':
+    @register_action("calculate")
+    def calculate(expression=""):
+        """Calculate the result of a mathematical expression."""
+        try:
+            result = eval(expression)
+            return result
+        except Exception as e:
+            return f"Error in calculation: {str(e)}"
+
+
+    @register_action("reverse_string")
+    def reverse_string(s=""):
+        """Reverse the input string."""
+        try:
+            logger.debug(f"Reversing string: {s}")
+            r = s[::-1]
+            logger.debug(f"Reversed string: {r}")
+            return r
+        except Exception as e:
+            return f"Error in reversing string: {str(e)}"
+
+
+    @register_action("text_length")
+    def text_length(s):
+        """Calculate the length of the input text string."""
+        try:
+            logger.debug(f"Calculating text length: {s}")
+            r = len(s)
+            logger.debug(f"Text length: {r}")
+            return r
+        except Exception as e:
+            return f"Error in calculating text length: {str(e)}"
+
+
+    tools = [
+        {
+            "name_for_model": "calculate",
+            "name_for_human": "Calculator",
+            "description_for_model": "useful for performing mathematical calculations.",
+            "parameters": "expression: a mathematical expression to evaluate."
+        },
+        {
+            "name_for_model": "reverse_string",
+            "name_for_human": "String Reverser",
+            "description_for_model": "useful for reversing strings.",
+            "parameters": "the string to reverse."
+        },
+        # get text string length
+        {
+            "name_for_model": "text_length",
+            "name_for_human": "Text Length Calculator",
+            "description_for_model": "useful for calculating the length of a text string.",
+            "parameters": "the text string to calculate the length."
+        }
+    ]
+
+    agent = ReactAgent(tools=tools)
+
+    # Run the agent with a query that requires both tools
+    response = agent.run(
+        "What is the result of reversing the string '123hello111---232323k23你好，水电费不着调。。。。--23' and then calculating the length of the reversed string, 不要包括引号")
+    logger.info(response)

agentica-0.2.3/agentica/tools/cogvideo_tool.py

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+"""
+@author:XuMing(xuming624@qq.com)
+@description:
+CogVideoX
+模型编码：cogvideox、cogvideox-flash
+
+CogVideoX 是由智谱AI开发的视频生成大模型，具备强大的视频生成能力，只需输入文本或图片就可以轻松完成视频制作。
+"""
+import hashlib
+import json
+import os
+from os import getenv
+import time
+import requests
+from typing import Optional
+
+try:
+    from zhipuai import ZhipuAI
+except ImportError:
+    raise ImportError("`zhipuai` not installed. Please install using `pip install zhipuai`.")
+
+from agentica.tools.base import Toolkit
+from agentica.utils.log import logger
+
+
+class CogVideoTool(Toolkit):
+    """
+    This class inherits from the Toolkit class.
+        It defines a function for creating an image from a description using ZhipuAI's API.
+    """
+
+    def __init__(
+            self,
+            api_key: Optional[str] = None,
+            data_dir: Optional[str] = None,
+
+    ):
+        super().__init__(name="create_video_from_cogvideo_tool")
+        self.api_key = api_key or getenv("ZHIPUAI_API_KEY")
+        if not self.api_key:
+            logger.error("ZHIPUAI_API_KEY not set. Please set the ZHIPUAI_API_KEY environment variable.")
+        self.client = ZhipuAI(api_key=self.api_key)
+        self.data_dir: str = data_dir or "outputs"
+        self.register(self.create_video)
+
+    def _generate_name(self, prompt: Optional[str] = None) -> str:
+        """
+        Generates a unique name based on the prompt and the current time.
+
+        :param prompt: The prompt that describes the video.
+        :type prompt: str
+        :return: The name of the video file.
+        :rtype: str
+        """
+        timestamp = str(time.time())
+        prompt = prompt if prompt else ""
+        file_name = str(hashlib.sha256((prompt + timestamp).encode()).hexdigest())[:16]
+        return file_name + ".mp4"
+
+    def create_video(
+            self,
+            prompt: Optional[str] = None,
+            image_url: Optional[str] = None,
+            model: str = "cogvideox-flash",
+            with_audio: bool = False,
+            size: Optional[str] = None,
+            duration: int = 5,
+            fps: int = 30
+    ) -> str:
+        """Creates a video from a description or image using ZhipuAI API, generates a unique video name based on the prompt or image URL,
+        and saves it to a specified output path.
+
+        Args:
+            prompt (str, optional): The prompt that describes the video.
+            image_url (str, optional): The URL of the image to base the video on.
+            model (str, optional): The model to use for video generation. Defaults to 'cogvideox'.
+            with_audio (bool, optional): Whether to generate AI audio. Defaults to False.
+            size (str, optional): The size of the video. Defaults to '1920x1080'.
+            duration (int, optional): The duration of the video in seconds. Defaults to 5.
+            fps (int, optional): The frame rate of the video. Defaults to 30.
+
+        Example:
+            from agentica.tools.cogvideo_tool import CogVideoTool
+            tool = CogVideoTool()
+            image_path = tool.create_video("A painting of a beautiful sunset over the ocean.")
+            print(image_path)
+
+        Returns:
+            str: The json result for the video generation.
+        """
+        params = {"model": model}
+        if prompt:
+            params["prompt"] = prompt
+        if image_url:
+            params["image_url"] = image_url
+            if size:
+                params["size"] = size
+            if with_audio:
+                params["with_audio"] = with_audio
+            if duration:
+                params["duration"] = duration
+            if fps:
+                params["fps"] = fps
+        logger.info(f"params: {params}")
+        response = self.client.videos.generations(**params)
+        # 异步接口，轮询获取视频生成结果
+        video_id = response.id
+        while True:
+            result = self.client.videos.retrieve_videos_result(id=video_id)
+            if result.task_status == "SUCCESS":
+                logger.info("Video generation succeeded. URL:", result)
+                break
+            elif result.task_status == "FAIL":
+                logger.debug("Video generation failed.")
+                break
+            elif result.task_status == "PROCESSING":
+                logger.debug("Video generation in progress. Checking again in 10 seconds...")
+                time.sleep(10)
+        video_url = result.video_result[0].url
+        cover_image_url = result.video_result[0].cover_image_url
+        video_path = f"{self.data_dir}/{self._generate_name(prompt)}"
+        self._download_and_save_video(video_url, video_path)
+        saved_video_path = os.path.abspath(video_path)
+        result = {"action": "create_video", "result_video_url": video_url, "result_video_path": saved_video_path,
+                  "cover_image_url": cover_image_url}
+        return json.dumps(result, ensure_ascii=False)
+
+    def _download_and_save_video(self, video_url: str, saved_video_path: str) -> None:
+        """
+        Downloads the video from the given URL and saves it to the specified path.
+
+        :param video_url: The URL of the video.
+        :type video_url: str
+        :param saved_video_path: The path to save the video.
+        :type saved_video_path: str
+        """
+        try:
+            video_data = requests.get(video_url).content
+            os.makedirs(os.path.dirname(saved_video_path), exist_ok=True)
+            with open(saved_video_path, "wb") as f:
+                f.write(video_data)
+            logger.info(f"Video saved to: {saved_video_path}")
+        except Exception as e:
+            logger.error(f"Error downloading video: {str(e)}")
+
+
+if __name__ == '__main__':
+    # from agentica.tools.cogview_tool import CogViewTool
+    m = CogVideoTool()
+    prompt = "比得兔开小汽车，游走在马路上，脸上的表情充满开心喜悦"
+    r = m.create_video(prompt)
+    print(r)