[WIP]Feauture/parallel

backend/AgentConfig.py

@@ -6,6 +6,12 @@
 from langchain.schema import SystemMessage, HumanMessage
 from langchain.chat_models import ChatOpenAI
 
+from PipedLLM import PipedLLM
+api_keys = json.loads(os.environ.get("OPENAI_API_KEYS", "[]"))
+if len(api_keys) == 0:
+    raise ValueError('No OpenAI API keys provided. OPENAI_API_KEYS=["sk-xxx", "sk-yyy"]')
+piped = PipedLLM(api_keys)
+
 class Agent:
     def __init__(self, id, name, principles, max_retry_times=5, chat_model='GPT3.5'):
         self.id = id
@@ -16,31 +22,6 @@ def __init__(self, id, name, principles, max_retry_times=5, chat_model='GPT3.5')
         self.max_retry_times = max_retry_times
         self.retry_times = max_retry_times
         self.reset()
-        if chat_model == 'GPT3.5':
-            self.chat_model = ChatOpenAI(
-                temperature=0, openai_api_key=os.environ.get("OPENAI_API_KEY"), max_tokens=1500, request_timeout=360)
-        elif chat_model == 'GPT4':
-            self.chat_model = ChatOpenAI(
-                temperature=0, openai_api_key=os.environ.get("OPENAI_API_KEY"), max_tokens=1500, request_timeout=360,
-                model_name="gpt-4")
-        elif chat_model == 'Claude':
-            from langchain.chat_models import ChatAnthropic
-            from langchain.prompts.chat import (
-                ChatPromptTemplate,
-                SystemMessagePromptTemplate,
-                AIMessagePromptTemplate,
-                HumanMessagePromptTemplate,
-            )
-            from langchain.schema import (
-                AIMessage,
-                HumanMessage,
-                SystemMessage
-            )
-            # os.environ.get("ANTHROPIC_API_KEY")
-            self.chat_model = ChatAnthropic(temperature=0, anthropic_api_key=os.environ.get("ANTHROPIC_API_KEY"))
-        else:
-            raise NotImplementedError(
-                f"Chat model {chat_model} not implemented.")
         self.instruction = self.get_instruction()
         self.error_message = self.get_error_message()
 
@@ -218,7 +199,7 @@ def take_action(self, surroundings, allowed_actions, stamina, wealth):
             surroundings=formmatted_surroundings, stamina=stamina, wealth=wealth, allowed_actions=allowed_actions)
         self.message_history.extend(_input.to_messages())
 
-        _output = self.chat_model(self.message_history)
+        _output = piped.put(self.message_history).result()
         json_string = _output.content.split("```json")[-1].strip().replace('```', '')
         # print(f"json_string: {json_string}")
         output = json.loads(json_string)

backend/PipedLLM.py

@@ -0,0 +1,61 @@
+import os
+import concurrent.futures
+
+import time
+from langchain.chat_models import ChatOpenAI
+
+class PipedLLM:
+    def __init__(self, api_keys, chat_model='GPT3.5'):
+        self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=len(api_keys))
+        self.api_keys = api_keys
+        self.used = {key: False for key in api_keys}
+
+        self.chat_models = {}
+
+        for key in api_keys:
+            if chat_model == 'GPT3.5':
+                self.chat_models[key] = ChatOpenAI(
+                    temperature=0, openai_api_key=key, max_tokens=1500, request_timeout=360)
+            elif chat_model == 'GPT4':
+                self.chat_models[key] = ChatOpenAI(
+                    temperature=0, openai_api_key=key, max_tokens=1500, request_timeout=360,
+                    model_name="gpt-4")
+            elif chat_model == 'Claude':
+                from langchain.chat_models import ChatAnthropic
+                from langchain.prompts.chat import (
+                    ChatPromptTemplate,
+                    SystemMessagePromptTemplate,
+                    AIMessagePromptTemplate,
+                    HumanMessagePromptTemplate,
+                )
+                from langchain.schema import (
+                    AIMessage,
+                    HumanMessage,
+                    SystemMessage
+                )
+                self.chat_models[key] = ChatAnthropic(temperature=0, anthropic_api_key=key)
+            else:
+                raise NotImplementedError(
+                    f"Chat model {chat_model} not implemented.")
+
+    def get_unused_key(self):
+        while True:
+            for key, used in self.used.items():
+                if not used:
+                    self.used[key] = True
+                    return key
+            time.sleep(0.1)
+
+    def release_key(self, key):
+        self.used[key] = False
+
+    def put(self, message):
+        key = self.get_unused_key()
+        future = self.executor.submit(self.request, message, key)
+        return future
+
+    def request(self, message, key):
+        result = self.chat_models[key](message)
+        self.release_key(key)
+        return result
+

backend/app.py

@@ -45,6 +45,15 @@ def post(self):
             "hash": ret,
         }
 
+# start_llm
+@api.route("/start_llm/<string:team>")
+class StartGameByTeam(Resource):
+    def post(self, team):
+        ret = web3Game.start_llm_by_team(team)
+        return {
+            "hash": ret,
+        }
+
 
 # transfer ownership of the gameplay contract
 # onlyOwner

backend/conf/sample.env

@@ -1,3 +1,3 @@
-OPENAI_API_KEY=<your secret key>
+OPENAI_API_KEYS=["sk-XXXXXXXXXXXXXXXXXXXXX", "sk-YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY"]
 NODE_URL=<~~~>
 PRIVATE_KEY=<~~~>

backend/web3game.py

@@ -157,6 +157,42 @@ def start_llm(self):
                     target_id = int(t.split("(")[1].replace(")", "").strip())
                     self.attack(agent_id, target_id)
 
+    # _team: 'A' or 'B'
+    def start_llm_by_team(self, _team):
+        team = _team + '-'
+        for _ in range(10): #define max number of round
+            unfiltered_agent_list = self.get_explorers_list()
+            agent_list = list(filter(lambda x: team in x['name'], unfiltered_agent_list))
+            for agent in agent_list:
+                agent_id = agent['id']
+                surroundings = self.get_surroundings(agent_id)
+                allowed_actions = self.get_allowed_actions(agent_id)
+                if allowed_actions is None:
+                    # maybe dead
+                    continue
+                explorer = self.get_agent(agent_id)
+                action = self.agent_list[agent_id].take_action(surroundings, allowed_actions, explorer['stamina'], explorer['wealth'])
+                if action is None:
+                    # I don't know why, but I'm handling it because it sometimes turns out to be none.
+                    # Better than falling off.
+                    continue
+                elif 'move' in action:
+                    _, direction = action.split(" ")
+                    self.move(agent_id, direction)
+                elif 'gather' in action:
+                    self.gather_wealth(agent_id)
+                elif 'rest' in action:
+                    self.rest(agent_id)
+                elif 'attack' in action:
+                    _, t = action.split(" ")
+                    # target_id = 0
+                    # for i in self.agent_list.keys():
+                    #     if self.agent_list[i].name.lower() == t.lower():
+                    #         target_id = i
+                    #         break
+                    target_id = int(t.split("(")[1].replace(")", "").strip())
+                    self.attack(agent_id, target_id)
+
     # move explorer
     # onlyOwner
     # agent_id: uint256

frontend/src/Game.js

@@ -1,5 +1,5 @@
 import axios from "axios";
-import { useState } from "react";
+import { useState, useMemo } from "react";
 import "./Game.css";
 
 axios.defaults.baseURL = "http://localhost:8080";
@@ -94,22 +94,35 @@ export default function Game() {
   const [modules, setModules] = useState(DEFAULT_MODULE);
   const [agents, setAgents] = useState(DEFAULT_AGENTS);
 
+  const team = useMemo(() => {
+    const queryString = window.location.search;
+
+    const params = new URLSearchParams(queryString);
+    return params.get('team')
+  }, [window.location.search])
+
   const handleStartGame = async () => {
     setMessage("Starting the game ...");
-
-    await axios.post("/start_game/", {
-      size,
-      num_wealth: numWealth,
-      agent_list: agents,
-      module_list: modules
-    });
+    if (team === 'A') {
+      await axios.post("/start_game/", {
+        size,
+        num_wealth: numWealth,
+        agent_list: agents,
+        module_list: modules
+      });
+    }
     setAgents([]);
     setMessage("Successfully started the game!");
 
     setTimeout(() => setGameStarted(true), 1000);
     setTimeout(() => setMessage(null), 5000);
 
-    axios.post("/start_llm/").catch();
+    if (team === 'A' || team === 'B') {
+      axios.post(`/start_llm/${team}`).catch();
+    } else {
+      axios.post("/start_llm/").catch();
+    }
+
     setAgents(DEFAULT_AGENTS);
     setInterval(() => {
       axios