-
-描述
- 我们是一家AI软件创业公司。通过投资我们，您将赋能一个充满无限可能的未来。
-
-位置参数
- IDEA
- 类型: str
- 您的创新想法，例如"写一个命令行贪吃蛇。"
-
-标志
- --investment=INVESTMENT
- 类型: float
- 默认值: 3.0
- 作为投资者，您有机会向这家AI公司投入一定的美元金额。
- --n_round=N_ROUND
- 类型: int
- 默认值: 5
-
-备注
- 您也可以用`标志`的语法，来处理`位置参数`
-```
-
-### 代码实现
-
-```python
-from metagpt.software_company import SoftwareCompany
-from metagpt.roles import ProjectManager, ProductManager, Architect, Engineer
-
-async def startup(idea: str, investment: float = 3.0, n_round: int = 5):
- """运行一个创业公司。做一个老板"""
- company = SoftwareCompany()
- company.hire([ProductManager(), Architect(), ProjectManager(), Engineer()])
- company.invest(investment)
- company.start_project(idea)
- await company.run(n_round=n_round)
-```
-
-你可以查看`examples`，其中有单角色（带知识库）的使用例子与仅LLM的使用例子。
-
-## 快速体验
-对一些用户来说，安装配置本地环境是有困难的，下面这些教程能够让你快速体验到MetaGPT的魅力。
-
-- [MetaGPT快速体验](https://deepwisdom.feishu.cn/wiki/Q8ycw6J9tiNXdHk66MRcIN8Pnlg)
-
-可直接在Huggingface Space体验
-
-- https://huggingface.co/spaces/deepwisdom/MetaGPT
-
-## 联系信息
+### 联系信息
如果您对这个项目有任何问题或反馈，欢迎联系我们。我们非常欢迎您的建议！
@@ -222,13 +119,17 @@ ## 联系信息
我们会在2-3个工作日内回复所有问题。
-## 演示
+## 引用
-https://github.com/geekan/MetaGPT/assets/2707039/5e8c1062-8c35-440f-bb20-2b0320f8d27d
+引用 [arXiv paper](https://arxiv.org/abs/2308.00352):
-## 加入我们
-
-📢 加入我们的Discord频道！
-https://discord.gg/ZRHeExS6xv
-
-期待在那里与您相见！🎉
+```bibtex
+@misc{hong2023metagpt,
+ title={MetaGPT: Meta Programming for Multi-Agent Collaborative Framework},
+ author={Sirui Hong and Xiawu Zheng and Jonathan Chen and Yuheng Cheng and Jinlin Wang and Ceyao Zhang and Zili Wang and Steven Ka Shing Yau and Zijuan Lin and Liyang Zhou and Chenyu Ran and Lingfeng Xiao and Chenglin Wu},
+ year={2023},
+ eprint={2308.00352},
+ archivePrefix={arXiv},
+ primaryClass={cs.AI}
+}
+```
diff --git a/docs/README_JA.md b/docs/README_JA.md
index 2b2c35a62..411d190b4 100644
--- a/docs/README_JA.md
+++ b/docs/README_JA.md
@@ -19,7 +19,6 @@ # MetaGPT: マルチエージェントフレームワーク
- 
@@ -60,17 +59,22 @@ ### インストールビデオガイド
### 伝統的なインストール
```bash
-# ステップ 1: NPM がシステムにインストールされていることを確認してください。次に mermaid-js をインストールします。(お使いのコンピューターに npm がない場合は、Node.js 公式サイトで Node.js https://nodejs.org/ をインストールしてください。）
-npm --version
-sudo npm install -g @mermaid-js/mermaid-cli
-
-# ステップ 2: Python 3.9+ がシステムにインストールされていることを確認してください。これを確認するには:
+# ステップ 1: Python 3.9+ がシステムにインストールされていることを確認してください。これを確認するには:
python --version
-# ステップ 3: リポジトリをローカルマシンにクローンし、インストールする。
-git clone https://github.com/geekan/metagpt
-cd metagpt
+# ステップ 2: リポジトリをローカルマシンにクローンし、インストールする。
+git clone https://github.com/geekan/MetaGPT.git
+cd MetaGPT
pip install -e.
+
+# ステップ 3: startup.py を実行する
+# config.yaml を key.yaml にコピーし、独自の OPENAI_API_KEY を設定します
+python3 startup.py "Write a cli snake game"
+
+# ステップ 4 [オプション]: 実行中に PRD ファイルなどのアーティファクトを保存する場合は、ステップ 3 の前にこのステップを実行できます。デフォルトでは、フレームワークには互換性があり、この手順を実行しなくてもプロセス全体を完了できます。
+# NPM がシステムにインストールされていることを確認してください。次に mermaid-js をインストールします。(お使いのコンピューターに npm がない場合は、Node.js 公式サイトで Node.js https://nodejs.org/ をインストールしてください。）
+npm --version
+sudo npm install -g @mermaid-js/mermaid-cli
```
**注:**
@@ -159,6 +163,7 @@ # ステップ 3: リポジトリをローカルマシンにクローンし、
注: この方法は pdf エクスポートに対応していません。
### Docker によるインストール
+> Windowsでは、"/opt/metagpt"をDockerが作成する権限を持つディレクトリに置き換える必要があります。例えば、"D:\Users\x\metagpt"などです。
```bash
# ステップ 1: metagpt 公式イメージをダウンロードし、config.yaml を準備する
@@ -270,12 +275,12 @@ ### 使用方法
### コードウォークスルー
```python
-from metagpt.software_company import SoftwareCompany
+from metagpt.team import Team
from metagpt.roles import ProjectManager, ProductManager, Architect, Engineer
async def startup(idea: str, investment: float = 3.0, n_round: int = 5):
"""スタートアップを実行する。ボスになる。"""
- company = SoftwareCompany()
+ company = Team()
company.hire([ProductManager(), Architect(), ProjectManager(), Engineer()])
company.invest(investment)
company.start_project(idea)
@@ -295,12 +300,12 @@ ## クイックスタート
## 引用
-現時点では、[Arxiv 論文](https://arxiv.org/abs/2308.00352)を引用してください:
+現時点では、[arXiv 論文](https://arxiv.org/abs/2308.00352)を引用してください:
```bibtex
@misc{hong2023metagpt,
- title={MetaGPT: Meta Programming for Multi-Agent Collaborative Framework},
- author={Sirui Hong and Xiawu Zheng and Jonathan Chen and Yuheng Cheng and Jinlin Wang and Ceyao Zhang and Zili Wang and Steven Ka Shing Yau and Zijuan Lin and Liyang Zhou and Chenyu Ran and Lingfeng Xiao and Chenglin Wu},
+ title={MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework},
+ author={Sirui Hong and Mingchen Zhuge and Jonathan Chen and Xiawu Zheng and Yuheng Cheng and Ceyao Zhang and Jinlin Wang and Zili Wang and Steven Ka Shing Yau and Zijuan Lin and Liyang Zhou and Chenyu Ran and Lingfeng Xiao and Chenglin Wu and Jürgen Schmidhuber},
year={2023},
eprint={2308.00352},
archivePrefix={arXiv},
diff --git a/docs/install/cli_install.md b/docs/install/cli_install.md
new file mode 100644
index 000000000..80deda771
--- /dev/null
+++ b/docs/install/cli_install.md
@@ -0,0 +1,109 @@
+## Traditional Command Line Installation
+
+### Support System and version
+| System Version | Python Version | Supported |
+| ---- | ---- | ----- |
+| macOS 13.x | python 3.9 | Yes |
+| Windows 11 | python 3.9 | Yes |
+| Ubuntu 22.04 | python 3.9 | Yes |
+
+### Detail Installation
+```bash
+# Step 1: Ensure that NPM is installed on your system. Then install mermaid-js. (If you don't have npm in your computer, please go to the Node.js official website to install Node.js https://nodejs.org/ and then you will have npm tool in your computer.)
+npm --version
+sudo npm install -g @mermaid-js/mermaid-cli
+
+# Step 2: Ensure that Python 3.9+ is installed on your system. You can check this by using:
+python3 --version
+
+# Step 3: Clone the repository to your local machine, and install it.
+git clone https://github.com/geekan/MetaGPT.git
+cd MetaGPT
+pip install -e.
+```
+
+**Note:**
+
+- If already have Chrome, Chromium, or MS Edge installed, you can skip downloading Chromium by setting the environment variable
+ `PUPPETEER_SKIP_CHROMIUM_DOWNLOAD` to `true`.
+
+- Some people are [having issues](https://github.com/mermaidjs/mermaid.cli/issues/15) installing this tool globally. Installing it locally is an alternative solution,
+
+ ```bash
+ npm install @mermaid-js/mermaid-cli
+ ```
+
+- don't forget to the configuration for mmdc in config.yml
+
+ ```yml
+ PUPPETEER_CONFIG: "./config/puppeteer-config.json"
+ MMDC: "./node_modules/.bin/mmdc"
+ ```
+
+- if `pip install -e.` fails with error `[Errno 13] Permission denied: '/usr/local/lib/python3.11/dist-packages/test-easy-install-13129.write-test'`, try instead running `pip install -e. --user`
+
+- To convert Mermaid charts to SVG, PNG, and PDF formats. In addition to the Node.js version of Mermaid-CLI, you now have the option to use Python version Playwright, pyppeteer or mermaid.ink for this task.
+
+ - Playwright
+ - **Install Playwright**
+
+ ```bash
+ pip install playwright
+ ```
+
+ - **Install the Required Browsers**
+
+ to support PDF conversion, please install Chrominum.
+
+ ```bash
+ playwright install --with-deps chromium
+ ```
+
+ - **modify `config.yaml`**
+
+ uncomment MERMAID_ENGINE from config.yaml and change it to `playwright`
+
+ ```yaml
+ MERMAID_ENGINE: playwright
+ ```
+
+ - pyppeteer
+ - **Install pyppeteer**
+
+ ```bash
+ pip install pyppeteer
+ ```
+
+ - **Use your own Browsers**
+
+ pyppeteer allows you use installed browsers, please set the following envirment
+
+ ```bash
+ export PUPPETEER_EXECUTABLE_PATH = /path/to/your/chromium or edge or chrome
+ ```
+
+ please do not use this command to install browser, it is too old
+
+ ```bash
+ pyppeteer-install
+ ```
+
+ - **modify `config.yaml`**
+
+ uncomment MERMAID_ENGINE from config.yaml and change it to `pyppeteer`
+
+ ```yaml
+ MERMAID_ENGINE: pyppeteer
+ ```
+
+ - mermaid.ink
+ - **modify `config.yaml`**
+
+ uncomment MERMAID_ENGINE from config.yaml and change it to `ink`
+
+ ```yaml
+ MERMAID_ENGINE: ink
+ ```
+
+ Note: this method does not support pdf export.
+
\ No newline at end of file
diff --git a/docs/install/cli_install_cn.md b/docs/install/cli_install_cn.md
new file mode 100644
index 000000000..f351090ed
--- /dev/null
+++ b/docs/install/cli_install_cn.md
@@ -0,0 +1,43 @@
+## 命令行安装
+
+### 支持的系统和版本
+| 系统版本 | Python 版本 | 是否支持 |
+| ---- | ---- | ----- |
+| macOS 13.x | python 3.9 | 是 |
+| Windows 11 | python 3.9 | 是 |
+| Ubuntu 22.04 | python 3.9 | 是 |
+
+### 详细安装
+
+```bash
+# 第 1 步：确保您的系统上安装了 NPM。并使用npm安装mermaid-js
+npm --version
+sudo npm install -g @mermaid-js/mermaid-cli
+
+# 第 2 步：确保您的系统上安装了 Python 3.9+。您可以使用以下命令进行检查：
+python --version
+
+# 第 3 步：克隆仓库到您的本地机器，并进行安装。
+git clone https://github.com/geekan/MetaGPT.git
+cd MetaGPT
+pip install -e.
+```
+
+**注意：**
+
+- 如果已经安装了Chrome、Chromium或MS Edge，可以通过将环境变量`PUPPETEER_SKIP_CHROMIUM_DOWNLOAD`设置为`true`来跳过下载Chromium。
+
+- 一些人在全局安装此工具时遇到问题。在本地安装是替代解决方案，
+
+ ```bash
+ npm install @mermaid-js/mermaid-cli
+ ```
+
+- 不要忘记在config.yml中为mmdc配置配置，
+
+ ```yml
+ PUPPETEER_CONFIG: "./config/puppeteer-config.json"
+ MMDC: "./node_modules/.bin/mmdc"
+ ```
+
+- 如果`pip install -e.`失败并显示错误`[Errno 13] Permission denied: '/usr/local/lib/python3.11/dist-packages/test-easy-install-13129.write-test'`，请尝试使用`pip install -e. --user`运行。
diff --git a/docs/install/docker_install.md b/docs/install/docker_install.md
new file mode 100644
index 000000000..b803a5dae
--- /dev/null
+++ b/docs/install/docker_install.md
@@ -0,0 +1,44 @@
+## Docker Installation
+
+### Use default MetaGPT image
+
+```bash
+# Step 1: Download metagpt official image and prepare config.yaml
+docker pull metagpt/metagpt:latest
+mkdir -p /opt/metagpt/{config,workspace}
+docker run --rm metagpt/metagpt:latest cat /app/metagpt/config/config.yaml > /opt/metagpt/config/key.yaml
+vim /opt/metagpt/config/key.yaml # Change the config
+
+# Step 2: Run metagpt demo with container
+docker run --rm \
+ --privileged \
+ -v /opt/metagpt/config/key.yaml:/app/metagpt/config/key.yaml \
+ -v /opt/metagpt/workspace:/app/metagpt/workspace \
+ metagpt/metagpt:latest \
+ python3 startup.py "Write a cli snake game"
+
+# You can also start a container and execute commands in it
+docker run --name metagpt -d \
+ --privileged \
+ -v /opt/metagpt/config/key.yaml:/app/metagpt/config/key.yaml \
+ -v /opt/metagpt/workspace:/app/metagpt/workspace \
+ metagpt/metagpt:latest
+
+docker exec -it metagpt /bin/bash
+$ python3 startup.py "Write a cli snake game"
+```
+
+The command `docker run ...` do the following things:
+
+- Run in privileged mode to have permission to run the browser
+- Map host configure file `/opt/metagpt/config/key.yaml` to container `/app/metagpt/config/key.yaml`
+- Map host directory `/opt/metagpt/workspace` to container `/app/metagpt/workspace`
+- Execute the demo command `python3 startup.py "Write a cli snake game"`
+
+### Build image by yourself
+
+```bash
+# You can also build metagpt image by yourself.
+git clone https://github.com/geekan/MetaGPT.git
+cd MetaGPT && docker build -t metagpt:custom .
+```
diff --git a/docs/install/docker_install_cn.md b/docs/install/docker_install_cn.md
new file mode 100644
index 000000000..347fae10c
--- /dev/null
+++ b/docs/install/docker_install_cn.md
@@ -0,0 +1,44 @@
+## Docker安装
+
+### 使用MetaGPT镜像
+
+```bash
+# 步骤1: 下载metagpt官方镜像并准备好config.yaml
+docker pull metagpt/metagpt:latest
+mkdir -p /opt/metagpt/{config,workspace}
+docker run --rm metagpt/metagpt:latest cat /app/metagpt/config/config.yaml > /opt/metagpt/config/key.yaml
+vim /opt/metagpt/config/key.yaml # 修改配置文件
+
+# 步骤2: 使用容器运行metagpt演示
+docker run --rm \
+ --privileged \
+ -v /opt/metagpt/config/key.yaml:/app/metagpt/config/key.yaml \
+ -v /opt/metagpt/workspace:/app/metagpt/workspace \
+ metagpt/metagpt:latest \
+ python startup.py "Write a cli snake game"
+
+# 您也可以启动一个容器并在其中执行命令
+docker run --name metagpt -d \
+ --privileged \
+ -v /opt/metagpt/config/key.yaml:/app/metagpt/config/key.yaml \
+ -v /opt/metagpt/workspace:/app/metagpt/workspace \
+ metagpt/metagpt:latest
+
+docker exec -it metagpt /bin/bash
+$ python startup.py "Write a cli snake game"
+```
+
+`docker run ...`做了以下事情:
+
+- 以特权模式运行，有权限运行浏览器
+- 将主机文件 `/opt/metagpt/config/key.yaml` 映射到容器文件 `/app/metagpt/config/key.yaml`
+- 将主机目录 `/opt/metagpt/workspace` 映射到容器目录 `/app/metagpt/workspace`
+- 执行示例命令 `python startup.py "Write a cli snake game"`
+
+### 自己构建镜像
+
+```bash
+# 您也可以自己构建metagpt镜像
+git clone https://github.com/geekan/MetaGPT.git
+cd MetaGPT && docker build -t metagpt:custom .
+```
diff --git a/docs/tutorial/usage.md b/docs/tutorial/usage.md
new file mode 100644
index 000000000..ee87b65c9
--- /dev/null
+++ b/docs/tutorial/usage.md
@@ -0,0 +1,67 @@
+## MetaGPT Usage
+
+### Configuration
+
+- Configure your `OPENAI_API_KEY` in any of `config/key.yaml / config/config.yaml / env`
+- Priority order: `config/key.yaml > config/config.yaml > env`
+
+```bash
+# Copy the configuration file and make the necessary modifications.
+cp config/config.yaml config/key.yaml
+```
+
+| Variable Name | config/key.yaml | env |
+| ------------------------------------------ | ----------------------------------------- | ----------------------------------------------- |
+| OPENAI_API_KEY # Replace with your own key | OPENAI_API_KEY: "sk-..." | export OPENAI_API_KEY="sk-..." |
+| OPENAI_API_BASE # Optional | OPENAI_API_BASE: "https:///v1" | export OPENAI_API_BASE="https:///v1" |
+
+### Initiating a startup
+
+```shell
+# Run the script
+python startup.py "Write a cli snake game"
+# Do not hire an engineer to implement the project
+python startup.py "Write a cli snake game" --implement False
+# Hire an engineer and perform code reviews
+python startup.py "Write a cli snake game" --code_review True
+```
+
+After running the script, you can find your new project in the `workspace/` directory.
+
+### Preference of Platform or Tool
+
+You can tell which platform or tool you want to use when stating your requirements.
+
+```shell
+python startup.py "Write a cli snake game based on pygame"
+```
+
+### Usage
+
+```
+NAME
+ startup.py - We are a software startup comprised of AI. By investing in us, you are empowering a future filled with limitless possibilities.
+
+SYNOPSIS
+ startup.py IDEA
+
+DESCRIPTION
+ We are a software startup comprised of AI. By investing in us, you are empowering a future filled with limitless possibilities.
+
+POSITIONAL ARGUMENTS
+ IDEA
+ Type: str
+ Your innovative idea, such as "Creating a snake game."
+
+FLAGS
+ --investment=INVESTMENT
+ Type: float
+ Default: 3.0
+ As an investor, you have the opportunity to contribute a certain dollar amount to this AI company.
+ --n_round=N_ROUND
+ Type: int
+ Default: 5
+
+NOTES
+ You can also use flags syntax for POSITIONAL ARGUMENTS
+```
\ No newline at end of file
diff --git a/docs/tutorial/usage_cn.md b/docs/tutorial/usage_cn.md
new file mode 100644
index 000000000..4b3bdd2c3
--- /dev/null
+++ b/docs/tutorial/usage_cn.md
@@ -0,0 +1,63 @@
+## MetaGPT 使用
+
+### 配置
+
+- 在 `config/key.yaml / config/config.yaml / env` 中配置您的 `OPENAI_API_KEY`
+- 优先级顺序：`config/key.yaml > config/config.yaml > env`
+
+```bash
+# 复制配置文件并进行必要的修改
+cp config/config.yaml config/key.yaml
+```
+
+| 变量名 | config/key.yaml | env |
+| ----------------------------------- | ----------------------------------------- | ----------------------------------------------- |
+| OPENAI_API_KEY # 用您自己的密钥替换 | OPENAI_API_KEY: "sk-..." | export OPENAI_API_KEY="sk-..." |
+| OPENAI_API_BASE # 可选 | OPENAI_API_BASE: "https:///v1" | export OPENAI_API_BASE="https:///v1" |
+
+### 示例：启动一个创业公司
+
+```shell
+python startup.py "写一个命令行贪吃蛇"
+# 开启code review模式会花费更多的金钱, 但是会提升代码质量和成功率
+python startup.py "写一个命令行贪吃蛇" --code_review True
+```
+
+运行脚本后，您可以在 `workspace/` 目录中找到您的新项目。
+
+### 平台或工具的倾向性
+可以在阐述需求时说明想要使用的平台或工具。
+例如：
+```shell
+python startup.py "写一个基于pygame的命令行贪吃蛇"
+```
+
+### 使用
+
+```
+名称
+ startup.py - 我们是一家AI软件创业公司。通过投资我们，您将赋能一个充满无限可能的未来。
+
+概要
+ startup.py IDEA
+
+描述
+ 我们是一家AI软件创业公司。通过投资我们，您将赋能一个充满无限可能的未来。
+
+位置参数
+ IDEA
+ 类型: str
+ 您的创新想法，例如"写一个命令行贪吃蛇。"
+
+标志
+ --investment=INVESTMENT
+ 类型: float
+ 默认值: 3.0
+ 作为投资者，您有机会向这家AI公司投入一定的美元金额。
+ --n_round=N_ROUND
+ 类型: int
+ 默认值: 5
+
+备注
+ 您也可以用`标志`的语法，来处理`位置参数`
+```
diff --git a/examples/build_customized_agent.py b/examples/build_customized_agent.py
index 87d7a9c76..be34e5e5e 100644
--- a/examples/build_customized_agent.py
+++ b/examples/build_customized_agent.py
@@ -9,6 +9,7 @@ import asyncio
import fire
+from metagpt.llm import LLM
from metagpt.actions import Action
from metagpt.roles import Role
from metagpt.schema import Message
@@ -19,19 +20,10 @@ class SimpleWriteCode(Action):
PROMPT_TEMPLATE = """
Write a python function that can {instruction} and provide two runnnable test cases.
Return ```python your_code_here ``` with NO other texts,
- example:
- ```python
- # function
- def add(a, b):
- return a + b
- # test cases
- print(add(1, 2))
- print(add(3, 4))
- ```
your code:
"""
- def __init__(self, name="SimpleWriteCode", context=None, llm=None):
+ def __init__(self, name: str = "SimpleWriteCode", context=None, llm: LLM = None):
super().__init__(name, context, llm)
async def run(self, instruction: str):
@@ -51,8 +43,9 @@ class SimpleWriteCode(Action):
code_text = match.group(1) if match else rsp
return code_text
+
class SimpleRunCode(Action):
- def __init__(self, name="SimpleRunCode", context=None, llm=None):
+ def __init__(self, name: str = "SimpleRunCode", context=None, llm: LLM = None):
super().__init__(name, context, llm)
async def run(self, code_text: str):
@@ -61,6 +54,7 @@ class SimpleRunCode(Action):
logger.info(f"{code_result=}")
return code_result
+
class SimpleCoder(Role):
def __init__(
self,
@@ -73,16 +67,16 @@ class SimpleCoder(Role):
async def _act(self) -> Message:
logger.info(f"{self._setting}: ready to {self._rc.todo}")
- todo = self._rc.todo
+ todo = self._rc.todo # todo will be SimpleWriteCode()
- msg = self._rc.memory.get()[-1] # retrieve the latest memory
- instruction = msg.content
+ msg = self.get_memories(k=1)[0] # find the most recent messages
- code_text = await SimpleWriteCode().run(instruction)
- msg = Message(content=code_text, role=self.profile, cause_by=todo)
+ code_text = await todo.run(msg.content)
+ msg = Message(content=code_text, role=self.profile, cause_by=type(todo))
return msg
+
class RunnableCoder(Role):
def __init__(
self,
@@ -92,43 +86,23 @@ class RunnableCoder(Role):
):
super().__init__(name, profile, **kwargs)
self._init_actions([SimpleWriteCode, SimpleRunCode])
-
- async def _think(self) -> None:
- if self._rc.todo is None:
- self._set_state(0)
- return
-
- if self._rc.state + 1 < len(self._states):
- self._set_state(self._rc.state + 1)
- else:
- self._rc.todo = None
+ self._set_react_mode(react_mode="by_order")
async def _act(self) -> Message:
logger.info(f"{self._setting}: ready to {self._rc.todo}")
+ # By choosing the Action by order under the hood
+ # todo will be first SimpleWriteCode() then SimpleRunCode()
todo = self._rc.todo
- msg = self._rc.memory.get()[-1]
- if isinstance(todo, SimpleWriteCode):
- instruction = msg.content
- result = await SimpleWriteCode().run(instruction)
+ msg = self.get_memories(k=1)[0] # find the most k recent messages
+ result = await todo.run(msg.content)
- elif isinstance(todo, SimpleRunCode):
- code_text = msg.content
- result = await SimpleRunCode().run(code_text)
-
- msg = Message(content=result, role=self.profile, cause_by=todo)
+ msg = Message(content=result, role=self.profile, cause_by=type(todo))
self._rc.memory.add(msg)
return msg
- async def _react(self) -> Message:
- while True:
- await self._think()
- if self._rc.todo is None:
- break
- await self._act()
- return Message(content="All job done", role=self.profile)
-def main(msg="write a function that calculates the sum of a list"):
+def main(msg="write a function that calculates the product of a list and run it"):
# role = SimpleCoder()
role = RunnableCoder()
logger.info(msg)
diff --git a/examples/build_customized_multi_agents.py b/examples/build_customized_multi_agents.py
new file mode 100644
index 000000000..0df927e32
--- /dev/null
+++ b/examples/build_customized_multi_agents.py
@@ -0,0 +1,158 @@
+'''
+Filename: MetaGPT/examples/build_customized_multi_agents.py
+Created Date: Wednesday, November 15th 2023, 7:12:39 pm
+Author: garylin2099
+'''
+import re
+import asyncio
+import fire
+
+from metagpt.llm import LLM
+from metagpt.actions import Action, BossRequirement
+from metagpt.roles import Role
+from metagpt.team import Team
+from metagpt.schema import Message
+from metagpt.logs import logger
+
+def parse_code(rsp):
+ pattern = r'```python(.*)```'
+ match = re.search(pattern, rsp, re.DOTALL)
+ code_text = match.group(1) if match else rsp
+ return code_text
+
+class SimpleWriteCode(Action):
+
+ PROMPT_TEMPLATE = """
+ Write a python function that can {instruction}.
+ Return ```python your_code_here ``` with NO other texts,
+ your code:
+ """
+
+ def __init__(self, name: str = "SimpleWriteCode", context=None, llm: LLM = None):
+ super().__init__(name, context, llm)
+
+ async def run(self, instruction: str):
+
+ prompt = self.PROMPT_TEMPLATE.format(instruction=instruction)
+
+ rsp = await self._aask(prompt)
+
+ code_text = parse_code(rsp)
+
+ return code_text
+
+
+class SimpleCoder(Role):
+ def __init__(
+ self,
+ name: str = "Alice",
+ profile: str = "SimpleCoder",
+ **kwargs,
+ ):
+ super().__init__(name, profile, **kwargs)
+ self._watch([BossRequirement])
+ self._init_actions([SimpleWriteCode])
+
+
+class SimpleWriteTest(Action):
+
+ PROMPT_TEMPLATE = """
+ Context: {context}
+ Write {k} unit tests using pytest for the given function, assuming you have imported it.
+ Return ```python your_code_here ``` with NO other texts,
+ your code:
+ """
+
+ def __init__(self, name: str = "SimpleWriteTest", context=None, llm: LLM = None):
+ super().__init__(name, context, llm)
+
+ async def run(self, context: str, k: int = 3):
+
+ prompt = self.PROMPT_TEMPLATE.format(context=context, k=k)
+
+ rsp = await self._aask(prompt)
+
+ code_text = parse_code(rsp)
+
+ return code_text
+
+
+class SimpleTester(Role):
+ def __init__(
+ self,
+ name: str = "Bob",
+ profile: str = "SimpleTester",
+ **kwargs,
+ ):
+ super().__init__(name, profile, **kwargs)
+ self._init_actions([SimpleWriteTest])
+ # self._watch([SimpleWriteCode])
+ self._watch([SimpleWriteCode, SimpleWriteReview]) # feel free to try this too
+
+ async def _act(self) -> Message:
+ logger.info(f"{self._setting}: ready to {self._rc.todo}")
+ todo = self._rc.todo
+
+ # context = self.get_memories(k=1)[0].content # use the most recent memory as context
+ context = self.get_memories() # use all memories as context
+
+ code_text = await todo.run(context, k=5) # specify arguments
+ msg = Message(content=code_text, role=self.profile, cause_by=type(todo))
+
+ return msg
+
+
+class SimpleWriteReview(Action):
+
+ PROMPT_TEMPLATE = """
+ Context: {context}
+ Review the test cases and provide one critical comments:
+ """
+
+ def __init__(self, name: str = "SimpleWriteReview", context=None, llm: LLM = None):
+ super().__init__(name, context, llm)
+
+ async def run(self, context: str):
+
+ prompt = self.PROMPT_TEMPLATE.format(context=context)
+
+ rsp = await self._aask(prompt)
+
+ return rsp
+
+
+class SimpleReviewer(Role):
+ def __init__(
+ self,
+ name: str = "Charlie",
+ profile: str = "SimpleReviewer",
+ **kwargs,
+ ):
+ super().__init__(name, profile, **kwargs)
+ self._init_actions([SimpleWriteReview])
+ self._watch([SimpleWriteTest])
+
+
+async def main(
+ idea: str = "write a function that calculates the product of a list",
+ investment: float = 3.0,
+ n_round: int = 5,
+ add_human: bool = False,
+):
+ logger.info(idea)
+
+ team = Team()
+ team.hire(
+ [
+ SimpleCoder(),
+ SimpleTester(),
+ SimpleReviewer(is_human=add_human),
+ ]
+ )
+
+ team.invest(investment=investment)
+ team.start_project(idea)
+ await team.run(n_round=n_round)
+
+if __name__ == '__main__':
+ fire.Fire(main)
diff --git a/examples/debate.py b/examples/debate.py
index 05db28070..a37e60848 100644
--- a/examples/debate.py
+++ b/examples/debate.py
@@ -7,14 +7,14 @@ import asyncio
import platform
import fire
-from metagpt.software_company import SoftwareCompany
+from metagpt.team import Team
from metagpt.actions import Action, BossRequirement
from metagpt.roles import Role
from metagpt.schema import Message
from metagpt.logs import logger
-class ShoutOut(Action):
- """Action: Shout out loudly in a debate (quarrel)"""
+class SpeakAloud(Action):
+ """Action: Speak out aloud in a debate (quarrel)"""
PROMPT_TEMPLATE = """
## BACKGROUND
@@ -27,7 +27,7 @@ class ShoutOut(Action):
craft a strong and emotional response in 80 words, in {name}'s rhetoric and viewpoints, your will argue:
"""
- def __init__(self, name="ShoutOut", context=None, llm=None):
+ def __init__(self, name="SpeakAloud", context=None, llm=None):
super().__init__(name, context, llm)
async def run(self, context: str, name: str, opponent_name: str):
@@ -39,96 +39,57 @@ class ShoutOut(Action):
return rsp
-class Trump(Role):
+class Debator(Role):
def __init__(
self,
- name: str = "Trump",
- profile: str = "Republican",
+ name: str,
+ profile: str,
+ opponent_name: str,
**kwargs,
):
super().__init__(name, profile, **kwargs)
- self._init_actions([ShoutOut])
- self._watch([ShoutOut])
- self.name = "Trump"
- self.opponent_name = "Biden"
+ self._init_actions([SpeakAloud])
+ self._watch([BossRequirement, SpeakAloud])
+ self.name = name
+ self.opponent_name = opponent_name
async def _observe(self) -> int:
await super()._observe()
# accept messages sent (from opponent) to self, disregard own messages from the last round
- self._rc.news = [msg for msg in self._rc.news if msg.send_to == self.name]
+ self._rc.news = [msg for msg in self._rc.news if msg.send_to == self.name]
return len(self._rc.news)
async def _act(self) -> Message:
logger.info(f"{self._setting}: ready to {self._rc.todo}")
+ todo = self._rc.todo # An instance of SpeakAloud
- msg_history = self._rc.memory.get_by_actions([ShoutOut])
- context = []
- for m in msg_history:
- context.append(str(m))
- context = "\n".join(context)
+ memories = self.get_memories()
+ context = "\n".join(f"{msg.sent_from}: {msg.content}" for msg in memories)
+ # print(context)
- rsp = await ShoutOut().run(context=context, name=self.name, opponent_name=self.opponent_name)
+ rsp = await todo.run(context=context, name=self.name, opponent_name=self.opponent_name)
msg = Message(
content=rsp,
role=self.profile,
- cause_by=ShoutOut,
+ cause_by=type(todo),
sent_from=self.name,
send_to=self.opponent_name,
)
- return msg
-
-class Biden(Role):
- def __init__(
- self,
- name: str = "Biden",
- profile: str = "Democrat",
- **kwargs,
- ):
- super().__init__(name, profile, **kwargs)
- self._init_actions([ShoutOut])
- self._watch([BossRequirement, ShoutOut])
- self.name = "Biden"
- self.opponent_name = "Trump"
-
- async def _observe(self) -> int:
- await super()._observe()
- # accept the very first human instruction (the debate topic) or messages sent (from opponent) to self,
- # disregard own messages from the last round
- self._rc.news = [msg for msg in self._rc.news if msg.cause_by == BossRequirement or msg.send_to == self.name]
- return len(self._rc.news)
-
- async def _act(self) -> Message:
- logger.info(f"{self._setting}: ready to {self._rc.todo}")
-
- msg_history = self._rc.memory.get_by_actions([BossRequirement, ShoutOut])
- context = []
- for m in msg_history:
- context.append(str(m))
- context = "\n".join(context)
-
- rsp = await ShoutOut().run(context=context, name=self.name, opponent_name=self.opponent_name)
-
- msg = Message(
- content=rsp,
- role=self.profile,
- cause_by=ShoutOut,
- sent_from=self.name,
- send_to=self.opponent_name,
- )
+ self._rc.memory.add(msg)
return msg
-async def startup(idea: str, investment: float = 3.0, n_round: int = 5,
- code_review: bool = False, run_tests: bool = False):
- """We reuse the startup paradigm for roles to interact with each other.
- Now we run a startup of presidents and watch they quarrel. :) """
- company = SoftwareCompany()
- company.hire([Biden(), Trump()])
- company.invest(investment)
- company.start_project(idea)
- await company.run(n_round=n_round)
+async def debate(idea: str, investment: float = 3.0, n_round: int = 5):
+ """Run a team of presidents and watch they quarrel. :) """
+ Biden = Debator(name="Biden", profile="Democrat", opponent_name="Trump")
+ Trump = Debator(name="Trump", profile="Republican", opponent_name="Biden")
+ team = Team()
+ team.hire([Biden, Trump])
+ team.invest(investment)
+ team.start_project(idea, send_to="Biden") # send debate topic to Biden and let him speak first
+ await team.run(n_round=n_round)
def main(idea: str, investment: float = 3.0, n_round: int = 10):
@@ -141,7 +102,7 @@ def main(idea: str, investment: float = 3.0, n_round: int = 10):
"""
if platform.system() == "Windows":
asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
- asyncio.run(startup(idea, investment, n_round))
+ asyncio.run(debate(idea, investment, n_round))
if __name__ == '__main__':
diff --git a/metagpt/config.py b/metagpt/config.py
index 27455d38d..3f9e742bd 100644
--- a/metagpt/config.py
+++ b/metagpt/config.py
@@ -45,10 +45,11 @@ class Config(metaclass=Singleton):
self.global_proxy = self._get("GLOBAL_PROXY")
self.openai_api_key = self._get("OPENAI_API_KEY")
self.anthropic_api_key = self._get("Anthropic_API_KEY")
- if (not self.openai_api_key or "YOUR_API_KEY" == self.openai_api_key) and (
- not self.anthropic_api_key or "YOUR_API_KEY" == self.anthropic_api_key
- ):
- raise NotConfiguredException("Set OPENAI_API_KEY or Anthropic_API_KEY first")
+ self.zhipuai_api_key = self._get("ZHIPUAI_API_KEY")
+ if (not self.openai_api_key or "YOUR_API_KEY" == self.openai_api_key) and \
+ (not self.anthropic_api_key or "YOUR_API_KEY" == self.anthropic_api_key) and \
+ (not self.zhipuai_api_key or "YOUR_API_KEY" == self.zhipuai_api_key):
+ raise NotConfiguredException("Set OPENAI_API_KEY or Anthropic_API_KEY or ZHIPUAI_API_KEY first")
self.openai_api_base = self._get("OPENAI_API_BASE")
openai_proxy = self._get("OPENAI_PROXY") or self.global_proxy
if openai_proxy:
diff --git a/metagpt/const.py b/metagpt/const.py
index 7f3f87dfa..407ce803a 100644
--- a/metagpt/const.py
+++ b/metagpt/const.py
@@ -6,7 +6,7 @@
@File : const.py
"""
from pathlib import Path
-
+from loguru import logger
def get_project_root():
"""Search upwards to find the project root directory."""
@@ -17,10 +17,15 @@ def get_project_root():
or (current_path / ".project_root").exists()
or (current_path / ".gitignore").exists()
):
+ # use metagpt with git clone will land here
+ logger.info(f"PROJECT_ROOT set to {str(current_path)}")
return current_path
parent_path = current_path.parent
if parent_path == current_path:
- raise Exception("Project root not found.")
+ # use metagpt with pip install will land here
+ cwd = Path.cwd()
+ logger.info(f"PROJECT_ROOT set to current working directory: {str(cwd)}")
+ return cwd
current_path = parent_path
diff --git a/metagpt/llm.py b/metagpt/llm.py
index e6f815950..4edcd7a83 100644
--- a/metagpt/llm.py
+++ b/metagpt/llm.py
@@ -6,14 +6,27 @@
@File : llm.py
"""
+from metagpt.logs import logger
+from metagpt.config import CONFIG
from metagpt.provider.anthropic_api import Claude2 as Claude
-from metagpt.provider.openai_api import OpenAIGPTAPI as LLM
+from metagpt.provider.openai_api import OpenAIGPTAPI
+from metagpt.provider.zhipuai_api import ZhiPuAIGPTAPI
+from metagpt.provider.spark_api import SparkAPI
+from metagpt.provider.human_provider import HumanProvider
-DEFAULT_LLM = LLM()
-CLAUDE_LLM = Claude()
-async def ai_func(prompt):
- """使用LLM进行QA
- QA with LLMs
- """
- return await DEFAULT_LLM.aask(prompt)
+def LLM() -> "BaseGPTAPI":
+ """ initialize different LLM instance according to the key field existence"""
+ # TODO a little trick, can use registry to initialize LLM instance further
+ if CONFIG.openai_api_key:
+ llm = OpenAIGPTAPI()
+ elif CONFIG.claude_api_key:
+ llm = Claude()
+ elif CONFIG.spark_api_key:
+ llm = SparkAPI()
+ elif CONFIG.zhipuai_api_key:
+ llm = ZhiPuAIGPTAPI()
+ else:
+ raise RuntimeError("You should config a LLM configuration first")
+
+ return llm
diff --git a/metagpt/provider/base_chatbot.py b/metagpt/provider/base_chatbot.py
index abdf423f4..72e6c94f9 100644
--- a/metagpt/provider/base_chatbot.py
+++ b/metagpt/provider/base_chatbot.py
@@ -13,6 +13,7 @@ from dataclasses import dataclass
class BaseChatbot(ABC):
"""Abstract GPT class"""
mode: str = "API"
+ use_system_prompt: bool = True
@abstractmethod
def ask(self, msg: str) -> str:
diff --git a/metagpt/provider/base_gpt_api.py b/metagpt/provider/base_gpt_api.py
index de61167b9..b6b034329 100644
--- a/metagpt/provider/base_gpt_api.py
+++ b/metagpt/provider/base_gpt_api.py
@@ -5,6 +5,7 @@
@Author : alexanderwu
@File : base_gpt_api.py
"""
+import json
from abc import abstractmethod
from typing import Optional
@@ -14,7 +15,8 @@ from metagpt.provider.base_chatbot import BaseChatbot
class BaseGPTAPI(BaseChatbot):
"""GPT API abstract class, requiring all inheritors to provide a series of standard capabilities"""
- system_prompt = 'You are a helpful assistant.'
+
+ system_prompt = "You are a helpful assistant."
def _user_msg(self, msg: str) -> dict[str, str]:
return {"role": "user", "content": msg}
@@ -32,15 +34,17 @@ class BaseGPTAPI(BaseChatbot):
return self._system_msg(self.system_prompt)
def ask(self, msg: str) -> str:
- message = [self._default_system_msg(), self._user_msg(msg)]
+ message = [self._default_system_msg(), self._user_msg(msg)] if self.use_system_prompt else [self._user_msg(msg)]
rsp = self.completion(message)
return self.get_choice_text(rsp)
async def aask(self, msg: str, system_msgs: Optional[list[str]] = None) -> str:
if system_msgs:
- message = self._system_msgs(system_msgs) + [self._user_msg(msg)]
+ message = self._system_msgs(system_msgs) + [self._user_msg(msg)] if self.use_system_prompt \
+ else [self._user_msg(msg)]
else:
- message = [self._default_system_msg(), self._user_msg(msg)]
+ message = [self._default_system_msg(), self._user_msg(msg)] if self.use_system_prompt \
+ else [self._user_msg(msg)]
rsp = await self.acompletion_text(message, stream=True)
logger.debug(message)
# logger.debug(rsp)
@@ -108,11 +112,50 @@ class BaseGPTAPI(BaseChatbot):
"""Required to provide the first text of choice"""
return rsp.get("choices")[0]["message"]["content"]
+ def get_choice_function(self, rsp: dict) -> dict:
+ """Required to provide the first function of choice
+ :param dict rsp: OpenAI chat.comletion respond JSON, Note "message" must include "tool_calls",
+ and "tool_calls" must include "function", for example:
+ {...
+ "choices": [
+ {
+ "index": 0,
+ "message": {
+ "role": "assistant",
+ "content": null,
+ "tool_calls": [
+ {
+ "id": "call_Y5r6Ddr2Qc2ZrqgfwzPX5l72",
+ "type": "function",
+ "function": {
+ "name": "execute",
+ "arguments": "{\n \"language\": \"python\",\n \"code\": \"print('Hello, World!')\"\n}"
+ }
+ }
+ ]
+ },
+ "finish_reason": "stop"
+ }
+ ],
+ ...}
+ :return dict: return first function of choice, for exmaple,
+ {'name': 'execute', 'arguments': '{\n "language": "python",\n "code": "print(\'Hello, World!\')"\n}'}
+ """
+ return rsp.get("choices")[0]["message"]["tool_calls"][0]["function"].to_dict()
+
+ def get_choice_function_arguments(self, rsp: dict) -> dict:
+ """Required to provide the first function arguments of choice.
+
+ :param dict rsp: same as in self.get_choice_function(rsp)
+ :return dict: return the first function arguments of choice, for example,
+ {'language': 'python', 'code': "print('Hello, World!')"}
+ """
+ return json.loads(self.get_choice_function(rsp)["arguments"])
+
def messages_to_prompt(self, messages: list[dict]):
"""[{"role": "user", "content": msg}] to user: etc."""
- return '\n'.join([f"{i['role']}: {i['content']}" for i in messages])
+ return "\n".join([f"{i['role']}: {i['content']}" for i in messages])
def messages_to_dict(self, messages):
"""objects to [{"role": "user", "content": msg}] etc."""
return [i.to_dict() for i in messages]
-
\ No newline at end of file
diff --git a/metagpt/provider/constant.py b/metagpt/provider/constant.py
new file mode 100644
index 000000000..db67847a8
--- /dev/null
+++ b/metagpt/provider/constant.py
@@ -0,0 +1,30 @@
+# function in tools, https://platform.openai.com/docs/api-reference/chat/create#chat-create-tools
+# Reference: https://github.com/KillianLucas/open-interpreter/blob/v0.1.14/interpreter/llm/setup_openai_coding_llm.py
+GENERAL_FUNCTION_SCHEMA = {
+ "name": "execute",
+ "description": "Executes code on the user's machine, **in the users local environment**, and returns the output",
+ "parameters": {
+ "type": "object",
+ "properties": {
+ "language": {
+ "type": "string",
+ "description": "The programming language (required parameter to the `execute` function)",
+ "enum": [
+ "python",
+ "R",
+ "shell",
+ "applescript",
+ "javascript",
+ "html",
+ "powershell",
+ ],
+ },
+ "code": {"type": "string", "description": "The code to execute (required)"},
+ },
+ "required": ["language", "code"],
+ },
+}
+
+# tool_choice value for general_function_schema
+# https://platform.openai.com/docs/api-reference/chat/create#chat-create-tool_choice
+GENERAL_TOOL_CHOICE = {"type": "function", "function": {"name": "execute"}}
diff --git a/metagpt/provider/general_api_requestor.py b/metagpt/provider/general_api_requestor.py
new file mode 100644
index 000000000..150f2f1e0
--- /dev/null
+++ b/metagpt/provider/general_api_requestor.py
@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc : General Async API for http-based LLM model
+
+from typing import AsyncGenerator, Tuple, Union, Optional, Literal
+import aiohttp
+import asyncio
+
+from openai.api_requestor import APIRequestor
+
+from metagpt.logs import logger
+
+
+class GeneralAPIRequestor(APIRequestor):
+ """
+ usage
+ # full_url = "{api_base}{url}"
+ requester = GeneralAPIRequestor(api_base=api_base)
+ result, _, api_key = await requester.arequest(
+ method=method,
+ url=url,
+ headers=headers,
+ stream=stream,
+ params=kwargs,
+ request_timeout=120
+ )
+ """
+
+ def _interpret_response_line(
+ self, rbody: str, rcode: int, rheaders, stream: bool
+ ) -> str:
+ # just do nothing to meet the APIRequestor process and return the raw data
+ # due to the openai sdk will convert the data into OpenAIResponse which we don't need in general cases.
+
+ return rbody
+
+ async def _interpret_async_response(
+ self, result: aiohttp.ClientResponse, stream: bool
+ ) -> Tuple[Union[str, AsyncGenerator[str, None]], bool]:
+ if stream and "text/event-stream" in result.headers.get("Content-Type", ""):
+ return (
+ self._interpret_response_line(
+ line, result.status, result.headers, stream=True
+ )
+ async for line in result.content
+ ), True
+ else:
+ try:
+ await result.read()
+ except (aiohttp.ServerTimeoutError, asyncio.TimeoutError) as e:
+ raise TimeoutError("Request timed out") from e
+ except aiohttp.ClientError as exp:
+ logger.warning(f"response: {result.content}, exp: {exp}")
+ return (
+ self._interpret_response_line(
+ await result.read(), # let the caller to decode the msg
+ result.status,
+ result.headers,
+ stream=False,
+ ),
+ False,
+ )
diff --git a/metagpt/provider/human_provider.py b/metagpt/provider/human_provider.py
new file mode 100644
index 000000000..1d12f972f
--- /dev/null
+++ b/metagpt/provider/human_provider.py
@@ -0,0 +1,35 @@
+'''
+Filename: MetaGPT/metagpt/provider/human_provider.py
+Created Date: Wednesday, November 8th 2023, 11:55:46 pm
+Author: garylin2099
+'''
+from typing import Optional
+from metagpt.provider.base_gpt_api import BaseGPTAPI
+from metagpt.logs import logger
+
+class HumanProvider(BaseGPTAPI):
+ """Humans provide themselves as a 'model', which actually takes in human input as its response.
+ This enables replacing LLM anywhere in the framework with a human, thus introducing human interaction
+ """
+
+ def ask(self, msg: str) -> str:
+ logger.info("It's your turn, please type in your response. You may also refer to the context below")
+ rsp = input(msg)
+ if rsp in ["exit", "quit"]:
+ exit()
+ return rsp
+
+ async def aask(self, msg: str, system_msgs: Optional[list[str]] = None) -> str:
+ return self.ask(msg)
+
+ def completion(self, messages: list[dict]):
+ """dummy implementation of abstract method in base"""
+ return []
+
+ async def acompletion(self, messages: list[dict]):
+ """dummy implementation of abstract method in base"""
+ return []
+
+ async def acompletion_text(self, messages: list[dict], stream=False) -> str:
+ """dummy implementation of abstract method in base"""
+ return []
diff --git a/metagpt/provider/openai_api.py b/metagpt/provider/openai_api.py
index 6ebed2c16..34e5693f8 100644
--- a/metagpt/provider/openai_api.py
+++ b/metagpt/provider/openai_api.py
@@ -21,6 +21,8 @@ from tenacity import (
from metagpt.config import CONFIG
from metagpt.logs import logger
from metagpt.provider.base_gpt_api import BaseGPTAPI
+from metagpt.provider.constant import GENERAL_FUNCTION_SCHEMA, GENERAL_TOOL_CHOICE
+from metagpt.schema import Message
from metagpt.utils.singleton import Singleton
from metagpt.utils.token_counter import (
TOKEN_COSTS,
@@ -110,7 +112,6 @@ class CostManager(metaclass=Singleton):
"""
return self.total_completion_tokens
-
def get_total_cost(self):
"""
Get the total cost of API calls.
@@ -120,7 +121,6 @@ class CostManager(metaclass=Singleton):
"""
return self.total_cost
-
def get_costs(self) -> Costs:
"""Get all costs"""
return Costs(self.total_prompt_tokens, self.total_completion_tokens, self.total_cost, self.total_budget)
@@ -181,7 +181,7 @@ class OpenAIGPTAPI(BaseGPTAPI, RateLimiter):
self._update_costs(usage)
return full_reply_content
- def _cons_kwargs(self, messages: list[dict]) -> dict:
+ def _cons_kwargs(self, messages: list[dict], **configs) -> dict:
kwargs = {
"messages": messages,
"max_tokens": self.get_max_tokens(messages),
@@ -190,6 +190,9 @@ class OpenAIGPTAPI(BaseGPTAPI, RateLimiter):
"temperature": 0.3,
"timeout": 3,
}
+ if configs:
+ kwargs.update(configs)
+
if CONFIG.openai_api_type == "azure":
if CONFIG.deployment_name and CONFIG.deployment_id:
raise ValueError("You can only use one of the `deployment_id` or `deployment_name` model")
@@ -239,6 +242,81 @@ class OpenAIGPTAPI(BaseGPTAPI, RateLimiter):
rsp = await self._achat_completion(messages)
return self.get_choice_text(rsp)
+ def _func_configs(self, messages: list[dict], **kwargs) -> dict:
+ """
+ Note: Keep kwargs consistent with the parameters in the https://platform.openai.com/docs/api-reference/chat/create
+ """
+ if "tools" not in kwargs:
+ configs = {
+ "tools": [{"type": "function", "function": GENERAL_FUNCTION_SCHEMA}],
+ "tool_choice": GENERAL_TOOL_CHOICE,
+ }
+ kwargs.update(configs)
+
+ return self._cons_kwargs(messages, **kwargs)
+
+ def _chat_completion_function(self, messages: list[dict], **kwargs) -> dict:
+ rsp = self.llm.ChatCompletion.create(**self._func_configs(messages, **kwargs))
+ self._update_costs(rsp.get("usage"))
+ return rsp
+
+ async def _achat_completion_function(self, messages: list[dict], **chat_configs) -> dict:
+ rsp = await self.llm.ChatCompletion.acreate(**self._func_configs(messages, **chat_configs))
+ self._update_costs(rsp.get("usage"))
+ return rsp
+
+ def _process_message(self, messages: Union[str, Message, list[dict], list[Message], list[str]]) -> list[dict]:
+ """convert messages to list[dict]."""
+ if isinstance(messages, list):
+ messages = [Message(msg) if isinstance(msg, str) else msg for msg in messages]
+ return [msg if isinstance(msg, dict) else msg.to_dict() for msg in messages]
+
+ if isinstance(messages, Message):
+ messages = [messages.to_dict()]
+ elif isinstance(messages, str):
+ messages = [{"role": "user", "content": messages}]
+ else:
+ raise ValueError(
+ f"Only support messages type are: str, Message, list[dict], but got {type(messages).__name__}!"
+ )
+ return messages
+
+ def ask_code(self, messages: Union[str, Message, list[dict]], **kwargs) -> dict:
+ """Use function of tools to ask a code.
+
+ Note: Keep kwargs consistent with the parameters in the https://platform.openai.com/docs/api-reference/chat/create
+
+ Examples:
+
+ >>> llm = OpenAIGPTAPI()
+ >>> llm.ask_code("Write a python hello world code.")
+ {'language': 'python', 'code': "print('Hello, World!')"}
+ >>> msg = [{'role': 'user', 'content': "Write a python hello world code."}]
+ >>> llm.ask_code(msg)
+ {'language': 'python', 'code': "print('Hello, World!')"}
+ """
+ messages = self._process_message(messages)
+ rsp = self._chat_completion_function(messages, **kwargs)
+ return self.get_choice_function_arguments(rsp)
+
+ async def aask_code(self, messages: Union[str, Message, list[dict]], **kwargs) -> dict:
+ """Use function of tools to ask a code.
+
+ Note: Keep kwargs consistent with the parameters in the https://platform.openai.com/docs/api-reference/chat/create
+
+ Examples:
+
+ >>> llm = OpenAIGPTAPI()
+ >>> rsp = await llm.ask_code("Write a python hello world code.")
+ >>> rsp
+ {'language': 'python', 'code': "print('Hello, World!')"}
+ >>> msg = [{'role': 'user', 'content': "Write a python hello world code."}]
+ >>> rsp = await llm.aask_code(msg) # -> {'language': 'python', 'code': "print('Hello, World!')"}
+ """
+ messages = self._process_message(messages)
+ rsp = await self._achat_completion_function(messages, **kwargs)
+ return self.get_choice_function_arguments(rsp)
+
def _calc_usage(self, messages: list[dict], rsp: str) -> dict:
usage = {}
if CONFIG.calc_usage:
diff --git a/metagpt/provider/zhipuai/__init__.py b/metagpt/provider/zhipuai/__init__.py
new file mode 100644
index 000000000..2bcf8efd0
--- /dev/null
+++ b/metagpt/provider/zhipuai/__init__.py
@@ -0,0 +1,3 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc :
diff --git a/metagpt/provider/zhipuai/async_sse_client.py b/metagpt/provider/zhipuai/async_sse_client.py
new file mode 100644
index 000000000..b819fdc63
--- /dev/null
+++ b/metagpt/provider/zhipuai/async_sse_client.py
@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc : async_sse_client to make keep the use of Event to access response
+# refs to `https://github.com/zhipuai/zhipuai-sdk-python/blob/main/zhipuai/utils/sse_client.py`
+
+from zhipuai.utils.sse_client import SSEClient, Event, _FIELD_SEPARATOR
+
+
+class AsyncSSEClient(SSEClient):
+
+ async def _aread(self):
+ data = b""
+ async for chunk in self._event_source:
+ for line in chunk.splitlines(True):
+ data += line
+ if data.endswith((b"\r\r", b"\n\n", b"\r\n\r\n")):
+ yield data
+ data = b""
+ if data:
+ yield data
+
+ async def async_events(self):
+ async for chunk in self._aread():
+ event = Event()
+ # Split before decoding so splitlines() only uses \r and \n
+ for line in chunk.splitlines():
+ # Decode the line.
+ line = line.decode(self._char_enc)
+
+ # Lines starting with a separator are comments and are to be
+ # ignored.
+ if not line.strip() or line.startswith(_FIELD_SEPARATOR):
+ continue
+
+ data = line.split(_FIELD_SEPARATOR, 1)
+ field = data[0]
+
+ # Ignore unknown fields.
+ if field not in event.__dict__:
+ self._logger.debug(
+ "Saw invalid field %s while parsing " "Server Side Event", field
+ )
+ continue
+
+ if len(data) > 1:
+ # From the spec:
+ # "If value starts with a single U+0020 SPACE character,
+ # remove it from value."
+ if data[1].startswith(" "):
+ value = data[1][1:]
+ else:
+ value = data[1]
+ else:
+ # If no value is present after the separator,
+ # assume an empty value.
+ value = ""
+
+ # The data field may come over multiple lines and their values
+ # are concatenated with each other.
+ if field == "data":
+ event.__dict__[field] += value + "\n"
+ else:
+ event.__dict__[field] = value
+
+ # Events with no data are not dispatched.
+ if not event.data:
+ continue
+
+ # If the data field ends with a newline, remove it.
+ if event.data.endswith("\n"):
+ event.data = event.data[0:-1]
+
+ # Empty event names default to 'message'
+ event.event = event.event or "message"
+
+ # Dispatch the event
+ self._logger.debug("Dispatching %s...", event)
+ yield event
diff --git a/metagpt/provider/zhipuai/zhipu_model_api.py b/metagpt/provider/zhipuai/zhipu_model_api.py
new file mode 100644
index 000000000..618b2e865
--- /dev/null
+++ b/metagpt/provider/zhipuai/zhipu_model_api.py
@@ -0,0 +1,79 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc : zhipu model api to support sync & async for invoke & sse_invoke
+
+import zhipuai
+from zhipuai.model_api.api import ModelAPI, InvokeType
+from zhipuai.utils.http_client import headers as zhipuai_default_headers
+
+from metagpt.provider.zhipuai.async_sse_client import AsyncSSEClient
+from metagpt.provider.general_api_requestor import GeneralAPIRequestor
+
+
+class ZhiPuModelAPI(ModelAPI):
+
+ @classmethod
+ def get_header(cls) -> dict:
+ token = cls._generate_token()
+ zhipuai_default_headers.update({"Authorization": token})
+ return zhipuai_default_headers
+
+ @classmethod
+ def get_sse_header(cls) -> dict:
+ token = cls._generate_token()
+ headers = {
+ "Authorization": token
+ }
+ return headers
+
+ @classmethod
+ def split_zhipu_api_url(cls, invoke_type: InvokeType, kwargs):
+ # use this method to prevent zhipu api upgrading to different version.
+ # and follow the GeneralAPIRequestor implemented based on openai sdk
+ zhipu_api_url = cls._build_api_url(kwargs, invoke_type)
+ """
+ example:
+ zhipu_api_url: https://open.bigmodel.cn/api/paas/v3/model-api/{model}/{invoke_method}
+ """
+ arr = zhipu_api_url.split("/api/")
+ # ("https://open.bigmodel.cn/api/" , "/paas/v3/model-api/chatglm_turbo/invoke")
+ return f"{arr[0]}/api", f"/{arr[1]}"
+
+ @classmethod
+ async def arequest(cls, invoke_type: InvokeType, stream: bool, method: str, headers: dict, kwargs):
+ # TODO to make the async request to be more generic for models in http mode.
+ assert method in ["post", "get"]
+
+ api_base, url = cls.split_zhipu_api_url(invoke_type, kwargs)
+ requester = GeneralAPIRequestor(api_base=api_base)
+ result, _, api_key = await requester.arequest(
+ method=method,
+ url=url,
+ headers=headers,
+ stream=stream,
+ params=kwargs,
+ request_timeout=zhipuai.api_timeout_seconds
+ )
+
+ return result
+
+ @classmethod
+ async def ainvoke(cls, **kwargs) -> dict:
+ """ async invoke different from raw method `async_invoke` which get the final result by task_id"""
+ headers = cls.get_header()
+ resp = await cls.arequest(invoke_type=InvokeType.SYNC,
+ stream=False,
+ method="post",
+ headers=headers,
+ kwargs=kwargs)
+ return resp
+
+ @classmethod
+ async def asse_invoke(cls, **kwargs) -> AsyncSSEClient:
+ """ async sse_invoke """
+ headers = cls.get_sse_header()
+ return AsyncSSEClient(await cls.arequest(invoke_type=InvokeType.SSE,
+ stream=True,
+ method="post",
+ headers=headers,
+ kwargs=kwargs))
diff --git a/metagpt/provider/zhipuai_api.py b/metagpt/provider/zhipuai_api.py
new file mode 100644
index 000000000..3161c0e88
--- /dev/null
+++ b/metagpt/provider/zhipuai_api.py
@@ -0,0 +1,139 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc : zhipuai LLM from https://open.bigmodel.cn/dev/api#sdk
+
+from enum import Enum
+import json
+from tenacity import (
+ after_log,
+ retry,
+ retry_if_exception_type,
+ stop_after_attempt,
+ wait_fixed,
+)
+from requests import ConnectionError
+
+import openai
+import zhipuai
+
+from metagpt.config import CONFIG
+from metagpt.logs import logger
+from metagpt.provider.base_gpt_api import BaseGPTAPI
+from metagpt.provider.openai_api import CostManager, log_and_reraise
+from metagpt.provider.zhipuai.zhipu_model_api import ZhiPuModelAPI
+
+
+class ZhiPuEvent(Enum):
+ ADD = "add"
+ ERROR = "error"
+ INTERRUPTED = "interrupted"
+ FINISH = "finish"
+
+
+class ZhiPuAIGPTAPI(BaseGPTAPI):
+ """
+ Refs to `https://open.bigmodel.cn/dev/api#chatglm_turbo`
+ From now, there is only one model named `chatglm_turbo`
+ """
+
+ use_system_prompt: bool = False # zhipuai has no system prompt when use api
+
+ def __init__(self):
+ self.__init_zhipuai(CONFIG)
+ self.llm = ZhiPuModelAPI
+ self.model = "chatglm_turbo" # so far only one model, just use it
+ self._cost_manager = CostManager()
+
+ def __init_zhipuai(self, config: CONFIG):
+ assert config.zhipuai_api_key
+ zhipuai.api_key = config.zhipuai_api_key
+ openai.api_key = zhipuai.api_key # due to use openai sdk, set the api_key but it will't be used.
+
+ def _const_kwargs(self, messages: list[dict]) -> dict:
+ kwargs = {
+ "model": self.model,
+ "prompt": messages,
+ "temperature": 0.3
+ }
+ return kwargs
+
+ def _update_costs(self, usage: dict):
+ """ update each request's token cost """
+ if CONFIG.calc_usage:
+ try:
+ prompt_tokens = int(usage.get("prompt_tokens", 0))
+ completion_tokens = int(usage.get("completion_tokens", 0))
+ self._cost_manager.update_cost(prompt_tokens, completion_tokens, self.model)
+ except Exception as e:
+ logger.error("zhipuai updats costs failed!", e)
+
+ def get_choice_text(self, resp: dict) -> str:
+ """ get the first text of choice from llm response """
+ assist_msg = resp.get("data", {}).get("choices", [{"role": "error"}])[-1]
+ assert assist_msg["role"] == "assistant"
+ return assist_msg.get("content")
+
+ def completion(self, messages: list[dict]) -> dict:
+ resp = self.llm.invoke(**self._const_kwargs(messages))
+ usage = resp.get("data").get("usage")
+ self._update_costs(usage)
+ return resp
+
+ async def _achat_completion(self, messages: list[dict]) -> dict:
+ resp = await self.llm.ainvoke(**self._const_kwargs(messages))
+ usage = resp.get("data").get("usage")
+ self._update_costs(usage)
+ return resp
+
+ async def acompletion(self, messages: list[dict]) -> dict:
+ return await self._achat_completion(messages)
+
+ async def _achat_completion_stream(self, messages: list[dict]) -> str:
+ response = await self.llm.asse_invoke(**self._const_kwargs(messages))
+ collected_content = []
+ usage = {}
+ async for event in response.async_events():
+ if event.event == ZhiPuEvent.ADD.value:
+ content = event.data
+ collected_content.append(content)
+ print(content, end="")
+ elif event.event == ZhiPuEvent.ERROR.value or event.event == ZhiPuEvent.INTERRUPTED.value:
+ content = event.data
+ logger.error(f"event error: {content}", end="")
+ collected_content.append([content])
+ elif event.event == ZhiPuEvent.FINISH.value:
+ """
+ event.meta
+ {
+ "task_status":"SUCCESS",
+ "usage":{
+ "completion_tokens":351,
+ "prompt_tokens":595,
+ "total_tokens":946
+ },
+ "task_id":"xx",
+ "request_id":"xxx"
+ }
+ """
+ meta = json.loads(event.meta)
+ usage = meta.get("usage")
+ else:
+ print(f"zhipuapi else event: {event.data}", end="")
+
+ self._update_costs(usage)
+ full_content = "".join(collected_content)
+ return full_content
+
+ @retry(
+ stop=stop_after_attempt(3),
+ wait=wait_fixed(1),
+ after=after_log(logger, logger.level("WARNING").name),
+ retry=retry_if_exception_type(ConnectionError),
+ retry_error_callback=log_and_reraise
+ )
+ async def acompletion_text(self, messages: list[dict], stream=False) -> str:
+ """ response in async with stream or non-stream mode """
+ if stream:
+ return await self._achat_completion_stream(messages)
+ resp = await self._achat_completion(messages)
+ return self.get_choice_text(resp)
diff --git a/metagpt/roles/engineer.py b/metagpt/roles/engineer.py
index 6d65575a8..1f6685b38 100644
--- a/metagpt/roles/engineer.py
+++ b/metagpt/roles/engineer.py
@@ -207,6 +207,7 @@ class Engineer(Role):
async def _act(self) -> Message:
"""Determines the mode of action based on whether code review is used."""
+ logger.info(f"{self._setting}: ready to WriteCode")
if self.use_code_review:
return await self._act_sp_precision()
return await self._act_sp()
diff --git a/metagpt/roles/invoice_ocr_assistant.py b/metagpt/roles/invoice_ocr_assistant.py
index c307b20c0..15f831c97 100644
--- a/metagpt/roles/invoice_ocr_assistant.py
+++ b/metagpt/roles/invoice_ocr_assistant.py
@@ -42,17 +42,7 @@ class InvoiceOCRAssistant(Role):
self.filename = ""
self.origin_query = ""
self.orc_data = None
-
- async def _think(self) -> None:
- """Determine the next action to be taken by the role."""
- if self._rc.todo is None:
- self._set_state(0)
- return
-
- if self._rc.state + 1 < len(self._states):
- self._set_state(self._rc.state + 1)
- else:
- self._rc.todo = None
+ self._set_react_mode(react_mode="by_order")
async def _act(self) -> Message:
"""Perform an action as determined by the role.
@@ -94,17 +84,3 @@ class InvoiceOCRAssistant(Role):
msg = Message(content=content, instruct_content=resp)
self._rc.memory.add(msg)
return msg
-
- async def _react(self) -> Message:
- """Execute the invoice ocr assistant's think and actions.
-
- Returns:
- A message containing the final result of the assistant's actions.
- """
- while True:
- await self._think()
- if self._rc.todo is None:
- break
- msg = await self._act()
- return msg
-
diff --git a/metagpt/roles/researcher.py b/metagpt/roles/researcher.py
index acb46c718..c5512121a 100644
--- a/metagpt/roles/researcher.py
+++ b/metagpt/roles/researcher.py
@@ -31,20 +31,11 @@ class Researcher(Role):
):
super().__init__(name, profile, goal, constraints, **kwargs)
self._init_actions([CollectLinks(name), WebBrowseAndSummarize(name), ConductResearch(name)])
+ self._set_react_mode(react_mode="by_order")
self.language = language
if language not in ("en-us", "zh-cn"):
logger.warning(f"The language `{language}` has not been tested, it may not work.")
- async def _think(self) -> None:
- if self._rc.todo is None:
- self._set_state(0)
- return
-
- if self._rc.state + 1 < len(self._states):
- self._set_state(self._rc.state + 1)
- else:
- self._rc.todo = None
-
async def _act(self) -> Message:
logger.info(f"{self._setting}: ready to {self._rc.todo}")
todo = self._rc.todo
@@ -73,12 +64,8 @@ class Researcher(Role):
self._rc.memory.add(ret)
return ret
- async def _react(self) -> Message:
- while True:
- await self._think()
- if self._rc.todo is None:
- break
- msg = await self._act()
+ async def react(self) -> Message:
+ msg = await super().react()
report = msg.instruct_content
self.write_report(report.topic, report.content)
return msg
diff --git a/metagpt/roles/role.py b/metagpt/roles/role.py
index 44bb3e976..b96c361c0 100644
--- a/metagpt/roles/role.py
+++ b/metagpt/roles/role.py
@@ -7,14 +7,15 @@
"""
from __future__ import annotations
-from typing import Iterable, Type
+from typing import Iterable, Type, Union
+from enum import Enum
from pydantic import BaseModel, Field
# from metagpt.environment import Environment
from metagpt.config import CONFIG
from metagpt.actions import Action, ActionOutput
-from metagpt.llm import LLM
+from metagpt.llm import LLM, HumanProvider
from metagpt.logs import logger
from metagpt.memory import Memory, LongTermMemory
from metagpt.schema import Message
@@ -27,12 +28,14 @@ Please note that only the text between the first and second "===" is information
{history}
===
-You can now choose one of the following stages to decide the stage you need to go in the next step:
+Your previous stage: {previous_state}
+
+Now choose one of the following stages you need to go to in the next step:
{states}
Just answer a number between 0-{n_states}, choose the most suitable stage according to the understanding of the conversation.
Please note that the answer only needs a number, no need to add any other text.
-If there is no conversation record, choose 0.
+If you think you have completed your goal and don't need to go to any of the stages, return -1.
Do not answer anything else, and do not add any other information in your answer.
"""
@@ -46,6 +49,14 @@ ROLE_TEMPLATE = """Your response should be based on the previous conversation hi
{name}: {result}
"""
+class RoleReactMode(str, Enum):
+ REACT = "react"
+ BY_ORDER = "by_order"
+ PLAN_AND_ACT = "plan_and_act"
+
+ @classmethod
+ def values(cls):
+ return [item.value for item in cls]
class RoleSetting(BaseModel):
"""Role Settings"""
@@ -54,6 +65,7 @@ class RoleSetting(BaseModel):
goal: str
constraints: str
desc: str
+ is_human: bool
def __str__(self):
return f"{self.name}({self.profile})"
@@ -67,10 +79,12 @@ class RoleContext(BaseModel):
env: 'Environment' = Field(default=None)
memory: Memory = Field(default_factory=Memory)
long_term_memory: LongTermMemory = Field(default_factory=LongTermMemory)
- state: int = Field(default=0)
+ state: int = Field(default=-1) # -1 indicates initial or termination state where todo is None
todo: Action = Field(default=None)
watch: set[Type[Action]] = Field(default_factory=set)
news: list[Type[Message]] = Field(default=[])
+ react_mode: RoleReactMode = RoleReactMode.REACT # see `Role._set_react_mode` for definitions of the following two attributes
+ max_react_loop: int = 1
class Config:
arbitrary_types_allowed = True
@@ -93,9 +107,10 @@ class RoleContext(BaseModel):
class Role:
"""Role/Agent"""
- def __init__(self, name="", profile="", goal="", constraints="", desc=""):
- self._llm = LLM()
- self._setting = RoleSetting(name=name, profile=profile, goal=goal, constraints=constraints, desc=desc)
+ def __init__(self, name="", profile="", goal="", constraints="", desc="", is_human=False):
+ self._llm = LLM() if not is_human else HumanProvider()
+ self._setting = RoleSetting(name=name, profile=profile, goal=goal,
+ constraints=constraints, desc=desc, is_human=is_human)
self._states = []
self._actions = []
self._role_id = str(self._setting)
@@ -109,24 +124,48 @@ class Role:
self._reset()
for idx, action in enumerate(actions):
if not isinstance(action, Action):
- i = action("")
+ i = action("", llm=self._llm)
else:
+ if self._setting.is_human and not isinstance(action.llm, HumanProvider):
+ logger.warning(f"is_human attribute does not take effect,"
+ f"as Role's {str(action)} was initialized using LLM, try passing in Action classes instead of initialized instances")
i = action
i.set_prefix(self._get_prefix(), self.profile)
self._actions.append(i)
self._states.append(f"{idx}. {action}")
+ def _set_react_mode(self, react_mode: str, max_react_loop: int = 1):
+ """Set strategy of the Role reacting to observed Message. Variation lies in how
+ this Role elects action to perform during the _think stage, especially if it is capable of multiple Actions.
+
+ Args:
+ react_mode (str): Mode for choosing action during the _think stage, can be one of:
+ "react": standard think-act loop in the ReAct paper, alternating thinking and acting to solve the task, i.e. _think -> _act -> _think -> _act -> ...
+ Use llm to select actions in _think dynamically;
+ "by_order": switch action each time by order defined in _init_actions, i.e. _act (Action1) -> _act (Action2) -> ...;
+ "plan_and_act": first plan, then execute an action sequence, i.e. _think (of a plan) -> _act -> _act -> ...
+ Use llm to come up with the plan dynamically.
+ Defaults to "react".
+ max_react_loop (int): Maximum react cycles to execute, used to prevent the agent from reacting forever.
+ Take effect only when react_mode is react, in which we use llm to choose actions, including termination.
+ Defaults to 1, i.e. _think -> _act (-> return result and end)
+ """
+ assert react_mode in RoleReactMode.values(), f"react_mode must be one of {RoleReactMode.values()}"
+ self._rc.react_mode = react_mode
+ if react_mode == RoleReactMode.REACT:
+ self._rc.max_react_loop = max_react_loop
+
def _watch(self, actions: Iterable[Type[Action]]):
"""Listen to the corresponding behaviors"""
self._rc.watch.update(actions)
# check RoleContext after adding watch actions
self._rc.check(self._role_id)
- def _set_state(self, state):
+ def _set_state(self, state: int):
"""Update the current state."""
self._rc.state = state
logger.debug(self._actions)
- self._rc.todo = self._actions[self._rc.state]
+ self._rc.todo = self._actions[self._rc.state] if state >= 0 else None
def set_env(self, env: 'Environment'):
"""Set the environment in which the role works. The role can talk to the environment and can also receive messages by observing."""
@@ -151,13 +190,19 @@ class Role:
return
prompt = self._get_prefix()
prompt += STATE_TEMPLATE.format(history=self._rc.history, states="\n".join(self._states),
- n_states=len(self._states) - 1)
+ n_states=len(self._states) - 1, previous_state=self._rc.state)
+ # print(prompt)
next_state = await self._llm.aask(prompt)
logger.debug(f"{prompt=}")
- if not next_state.isdigit() or int(next_state) not in range(len(self._states)):
- logger.warning(f'Invalid answer of state, {next_state=}')
- next_state = "0"
- self._set_state(int(next_state))
+ if (not next_state.isdigit() and next_state != "-1") \
+ or int(next_state) not in range(-1, len(self._states)):
+ logger.warning(f'Invalid answer of state, {next_state=}, will be set to -1')
+ next_state = -1
+ else:
+ next_state = int(next_state)
+ if next_state == -1:
+ logger.info(f"End actions with {next_state=}")
+ self._set_state(next_state)
async def _act(self) -> Message:
# prompt = self.get_prefix()
@@ -203,10 +248,45 @@ class Role:
self._rc.env.publish_message(msg)
async def _react(self) -> Message:
- """Think first, then act"""
- await self._think()
- logger.debug(f"{self._setting}: {self._rc.state=}, will do {self._rc.todo}")
- return await self._act()
+ """Think first, then act, until the Role _think it is time to stop and requires no more todo.
+ This is the standard think-act loop in the ReAct paper, which alternates thinking and acting in task solving, i.e. _think -> _act -> _think -> _act -> ...
+ Use llm to select actions in _think dynamically
+ """
+ actions_taken = 0
+ rsp = Message("No actions taken yet") # will be overwritten after Role _act
+ while actions_taken < self._rc.max_react_loop:
+ # think
+ await self._think()
+ if self._rc.todo is None:
+ break
+ # act
+ logger.debug(f"{self._setting}: {self._rc.state=}, will do {self._rc.todo}")
+ rsp = await self._act()
+ actions_taken += 1
+ return rsp # return output from the last action
+
+ async def _act_by_order(self) -> Message:
+ """switch action each time by order defined in _init_actions, i.e. _act (Action1) -> _act (Action2) -> ..."""
+ for i in range(len(self._states)):
+ self._set_state(i)
+ rsp = await self._act()
+ return rsp # return output from the last action
+
+ async def _plan_and_act(self) -> Message:
+ """first plan, then execute an action sequence, i.e. _think (of a plan) -> _act -> _act -> ... Use llm to come up with the plan dynamically."""
+ # TODO: to be implemented
+ return Message("")
+
+ async def react(self) -> Message:
+ """Entry to one of three strategies by which Role reacts to the observed Message"""
+ if self._rc.react_mode == RoleReactMode.REACT:
+ rsp = await self._react()
+ elif self._rc.react_mode == RoleReactMode.BY_ORDER:
+ rsp = await self._act_by_order()
+ elif self._rc.react_mode == RoleReactMode.PLAN_AND_ACT:
+ rsp = await self._plan_and_act()
+ self._set_state(state=-1) # current reaction is complete, reset state to -1 and todo back to None
+ return rsp
def recv(self, message: Message) -> None:
"""add message to history."""
@@ -223,6 +303,10 @@ class Role:
return await self._react()
+ def get_memories(self, k=0) -> list[Message]:
+ """A wrapper to return the most recent k memories of this role, return all when k=0"""
+ return self._rc.memory.get(k=k)
+
async def run(self, message=None):
"""Observe, and think and act based on the results of the observation"""
if message:
@@ -237,7 +321,7 @@ class Role:
logger.debug(f"{self._setting}: no news. waiting.")
return
- rsp = await self._react()
+ rsp = await self.react()
# Publish the reply to the environment, waiting for the next subscriber to process
self._publish_message(rsp)
return rsp
diff --git a/metagpt/software_company.py b/metagpt/software_company.py
index b2bd18c58..d44a0068a 100644
--- a/metagpt/software_company.py
+++ b/metagpt/software_company.py
@@ -5,58 +5,9 @@
@Author : alexanderwu
@File : software_company.py
"""
-from pydantic import BaseModel, Field
+from metagpt.team import Team as SoftwareCompany
-from metagpt.actions import BossRequirement
-from metagpt.config import CONFIG
-from metagpt.environment import Environment
-from metagpt.logs import logger
-from metagpt.roles import Role
-from metagpt.schema import Message
-from metagpt.utils.common import NoMoneyException
-
-
-class SoftwareCompany(BaseModel):
- """
- Software Company: Possesses a team, SOP (Standard Operating Procedures), and a platform for instant messaging,
- dedicated to writing executable code.
- """
- environment: Environment = Field(default_factory=Environment)
- investment: float = Field(default=10.0)
- idea: str = Field(default="")
-
- class Config:
- arbitrary_types_allowed = True
-
- def hire(self, roles: list[Role]):
- """Hire roles to cooperate"""
- self.environment.add_roles(roles)
-
- def invest(self, investment: float):
- """Invest company. raise NoMoneyException when exceed max_budget."""
- self.investment = investment
- CONFIG.max_budget = investment
- logger.info(f'Investment: ${investment}.')
-
- def _check_balance(self):
- if CONFIG.total_cost > CONFIG.max_budget:
- raise NoMoneyException(CONFIG.total_cost, f'Insufficient funds: {CONFIG.max_budget}')
-
- def start_project(self, idea):
- """Start a project from publishing boss requirement."""
- self.idea = idea
- self.environment.publish_message(Message(role="BOSS", content=idea, cause_by=BossRequirement))
-
- def _save(self):
- logger.info(self.json())
-
- async def run(self, n_round=3):
- """Run company until target round or no money"""
- while n_round > 0:
- # self._save()
- n_round -= 1
- logger.debug(f"{n_round=}")
- self._check_balance()
- await self.environment.run()
- return self.environment.history
-
\ No newline at end of file
+import warnings
+warnings.warn("metagpt.software_company is deprecated and will be removed in the future"
+ "Please use metagpt.team instead. SoftwareCompany class is now named as Team.",
+ DeprecationWarning, 2)
diff --git a/metagpt/team.py b/metagpt/team.py
new file mode 100644
index 000000000..67d3ecec8
--- /dev/null
+++ b/metagpt/team.py
@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time : 2023/5/12 00:30
+@Author : alexanderwu
+@File : software_company.py
+"""
+from pydantic import BaseModel, Field
+
+from metagpt.actions import BossRequirement
+from metagpt.config import CONFIG
+from metagpt.environment import Environment
+from metagpt.logs import logger
+from metagpt.roles import Role
+from metagpt.schema import Message
+from metagpt.utils.common import NoMoneyException
+
+
+class Team(BaseModel):
+ """
+ Team: Possesses one or more roles (agents), SOP (Standard Operating Procedures), and a platform for instant messaging,
+ dedicated to perform any multi-agent activity, such as collaboratively writing executable code.
+ """
+ environment: Environment = Field(default_factory=Environment)
+ investment: float = Field(default=10.0)
+ idea: str = Field(default="")
+
+ class Config:
+ arbitrary_types_allowed = True
+
+ def hire(self, roles: list[Role]):
+ """Hire roles to cooperate"""
+ self.environment.add_roles(roles)
+
+ def invest(self, investment: float):
+ """Invest company. raise NoMoneyException when exceed max_budget."""
+ self.investment = investment
+ CONFIG.max_budget = investment
+ logger.info(f'Investment: ${investment}.')
+
+ def _check_balance(self):
+ if CONFIG.total_cost > CONFIG.max_budget:
+ raise NoMoneyException(CONFIG.total_cost, f'Insufficient funds: {CONFIG.max_budget}')
+
+ def start_project(self, idea, send_to: str = ""):
+ """Start a project from publishing boss requirement."""
+ self.idea = idea
+ self.environment.publish_message(Message(role="Human", content=idea, cause_by=BossRequirement, send_to=send_to))
+
+ def _save(self):
+ logger.info(self.json())
+
+ async def run(self, n_round=3):
+ """Run company until target round or no money"""
+ while n_round > 0:
+ # self._save()
+ n_round -= 1
+ logger.debug(f"{n_round=}")
+ self._check_balance()
+ await self.environment.run()
+ return self.environment.history
+
\ No newline at end of file
diff --git a/metagpt/utils/mermaid.py b/metagpt/utils/mermaid.py
index 5e5b275b0..204c22c67 100644
--- a/metagpt/utils/mermaid.py
+++ b/metagpt/utils/mermaid.py
@@ -34,7 +34,10 @@ async def mermaid_to_file(mermaid_code, output_file_without_suffix, width=2048,
engine = CONFIG.mermaid_engine.lower()
if engine == "nodejs":
if check_cmd_exists(CONFIG.mmdc) != 0:
- logger.warning("RUN `npm install -g @mermaid-js/mermaid-cli` to install mmdc")
+ logger.warning(
+ "RUN `npm install -g @mermaid-js/mermaid-cli` to install mmdc,"
+ "or consider changing MERMAID_ENGINE to `playwright`, `pyppeteer`, or `ink`."
+ )
return -1
for suffix in ["pdf", "svg", "png"]:
diff --git a/metagpt/utils/token_counter.py b/metagpt/utils/token_counter.py
index a5a65803a..1af96f272 100644
--- a/metagpt/utils/token_counter.py
+++ b/metagpt/utils/token_counter.py
@@ -22,6 +22,7 @@ TOKEN_COSTS = {
"gpt-4-32k-0314": {"prompt": 0.06, "completion": 0.12},
"gpt-4-0613": {"prompt": 0.06, "completion": 0.12},
"text-embedding-ada-002": {"prompt": 0.0004, "completion": 0.0},
+ "chatglm_turbo": {"prompt": 0.0, "completion": 0.00069} # 32k version, prompt + completion tokens=0.005￥/k-tokens
}
@@ -37,6 +38,7 @@ TOKEN_MAX = {
"gpt-4-32k-0314": 32768,
"gpt-4-0613": 8192,
"text-embedding-ada-002": 8192,
+ "chatglm_turbo": 32768
}
@@ -68,7 +70,9 @@ def count_message_tokens(messages, model="gpt-3.5-turbo-0613"):
return count_message_tokens(messages, model="gpt-4-0613")
else:
raise NotImplementedError(
- f"""num_tokens_from_messages() is not implemented for model {model}. See https://github.com/openai/openai-python/blob/main/chatml.md for information on how messages are converted to tokens."""
+ f"num_tokens_from_messages() is not implemented for model {model}. "
+ f"See https://github.com/openai/openai-python/blob/main/chatml.md "
+ f"for information on how messages are converted to tokens."
)
num_tokens = 0
for message in messages:
diff --git a/requirements.txt b/requirements.txt
index 093298775..f0169d7fa 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -14,7 +14,7 @@ langchain==0.0.231
loguru==0.6.0
meilisearch==0.21.0
numpy==1.24.3
-openai
+openai>=0.28.0
openpyxl
beautifulsoup4==4.12.2
pandas==2.0.3
@@ -44,3 +44,4 @@ ta==0.10.2
semantic-kernel==0.3.13.dev0
wrapt==1.15.0
websocket-client==0.58.0
+zhipuai==1.0.7
diff --git a/setup.py b/setup.py
index f9ae768e6..239156ae3 100644
--- a/setup.py
+++ b/setup.py
@@ -30,16 +30,16 @@ with open(path.join(here, "requirements.txt"), encoding="utf-8") as f:
setup(
name="metagpt",
- version="0.1",
+ version="0.3.0",
description="The Multi-Role Meta Programming Framework",
long_description=long_description,
long_description_content_type="text/markdown",
- url="https://gitlab.deepwisdomai.com/pub/metagpt",
+ url="https://github.com/geekan/MetaGPT",
author="Alexander Wu",
author_email="alexanderwu@fuzhi.ai",
license="Apache 2.0",
keywords="metagpt multi-role multi-agent programming gpt llm",
- packages=find_packages(exclude=["contrib", "docs", "examples"]),
+ packages=find_packages(exclude=["contrib", "docs", "examples", "tests*"]),
python_requires=">=3.9",
install_requires=requirements,
extras_require={
diff --git a/startup.py b/startup.py
index e2a903c9b..e9fbf94d3 100644
--- a/startup.py
+++ b/startup.py
@@ -11,7 +11,7 @@ from metagpt.roles import (
ProjectManager,
QaEngineer,
)
-from metagpt.software_company import SoftwareCompany
+from metagpt.team import Team
async def startup(
@@ -23,7 +23,7 @@ async def startup(
implement: bool = True,
):
"""Run a startup. Be a boss."""
- company = SoftwareCompany()
+ company = Team()
company.hire(
[
ProductManager(),
diff --git a/tests/metagpt/provider/test_openai.py b/tests/metagpt/provider/test_openai.py
new file mode 100644
index 000000000..2b0af37b5
--- /dev/null
+++ b/tests/metagpt/provider/test_openai.py
@@ -0,0 +1,80 @@
+import pytest
+
+from metagpt.provider.openai_api import OpenAIGPTAPI
+from metagpt.schema import UserMessage
+
+
+@pytest.mark.asyncio
+async def test_aask_code():
+ llm = OpenAIGPTAPI()
+ msg = [{"role": "user", "content": "Write a python hello world code."}]
+ rsp = await llm.aask_code(msg) # -> {'language': 'python', 'code': "print('Hello, World!')"}
+ assert "language" in rsp
+ assert "code" in rsp
+ assert len(rsp["code"]) > 0
+
+
+@pytest.mark.asyncio
+async def test_aask_code_str():
+ llm = OpenAIGPTAPI()
+ msg = "Write a python hello world code."
+ rsp = await llm.aask_code(msg) # -> {'language': 'python', 'code': "print('Hello, World!')"}
+ assert "language" in rsp
+ assert "code" in rsp
+ assert len(rsp["code"]) > 0
+
+
+@pytest.mark.asyncio
+async def test_aask_code_Message():
+ llm = OpenAIGPTAPI()
+ msg = UserMessage("Write a python hello world code.")
+ rsp = await llm.aask_code(msg) # -> {'language': 'python', 'code': "print('Hello, World!')"}
+ assert "language" in rsp
+ assert "code" in rsp
+ assert len(rsp["code"]) > 0
+
+
+def test_ask_code():
+ llm = OpenAIGPTAPI()
+ msg = [{"role": "user", "content": "Write a python hello world code."}]
+ rsp = llm.ask_code(msg) # -> {'language': 'python', 'code': "print('Hello, World!')"}
+ assert "language" in rsp
+ assert "code" in rsp
+ assert len(rsp["code"]) > 0
+
+
+def test_ask_code_str():
+ llm = OpenAIGPTAPI()
+ msg = "Write a python hello world code."
+ rsp = llm.ask_code(msg) # -> {'language': 'python', 'code': "print('Hello, World!')"}
+ assert "language" in rsp
+ assert "code" in rsp
+ assert len(rsp["code"]) > 0
+
+
+def test_ask_code_Message():
+ llm = OpenAIGPTAPI()
+ msg = UserMessage("Write a python hello world code.")
+ rsp = llm.ask_code(msg) # -> {'language': 'python', 'code': "print('Hello, World!')"}
+ assert "language" in rsp
+ assert "code" in rsp
+ assert len(rsp["code"]) > 0
+
+
+def test_ask_code_list_Message():
+ llm = OpenAIGPTAPI()
+ msg = [UserMessage("a=[1,2,5,10,-10]"), UserMessage("写出求a中最大值的代码python")]
+ rsp = llm.ask_code(msg) # -> {'language': 'python', 'code': 'max_value = max(a)\nmax_value'}
+ assert "language" in rsp
+ assert "code" in rsp
+ assert len(rsp["code"]) > 0
+
+
+def test_ask_code_list_str():
+ llm = OpenAIGPTAPI()
+ msg = ["a=[1,2,5,10,-10]", "写出求a中最大值的代码python"]
+ rsp = llm.ask_code(msg) # -> {'language': 'python', 'code': 'max_value = max(a)\nmax_value'}
+ print(rsp)
+ assert "language" in rsp
+ assert "code" in rsp
+ assert len(rsp["code"]) > 0
diff --git a/tests/metagpt/provider/test_zhipuai_api.py b/tests/metagpt/provider/test_zhipuai_api.py
new file mode 100644
index 000000000..6a0c70de5
--- /dev/null
+++ b/tests/metagpt/provider/test_zhipuai_api.py
@@ -0,0 +1,47 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# @Desc : the unittest of ZhiPuAIGPTAPI
+
+import pytest
+
+from metagpt.provider.zhipuai_api import ZhiPuAIGPTAPI
+
+
+default_resp = {
+ "code": 200,
+ "data": {
+ "choices": [
+ {"role": "assistant", "content": "I'm chatglm-turbo"}
+ ]
+ }
+}
+
+messages = [
+ {"role": "user", "content": "who are you"}
+]
+
+
+def mock_llm_ask(self, messages: list[dict]) -> dict:
+ return default_resp
+
+
+def test_zhipuai_completion(mocker):
+ mocker.patch("metagpt.provider.zhipuai_api.ZhiPuAIGPTAPI.completion", mock_llm_ask)
+
+ resp = ZhiPuAIGPTAPI().completion(messages)
+ assert resp["code"] == 200
+ assert "chatglm-turbo" in resp["data"]["choices"][0]["content"]
+
+
+async def mock_llm_aask(self, messgaes: list[dict], stream: bool = False) -> dict:
+ return default_resp
+
+
+@pytest.mark.asyncio
+async def test_zhipuai_acompletion(mocker):
+ mocker.patch("metagpt.provider.zhipuai_api.ZhiPuAIGPTAPI.acompletion_text", mock_llm_aask)
+
+ resp = await ZhiPuAIGPTAPI().acompletion_text(messages, stream=False)
+
+ assert resp["code"] == 200
+ assert "chatglm-turbo" in resp["data"]["choices"][0]["content"]
diff --git a/tests/metagpt/roles/test_ui.py b/tests/metagpt/roles/test_ui.py
index 285bff323..d58d31bd9 100644
--- a/tests/metagpt/roles/test_ui.py
+++ b/tests/metagpt/roles/test_ui.py
@@ -2,7 +2,7 @@
# @Date : 2023/7/22 02:40
# @Author : stellahong (stellahong@fuzhi.ai)
#
-from metagpt.software_company import SoftwareCompany
+from metagpt.team import Team
from metagpt.roles import ProductManager
from tests.metagpt.roles.ui_role import UI
@@ -15,7 +15,7 @@ def test_add_ui():
async def test_ui_role(idea: str, investment: float = 3.0, n_round: int = 5):
"""Run a startup. Be a boss."""
- company = SoftwareCompany()
+ company = Team()
company.hire([ProductManager(), UI()])
company.invest(investment)
company.start_project(idea)
diff --git a/tests/metagpt/test_software_company.py b/tests/metagpt/test_software_company.py
index 00538442c..4fc651f52 100644
--- a/tests/metagpt/test_software_company.py
+++ b/tests/metagpt/test_software_company.py
@@ -8,12 +8,12 @@
import pytest
from metagpt.logs import logger
-from metagpt.software_company import SoftwareCompany
+from metagpt.team import Team
@pytest.mark.asyncio
-async def test_software_company():
- company = SoftwareCompany()
+async def test_team():
+ company = Team()
company.start_project("做一个基础搜索引擎，可以支持知识库")
history = await company.run(n_round=5)
logger.info(history)
-
+
