init

.gitignore

@@ -0,0 +1,27 @@
+# Compiled python files
+*.pyc
+
+# Compiled C extensions
+*.so
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+
+# IDE / editor files
+.idea/
+*.swp
+*~
+
+# Virtual environment
+venv/
+env/
+
+__pycache__/
+.vscode/
+.DS_Store
+
+cache/
+
+secret_keys_mine.sh

app.py

@@ -0,0 +1,238 @@
+import gradio as gr
+import sys
+# sys.path.append('./inference/')
+import bmtools
+from bmtools.agent.tools_controller import MTQuestionAnswerer, load_valid_tools
+from bmtools.agent.singletool import STQuestionAnswerer
+from langchain.schema import AgentFinish
+import os
+import requests
+from threading import Thread
+from multiprocessing import Process
+import time
+
+available_models = ["ChatGPT", "GPT-3.5"]
+DEFAULTMODEL = "GPT-3.5"
+
+tools_mappings = {
+    "klarna": "https://www.klarna.com/",
+    "chemical-prop": "http://127.0.0.1:8079/tools/chemical-prop/",
+    "wolframalpha": "http://127.0.0.1:8079/tools/wolframalpha/",
+    "weather": "http://127.0.0.1:8079/tools/weather/",
+    "douban-film": "http://127.0.0.1:8079/tools/douban-film/",
+    "wikipedia": "http://127.0.0.1:8079/tools/wikipedia/",
+    "office-ppt": "http://127.0.0.1:8079/tools/office-ppt/",
+    "bing_search": "http://127.0.0.1:8079/tools/bing_search/",
+    "map": "http://127.0.0.1:8079/tools/map/",
+    "stock": "http://127.0.0.1:8079/tools/stock/",
+    "baidu-translation": "http://127.0.0.1:8079/tools/baidu-translation/",
+    "nllb-translation": "http://127.0.0.1:8079/tools/nllb-translation/",
+}
+
+valid_tools_info = {}
+all_tools_list = []
+
+gr.close_all()
+
+MAX_TURNS = 30
+MAX_BOXES = MAX_TURNS * 2
+
+return_msg = []
+chat_history = ""
+
+tool_server_flag = False
+
+def run_tool_server():
+    def run_server():
+        server = bmtools.ToolServer()
+        # server.load_tool("chemical-prop")
+        server.load_tool("douban-film")
+        # server.load_tool("weather")
+        # server.load_tool("wikipedia")
+        # server.load_tool("wolframalpha")
+        # server.load_tool("bing_search")
+        # server.load_tool("office-ppt")
+        # server.load_tool("stock")
+        # server.load_tool("map")
+        # server.load_tool("nllb-translation")
+        # server.load_tool("baidu-translation")
+        # server.load_tool("tutorial")
+        server.serve()
+    # server = Thread(target=run_server)
+    server = Process(target=run_server)
+    server.start()
+    global tool_server_flag
+    tool_server_flag = True
+
+def load_tools():
+    global valid_tools_info
+    global all_tools_list
+    valid_tools_info = load_valid_tools(tools_mappings)
+    all_tools_list = sorted(list(valid_tools_info.keys()))
+    return gr.update(choices=all_tools_list)
+
+def set_environ(OPENAI_API_KEY: str,
+                WOLFRAMALPH_APP_ID: str = "",
+                WEATHER_API_KEYS: str = "",
+                BING_SUBSCRIPT_KEY: str = "",
+                ALPHA_VANTAGE_KEY: str = "",
+                BING_MAP_KEY: str = "",
+                BAIDU_TRANSLATE_KEY: str = "",
+                BAIDU_SECRET_KEY: str = "") -> str:
+    os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+    os.environ["WOLFRAMALPH_APP_ID"] = WOLFRAMALPH_APP_ID
+    os.environ["WEATHER_API_KEYS"] = WEATHER_API_KEYS
+    os.environ["BING_SUBSCRIPT_KEY"] = BING_SUBSCRIPT_KEY
+    os.environ["ALPHA_VANTAGE_KEY"] = ALPHA_VANTAGE_KEY
+    os.environ["BING_MAP_KEY"] = BING_MAP_KEY
+    os.environ["BAIDU_TRANSLATE_KEY"] = BAIDU_TRANSLATE_KEY
+    os.environ["BAIDU_SECRET_KEY"] = BAIDU_SECRET_KEY
+    if not tool_server_flag:
+        run_tool_server()
+        time.sleep(10)
+    return gr.update(value="OK!")
+
+def show_avatar_imgs(tools_chosen):
+    if len(tools_chosen) == 0:
+        tools_chosen = list(valid_tools_info.keys())
+    img_template = '<a href="{}" style="float: left"> <img style="margin:5px" src="{}.png" width="24" height="24" alt="avatar" /> {} </a>'
+    imgs = [valid_tools_info[tool]['avatar'] for tool in tools_chosen if valid_tools_info[tool]['avatar'] != None]
+    imgs = ' '.join([img_template.format(img, img, tool ) for img, tool in zip(imgs, tools_chosen) ])
+    return [gr.update(value='<span class="">'+imgs+'</span>', visible=True), gr.update(visible=True)]
+
+def answer_by_tools(question, tools_chosen, model_chosen):
+    global return_msg
+    return_msg += [(question, None), (None, '...')]
+    yield [gr.update(visible=True, value=return_msg), gr.update(), gr.update()]
+    OPENAI_API_KEY = os.environ.get('OPENAI_API_KEY', '')
+
+    if len(tools_chosen) == 0:  # if there is no tools chosen, we use all todo (TODO: What if the pool is too large.)
+        tools_chosen = list(valid_tools_info.keys())
+
+    if len(tools_chosen) == 1:
+        answerer = STQuestionAnswerer(OPENAI_API_KEY.strip(), stream_output=True, llm=model_chosen)
+        agent_executor = answerer.load_tools(tools_chosen[0], valid_tools_info[tools_chosen[0]], prompt_type="react-with-tool-description", return_intermediate_steps=True)
+    else:
+        answerer = MTQuestionAnswerer(OPENAI_API_KEY.strip(), load_valid_tools({k: tools_mappings[k] for k in tools_chosen}), stream_output=True, llm=model_chosen)
+
+        agent_executor = answerer.build_runner()
+
+    global chat_history
+    chat_history += "Question: " + question + "\n"
+    question = chat_history
+    for inter in agent_executor(question):
+        if isinstance(inter, AgentFinish): continue
+        result_str = []
+        return_msg.pop()
+        if isinstance(inter, dict):
+            result_str.append("<font color=red>Answer:</font> {}".format(inter['output']))
+            chat_history += "Answer:" + inter['output'] + "\n"
+            result_str.append("...")
+        else:
+            not_observation = inter[0].log
+            if not not_observation.startswith('Thought:'):
+                not_observation = "Thought: " + not_observation
+            chat_history += not_observation
+            not_observation = not_observation.replace('Thought:', '<font color=green>Thought: </font>')
+            not_observation = not_observation.replace('Action:', '<font color=purple>Action: </font>')
+            not_observation = not_observation.replace('Action Input:', '<font color=purple>Action Input: </font>')
+            result_str.append("{}".format(not_observation))
+            result_str.append("<font color=blue>Action output:</font>\n{}".format(inter[1]))
+            chat_history += "\nAction output:" + inter[1] + "\n"
+            result_str.append("...")
+        return_msg += [(None, result) for result in result_str]
+        yield [gr.update(visible=True, value=return_msg), gr.update(), gr.update()]
+    return_msg.pop()
+    if return_msg[-1][1].startswith("<font color=red>Answer:</font> "):
+        return_msg[-1] = (return_msg[-1][0], return_msg[-1][1].replace("<font color=red>Answer:</font> ", "<font color=green>Final Answer:</font> "))
+    yield [gr.update(visible=True, value=return_msg), gr.update(visible=True), gr.update(visible=False)]
+
+def retrieve(tools_search):
+    if tools_search == "":
+        return gr.update(choices=all_tools_list)
+    else:
+        url = "http://127.0.0.1:8079/retrieve"
+        param = {
+            "query": tools_search
+        }
+        response = requests.post(url, json=param)
+        result = response.json()
+        retrieved_tools = result["tools"]
+        return gr.update(choices=retrieved_tools)
+
+def clear_history():
+    global return_msg
+    global chat_history
+    return_msg = []
+    chat_history = ""
+    yield gr.update(visible=True, value=return_msg)
+
+with gr.Blocks() as demo:
+    with gr.Row():
+        with gr.Column(scale=14):
+            gr.Markdown("<h1 align='left'> BMTools </h1>")
+        with gr.Column(scale=1):
+            gr.Markdown('<img src="https://openbmb.cn/openbmb/img/head_logo.e9d9f3f.png" width="140">')
+    with gr.Row():
+        with gr.Column(scale=1):
+            OPENAI_API_KEY = gr.Textbox(label="OpenAI API KEY:", placeholder="sk-...", type="text")
+            # WOLFRAMALPH_APP_ID = gr.Textbox(label="WOLFRAMALPH APP ID:", type="text")
+            # WEATHER_API_KEYS = gr.Textbox(label="WEATHER API KEYS:", type="text")
+            # BING_SUBSCRIPT_KEY = gr.Textbox(label="BING SUBSCRIPT KEY:", type="text")
+            # ALPHA_VANTAGE_KEY = gr.Textbox(label="ALPHA VANTAGE KEY:", type="text")
+            # BING_MAP_KEY = gr.Textbox(label="BING MAP KEY:", type="text")
+            # BAIDU_TRANSLATE_KEY = gr.Textbox(label="BAIDU TRANSLATE KEY:", type="text")
+            # BAIDU_SECRET_KEY = gr.Textbox(label="BAIDU SECRET KEY:", type="text")
+            key_set_btn = gr.Button(value="Set")
+
+        with gr.Column(scale=4):
+            with gr.Row():
+                with gr.Column(scale=0.85):
+                    txt = gr.Textbox(show_label=False, placeholder="Question here. Use Shift+Enter to add new line.", lines=1).style(container=False)
+                with gr.Column(scale=0.15, min_width=0):
+                    buttonClear = gr.Button("Clear History")
+                    buttonStop = gr.Button("Stop", visible=False)
+
+            chatbot = gr.Chatbot(show_label=False, visible=True).style(height=600)
+
+        with gr.Column(scale=1):
+            with gr.Column():
+                tools_search = gr.Textbox(
+                    lines=1,
+                    label="Tools Search",
+                    info="Please input some text to search tools.",
+                )
+                buttonSearch = gr.Button("Clear")
+                tools_chosen = gr.CheckboxGroup(
+                    choices=all_tools_list,
+                    value=["chemical-prop"],
+                    label="Tools provided",
+                    info="Choose the tools to solve your question.",
+                )
+                model_chosen = gr.Dropdown(
+                    list(available_models), value=DEFAULTMODEL, multiselect=False, label="Model provided", info="Choose the model to solve your question, Default means ChatGPT."
+                )
+
+
+
+    key_set_btn.click(fn=set_environ, inputs=[
+            OPENAI_API_KEY,
+            # WOLFRAMALPH_APP_ID,
+            # WEATHER_API_KEYS,
+            # BING_SUBSCRIPT_KEY,
+            # ALPHA_VANTAGE_KEY,
+            # BING_MAP_KEY,
+            # BAIDU_TRANSLATE_KEY,
+            # BAIDU_SECRET_KEY
+        ], outputs=key_set_btn)
+    key_set_btn.click(fn=load_tools, outputs=tools_chosen)
+
+    tools_search.change(retrieve, tools_search, tools_chosen)
+    buttonSearch.click(lambda : [gr.update(value=""), gr.update(choices=all_tools_list)], [], [tools_search, tools_chosen])
+
+    txt.submit(lambda : [gr.update(value=''), gr.update(visible=False), gr.update(visible=True)], [], [txt, buttonClear, buttonStop])
+    inference_event = txt.submit(answer_by_tools, [txt, tools_chosen, model_chosen], [chatbot, buttonClear, buttonStop])
+    buttonStop.click(lambda : [gr.update(visible=True), gr.update(visible=False)], [], [buttonClear, buttonStop], cancels=[inference_event])
+    buttonClear.click(clear_history, [], chatbot)
+
+demo.queue().launch(share=False, inbrowser=True, server_name="127.0.0.1", server_port=7001)

bmtools/__init__.py

@@ -0,0 +1,2 @@
+from .tools.serve import ToolServer
+from .utils.logging import get_logger

bmtools/agent/BabyagiTools.py

@@ -0,0 +1,317 @@
+from collections import deque
+from typing import Dict, List, Optional, Any
+import re
+
+from langchain import LLMChain, OpenAI, PromptTemplate, SerpAPIWrapper
+from langchain.embeddings import OpenAIEmbeddings
+from langchain.llms import BaseLLM
+from langchain.vectorstores.base import VectorStore
+from pydantic import BaseModel, Field
+from langchain.chains.base import Chain
+
+from langchain.vectorstores import FAISS
+import faiss
+from langchain.docstore import InMemoryDocstore
+from langchain.agents import ZeroShotAgent, Tool, AgentExecutor
+from bmtools.agent.executor import Executor, AgentExecutorWithTranslation
+
+class ContextAwareAgent(ZeroShotAgent):
+    def get_full_inputs(
+        self, intermediate_steps, **kwargs: Any
+    ) -> Dict[str, Any]:
+        """Create the full inputs for the LLMChain from intermediate steps."""
+        thoughts = self._construct_scratchpad(intermediate_steps)
+        new_inputs = {"agent_scratchpad": thoughts, "stop": self._stop}
+        full_inputs = {**kwargs, **new_inputs}
+        return full_inputs
+    
+    def _construct_scratchpad(self, intermediate_steps):
+        """Construct the scratchpad that lets the agent continue its thought process."""
+        thoughts = ""
+        # only modify the following line, [-2: ]
+        for action, observation in intermediate_steps[-2: ]:
+            thoughts += action.log
+            thoughts += f"\n{self.observation_prefix}{observation}\n{self.llm_prefix}"
+            if "is not a valid tool, try another one" in observation:
+                thoughts += "You should select another tool rather than the invalid one.\n"
+        return thoughts
+
+class TaskCreationChain(LLMChain):
+    """Chain to generates tasks."""
+
+    @classmethod
+    def from_llm(cls, llm: BaseLLM, verbose: bool = True) -> LLMChain:
+        """Get the response parser."""
+        task_creation_template = (
+            "You are an task creation AI that uses the result of an execution agent"
+            " to create new tasks with the following objective: {objective},"
+            " The last completed task has the result: {result}."
+            " This result was based on this task description: {task_description}."
+            " These are incomplete tasks: {incomplete_tasks}."
+            " Based on the result, create new tasks to be completed"
+            " by the AI system that do not overlap with incomplete tasks."
+            " For a simple objective, do not generate complex todo lists."
+            " Do not generate repetitive tasks (e.g., tasks that have already been completed)."
+            " If there is not futher task needed to complete the objective, return NO TASK."
+            " Now return the tasks as an array."
+        )
+        prompt = PromptTemplate(
+            template=task_creation_template,
+            input_variables=["result", "task_description", "incomplete_tasks", "objective"],
+        )
+        return cls(prompt=prompt, llm=llm, verbose=verbose)
+    
+class InitialTaskCreationChain(LLMChain):
+    """Chain to generates tasks."""
+
+    @classmethod
+    def from_llm(cls, llm: BaseLLM, verbose: bool = True) -> LLMChain:
+        """Get the response parser."""
+        task_creation_template = (
+            "You are a planner who is an expert at coming up with a todo list for a given objective. For a simple objective, do not generate a complex todo list. Generate the first (only one) task needed to do for this objective: {objective}"
+        )
+        prompt = PromptTemplate(
+            template=task_creation_template,
+            input_variables=["objective"],
+        )
+        return cls(prompt=prompt, llm=llm, verbose=verbose)
+    
+class TaskPrioritizationChain(LLMChain):
+    """Chain to prioritize tasks."""
+
+    @classmethod
+    def from_llm(cls, llm: BaseLLM, verbose: bool = True) -> LLMChain:
+        """Get the response parser."""
+        task_prioritization_template = (
+            "You are an task prioritization AI tasked with cleaning the formatting of and reprioritizing"
+            " the following tasks: {task_names}."
+            " Consider the ultimate objective of your team: {objective}."
+            " Do not make up any tasks, just reorganize the existing tasks."
+            " Do not remove any tasks. Return the result as a numbered list, like:"
+            " #. First task"
+            " #. Second task"
+            " Start the task list with number {next_task_id}. (e.g., 2. ***, 3. ***, etc.)"
+        )
+        prompt = PromptTemplate(
+            template=task_prioritization_template,
+            input_variables=["task_names", "next_task_id", "objective"],
+        )
+        return cls(prompt=prompt, llm=llm, verbose=verbose)
+
+def get_next_task(task_creation_chain: LLMChain, result: Dict, task_description: str, task_list: List[str], objective: str) -> List[Dict]:
+    """Get the next task."""
+    incomplete_tasks = ", ".join(task_list)
+    response = task_creation_chain.run(result=result, task_description=task_description, incomplete_tasks=incomplete_tasks, objective=objective)
+    # change the split method to re matching
+    # new_tasks = response.split('\n')
+    task_pattern = re.compile(r'\d+\. (.+?)\n')
+    new_tasks = task_pattern.findall(response)
+
+    return [{"task_name": task_name} for task_name in new_tasks if task_name.strip()]
+
+def prioritize_tasks(task_prioritization_chain: LLMChain, this_task_id: int, task_list: List[Dict], objective: str) -> List[Dict]:
+    """Prioritize tasks."""
+    task_names = [t["task_name"] for t in task_list]
+    next_task_id = int(this_task_id) + 1
+    response = task_prioritization_chain.run(task_names=task_names, next_task_id=next_task_id, objective=objective)
+    new_tasks = response.split('\n')
+    prioritized_task_list = []
+    for task_string in new_tasks:
+        if not task_string.strip():
+            continue
+        task_parts = task_string.strip().split(".", 1)
+        if len(task_parts) == 2:
+            task_id = task_parts[0].strip()
+            task_name = task_parts[1].strip()
+            prioritized_task_list.append({"task_id": task_id, "task_name": task_name})
+    return prioritized_task_list
+
+def _get_top_tasks(vectorstore, query: str, k: int) -> List[str]:
+    """Get the top k tasks based on the query."""
+    results = vectorstore.similarity_search_with_score(query, k=k)
+    if not results:
+        return []
+    sorted_results, _ = zip(*sorted(results, key=lambda x: x[1], reverse=True))
+    return [str(item.metadata['task']) for item in sorted_results]
+
+def execute_task(vectorstore, execution_chain: LLMChain, objective: str, task: str, k: int = 5) -> str:
+    """Execute a task."""
+    context = _get_top_tasks(vectorstore, query=objective, k=k)
+    return execution_chain.run(objective=objective, context=context, task=task)
+
+class BabyAGI(Chain, BaseModel):
+    """Controller model for the BabyAGI agent."""
+
+    task_list: deque = Field(default_factory=deque)
+    task_creation_chain: TaskCreationChain = Field(...)
+    task_prioritization_chain: TaskPrioritizationChain = Field(...)
+    initial_task_creation_chain: InitialTaskCreationChain = Field(...)
+    execution_chain: AgentExecutor = Field(...)
+    task_id_counter: int = Field(1)
+    vectorstore: VectorStore = Field(init=False)
+    max_iterations: Optional[int] = None
+        
+    class Config:
+        """Configuration for this pydantic object."""
+        arbitrary_types_allowed = True
+
+    def add_task(self, task: Dict):
+        self.task_list.append(task)
+
+    def print_task_list(self):
+        print("\033[95m\033[1m" + "\n*****TASK LIST*****\n" + "\033[0m\033[0m")
+        for t in self.task_list:
+            print(str(t["task_id"]) + ": " + t["task_name"])
+
+    def print_next_task(self, task: Dict):
+        print("\033[92m\033[1m" + "\n*****NEXT TASK*****\n" + "\033[0m\033[0m")
+        print(str(task["task_id"]) + ": " + task["task_name"])
+
+    def print_task_result(self, result: str):
+        print("\033[93m\033[1m" + "\n*****TASK RESULT*****\n" + "\033[0m\033[0m")
+        print(result)
+        
+    @property
+    def input_keys(self) -> List[str]:
+        return ["objective"]
+    
+    @property
+    def output_keys(self) -> List[str]:
+        return []
+
+    def _call(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
+        """Run the agent."""
+        # not an elegant implementation, but it works for the first task
+        objective = inputs['objective']
+        first_task = inputs.get("first_task", self.initial_task_creation_chain.run(objective=objective))# self.task_creation_chain.llm(initial_task_prompt))
+
+        self.add_task({"task_id": 1, "task_name": first_task})
+        num_iters = 0
+        while True:
+            if self.task_list:
+                self.print_task_list()
+
+                # Step 1: Pull the first task
+                task = self.task_list.popleft()
+                self.print_next_task(task)
+
+                # Step 2: Execute the task
+                result = execute_task(
+                    self.vectorstore, self.execution_chain, objective, task["task_name"]
+                )
+                this_task_id = int(task["task_id"])
+                self.print_task_result(result)
+
+                # Step 3: Store the result in Pinecone
+                result_id = f"result_{task['task_id']}"
+                self.vectorstore.add_texts(
+                    texts=[result],
+                    metadatas=[{"task": task["task_name"]}],
+                    ids=[result_id],
+                )
+
+                # Step 4: Create new tasks and reprioritize task list
+                new_tasks = get_next_task(
+                    self.task_creation_chain, result, task["task_name"], [t["task_name"] for t in self.task_list], objective
+                )
+                for new_task in new_tasks:
+                    self.task_id_counter += 1
+                    new_task.update({"task_id": self.task_id_counter})
+                    self.add_task(new_task)
+
+                if len(self.task_list) == 0:
+                    print("\033[91m\033[1m" + "\n*****NO TASK, ABORTING*****\n" + "\033[0m\033[0m")
+                    break
+
+                self.task_list = deque(
+                    prioritize_tasks(
+                        self.task_prioritization_chain, this_task_id, list(self.task_list), objective
+                    )
+                )
+            num_iters += 1
+            if self.max_iterations is not None and num_iters == self.max_iterations:
+                print("\033[91m\033[1m" + "\n*****TASK ENDING*****\n" + "\033[0m\033[0m")
+                break
+        return {}
+
+    @classmethod
+    def from_llm(
+        cls,
+        llm: BaseLLM,
+        prompt = None,
+        verbose: bool = False,
+        tools = None,
+        stream_output = None,
+        **kwargs
+    ) -> "BabyAGI":
+        embeddings_model = OpenAIEmbeddings()
+        embedding_size = 1536
+        index = faiss.IndexFlatL2(embedding_size)
+        vectorstore = FAISS(embeddings_model.embed_query, index, InMemoryDocstore({}), {})
+
+        task_creation_chain = TaskCreationChain.from_llm(
+            llm, verbose=verbose
+        )
+        initial_task_creation_chain = InitialTaskCreationChain.from_llm(
+            llm, verbose=verbose
+        )
+        task_prioritization_chain = TaskPrioritizationChain.from_llm(
+            llm, verbose=verbose
+        )
+        llm_chain = LLMChain(llm=llm, prompt=prompt)
+        tool_names = [tool.name for tool in tools]
+        agent = ContextAwareAgent(llm_chain=llm_chain, allowed_tools=tool_names)
+
+        if stream_output:
+            agent_executor = Executor.from_agent_and_tools(agent=agent, tools=tools, verbose=True)
+        else:
+            agent_executor = AgentExecutorWithTranslation.from_agent_and_tools(agent=agent, tools=tools, verbose=True)
+
+        return cls(
+            task_creation_chain=task_creation_chain,
+            task_prioritization_chain=task_prioritization_chain,
+            initial_task_creation_chain=initial_task_creation_chain,
+            execution_chain=agent_executor,
+            vectorstore=vectorstore,
+            **kwargs
+        )
+    
+if __name__ == "__main__":
+    todo_prompt = PromptTemplate.from_template("You are a planner who is an expert at coming up with a todo list for a given objective. For a simple objective, do not generate a complex todo list. Come up with a todo list for this objective: {objective}")
+    todo_chain = LLMChain(llm=OpenAI(temperature=0), prompt=todo_prompt)
+    search = SerpAPIWrapper()
+    tools = [
+        Tool(
+            name = "Search",
+            func=search.run,
+            description="useful for when you need to answer questions about current events"
+        ),
+        Tool(
+            name = "TODO",
+            func=todo_chain.run,
+            description="useful for when you need to come up with todo lists. Input: an objective to create a todo list for. Output: a todo list for that objective. Please be very clear what the objective is!"
+        )
+    ]
+
+    prefix = """You are an AI who performs one task based on the following objective: {objective}. Take into account these previously completed tasks: {context}."""
+    suffix = """Question: {task}
+    {agent_scratchpad}"""
+    prompt = ZeroShotAgent.create_prompt(
+        tools, 
+        prefix=prefix, 
+        suffix=suffix, 
+        input_variables=["objective", "task", "context","agent_scratchpad"]
+    )
+
+    OBJECTIVE = "Write a weather report for SF today"
+    llm = OpenAI(temperature=0)
+    # Logging of LLMChains
+    verbose=False
+    # If None, will keep on going forever
+    max_iterations: Optional[int] = 10
+    baby_agi = BabyAGI.from_llm(
+        llm=llm,
+        verbose=verbose,
+        max_iterations=max_iterations
+    )
+    baby_agi({"objective": OBJECTIVE})

bmtools/agent/apitool.py

@@ -0,0 +1,102 @@
+"""Interface for tools."""
+from inspect import signature
+from typing import Any, Awaitable, Callable, Optional, Union
+
+from langchain.agents import Tool as LangChainTool
+from langchain.tools.base import BaseTool
+import requests
+import json
+import http.client
+http.client._MAXLINE = 655360
+
+from bmtools import get_logger
+
+logger = get_logger(__name__)
+
+class Tool(LangChainTool):
+    tool_logo_md: str = ""
+
+class RequestTool(BaseTool):
+    """Tool that takes in function or coroutine directly."""
+
+    description: str = ""
+    func: Callable[[str], str]
+    coroutine: Optional[Callable[[str], Awaitable[str]]] = None
+    max_output_len = 4000
+    tool_logo_md: str = ""
+
+    def _run(self, tool_input: str) -> str:
+        """Use the tool."""
+        return self.func(tool_input)
+
+    async def _arun(self, tool_input: str) -> str:
+        """Use the tool asynchronously."""
+        if self.coroutine:
+            return await self.coroutine(tool_input)
+        raise NotImplementedError("Tool does not support async")
+
+
+    def convert_prompt(self,params):
+        lines = "Your input should be a json: {{"
+        for p in params:
+            logger.debug(p)
+            optional = not p['required']
+            description = p.get('description', '')
+            if len(description) > 0:
+                description = "("+description+")"
+
+            lines +=  '"{name}" : {type}{desc},'.format(
+                                                                    name=p['name'],
+                                                                    type= p['schema']['type'], 
+                                                                    optional=optional,
+                                                                    desc=description)
+
+        lines += "}}"
+        return lines
+        
+
+
+    def __init__(self, root_url, func_url, method, request_info,  **kwargs):
+        """ Store the function, description, and tool_name in a class to store the information
+        """
+        url = root_url + func_url
+    
+        def func(json_args):
+            if isinstance(json_args, str):
+                # json_args = json_args.replace("\'", "\"")
+                # print(json_args)
+                try:
+                    json_args = json.loads(json_args)
+                except:
+                    return "Your input can not be parsed as json, please use thought."
+            response = requests.get(url, json_args)
+            if response.status_code == 200:
+                message = response.text
+            else:
+                message = f"Error code {response.status_code}. You can try (1) Change your input (2) Call another function. (If the same error code is produced more than 4 times, please use Thought: I can not use these APIs, so I will stop. Final Answer: No Answer, please check the APIs.)"
+            
+            message = message[:self.max_output_len] # TODO: not rigorous, to improve
+            return message
+        
+        tool_name = func_url.replace("/", ".").strip(".")
+
+        if 'parameters' in request_info[method]:
+            str_doc = self.convert_prompt(request_info[method]['parameters'])
+        else:
+            str_doc = ''
+
+
+        description = f"- {tool_name}:\n" + \
+             request_info[method].get('summary', '').replace("{", "{{").replace("}", "}}") \
+                + "," \
+                + request_info[method].get('description','').replace("{", "{{").replace("}", "}}") \
+                + str_doc \
+                + f"The Action to trigger this API should be {tool_name}\n and the input parameters should be a json dict string. Pay attention to the type of parameters.\n"
+
+        logger.info("API Name: {}".format(tool_name))
+        logger.info("API Description: {}".format(description))
+
+        super(RequestTool, self).__init__(
+            name=tool_name, func=func, description=description, **kwargs
+        )
+

bmtools/agent/executor.py

@@ -0,0 +1,109 @@
+import types
+from typing import Any, Dict, List, Tuple, Union
+from langchain.agents import AgentExecutor
+from langchain.input import get_color_mapping
+from langchain.schema import AgentAction, AgentFinish
+from bmtools.agent.translator import Translator
+
+class AgentExecutorWithTranslation(AgentExecutor):
+
+    translator: Translator = Translator()
+
+    def prep_outputs(
+        self,
+        inputs: Dict[str, str],
+        outputs: Dict[str, str],
+        return_only_outputs: bool = False,
+    ) -> Dict[str, str]:
+        try:
+            outputs = super().prep_outputs(inputs, outputs, return_only_outputs)
+        except ValueError as e:
+            return outputs
+        else:
+            if "input" in outputs:
+                outputs = self.translator(outputs)
+            return outputs
+
+class Executor(AgentExecutorWithTranslation):
+    def _call(self, inputs: Dict[str, str]) -> Dict[str, Any]:
+        """Run text through and get agent response."""
+        # Do any preparation necessary when receiving a new input.
+        self.agent.prepare_for_new_call()
+        # Construct a mapping of tool name to tool for easy lookup
+        name_to_tool_map = {tool.name: tool for tool in self.tools}
+        # We construct a mapping from each tool to a color, used for logging.
+        color_mapping = get_color_mapping(
+            [tool.name for tool in self.tools], excluded_colors=["green"]
+        )
+        intermediate_steps: List[Tuple[AgentAction, str]] = []
+        # Let's start tracking the iterations the agent has gone through
+        iterations = 0
+        # We now enter the agent loop (until it returns something).
+        while self._should_continue(iterations):
+            next_step_output = self._take_next_step(
+                name_to_tool_map, color_mapping, inputs, intermediate_steps
+            )
+            if isinstance(next_step_output, AgentFinish):
+                yield self._return(next_step_output, intermediate_steps)
+                return
+
+            agent_action = next_step_output[0]
+            tool_logo = None
+            for tool in self.tools:
+                if tool.name == agent_action.tool:
+                    tool_logo = tool.tool_logo_md
+            if isinstance(next_step_output[1], types.GeneratorType):
+                logo = f"{tool_logo}" if tool_logo is not None else ""
+                yield (AgentAction("", agent_action.tool_input, agent_action.log), f"Further use other tool {logo} to answer the question.")
+                for output in next_step_output[1]:
+                    yield output
+                next_step_output = (agent_action, output)
+            else:
+                for tool in self.tools:
+                    if tool.name == agent_action.tool:
+                        yield (AgentAction(tool_logo, agent_action.tool_input, agent_action.log), next_step_output[1])
+
+            intermediate_steps.append(next_step_output)
+            # See if tool should return directly
+            tool_return = self._get_tool_return(next_step_output)
+            if tool_return is not None:
+                yield self._return(tool_return, intermediate_steps)
+                return
+            iterations += 1
+        output = self.agent.return_stopped_response(
+            self.early_stopping_method, intermediate_steps, **inputs
+        )
+        yield self._return(output, intermediate_steps)
+        return
+
+    def __call__(
+        self, inputs: Union[Dict[str, Any], Any], return_only_outputs: bool = False
+    ) -> Dict[str, Any]:
+        """Run the logic of this chain and add to output if desired.
+
+        Args:
+            inputs: Dictionary of inputs, or single input if chain expects
+                only one param.
+            return_only_outputs: boolean for whether to return only outputs in the
+                response. If True, only new keys generated by this chain will be
+                returned. If False, both input keys and new keys generated by this
+                chain will be returned. Defaults to False.
+
+        """
+        inputs = self.prep_inputs(inputs)
+        self.callback_manager.on_chain_start(
+            {"name": self.__class__.__name__},
+            inputs,
+            verbose=self.verbose,
+        )
+        try:
+            for output in self._call(inputs):
+                if type(output) is dict:
+                    output = self.prep_outputs(inputs, output, return_only_outputs)
+                yield output
+        except (KeyboardInterrupt, Exception) as e:
+            self.callback_manager.on_chain_error(e, verbose=self.verbose)
+            raise e
+        self.callback_manager.on_chain_end(output, verbose=self.verbose)
+        # return self.prep_outputs(inputs, output, return_only_outputs)
+        return output

bmtools/agent/singletool.py

@@ -0,0 +1,173 @@
+from langchain.llms import OpenAI
+from langchain import OpenAI, LLMChain, PromptTemplate, SerpAPIWrapper
+from langchain.agents import ZeroShotAgent, AgentExecutor, initialize_agent, Tool
+import importlib
+import json
+import os
+import requests
+import yaml
+from bmtools.agent.apitool import RequestTool
+from bmtools.agent.executor import Executor, AgentExecutorWithTranslation
+from bmtools import get_logger
+from bmtools.agent.BabyagiTools import BabyAGI
+# from bmtools.models.customllm import CustomLLM
+
+
+logger = get_logger(__name__)
+
+
+def import_all_apis(tool_json):
+    '''import all apis that is a tool
+    '''
+    doc_url = tool_json['api']['url']
+    response = requests.get(doc_url)
+
+    logger.info("Doc string URL: {}".format(doc_url))
+    if doc_url.endswith('yaml') or doc_url.endswith('yml'):
+        plugin = yaml.safe_load(response.text)
+    else:
+        plugin = json.loads(response.text)
+
+    server_url = plugin['servers'][0]['url']
+    if server_url.startswith("/"):
+        server_url = "http://127.0.0.1:8079" + server_url
+    logger.info("server_url {}".format(server_url))
+    all_apis = []
+    for key in plugin['paths']:
+        value = plugin['paths'][key]
+        api = RequestTool(root_url=server_url, func_url=key, method='get', request_info=value)
+        all_apis.append(api)
+    return all_apis
+
+def load_single_tools(tool_name, tool_url):
+    
+    # tool_name, tool_url = "datasette", "https://datasette.io/"
+    # tool_name, tool_url = "klarna", "https://www.klarna.com/"
+    # tool_name, tool_url =  'chemical-prop',  "http://127.0.0.1:8079/tools/chemical-prop/"
+    # tool_name, tool_url =  'douban-film',  "http://127.0.0.1:8079/tools/douban-film/"
+    # tool_name, tool_url =  'weather',  "http://127.0.0.1:8079/tools/weather/"
+    # tool_name, tool_url =  'wikipedia',  "http://127.0.0.1:8079/tools/wikipedia/"
+    # tool_name, tool_url =  'wolframalpha',  "http://127.0.0.1:8079/tools/wolframalpha/"
+    # tool_name, tool_url =  'klarna',  "https://www.klarna.com/"
+
+
+    get_url = tool_url +".well-known/ai-plugin.json"
+    response = requests.get(get_url)
+
+    if response.status_code == 200:
+        tool_config_json = response.json()
+    else:
+        raise RuntimeError("Your URL of the tool is invalid.")
+
+    return tool_name, tool_config_json
+    
+
+
+class STQuestionAnswerer:
+    def __init__(self, openai_api_key = "", stream_output=False, llm='ChatGPT'):
+        if len(openai_api_key) < 3: # not valid key (TODO: more rigorous checking)
+            openai_api_key = os.environ.get('OPENAI_API_KEY')
+
+        self.openai_api_key = openai_api_key
+        self.llm_model = llm
+
+        self.set_openai_api_key(openai_api_key)
+        self.stream_output = stream_output
+        
+     
+    
+    def set_openai_api_key(self, key):
+        # self.llm = CustomLLM()
+        logger.info("Using {}".format(self.llm_model))
+        if self.llm_model == "GPT-3.5":
+            self.llm = OpenAI(temperature=0.0, openai_api_key=key)  # use text-darvinci
+        elif self.llm_model == "ChatGPT":
+            self.llm = OpenAI(model_name="gpt-3.5-turbo", temperature=0.0, openai_api_key=key)  # use chatgpt
+        else:
+            raise RuntimeError("Your model is not available.")
+
+    def load_tools(self, name, meta_info, prompt_type="react-with-tool-description", return_intermediate_steps=True):
+
+        self.all_tools_map = {}
+        
+        self.all_tools_map[name] = import_all_apis(meta_info)
+
+        logger.info("Tool [{}] has the following apis: {}".format(name, self.all_tools_map[name]))
+
+        if prompt_type == "zero-shot-react-description":
+            subagent = initialize_agent(self.all_tools_map[name], self.llm, agent="zero-shot-react-description", verbose=True, return_intermediate_steps=return_intermediate_steps)
+        elif prompt_type == "react-with-tool-description":
+            description_for_model = meta_info['description_for_model'].replace("{", "{{").replace("}", "}}").strip()
+
+            prefix = f"""Answer the following questions as best you can. General instructions are: {description_for_model}. Specifically, you have access to the following APIs:"""
+            suffix = """Begin! Remember: (1) Follow the format, i.e,\nThought:\nAction:\nAction Input:\nObservation:\nFinal Answer:\n (2) Provide as much as useful information in your Final Answer. (3) YOU MUST INCLUDE all relevant IMAGES in your Final Answer using format ![img](url), and include relevant links. (3) Do not make up anything, and if your Observation has no link, DO NOT hallucihate one. (4) If you have enough information, please use \nThought: I have got enough information\nFinal Answer: \n\nQuestion: {input}\n{agent_scratchpad}"""
+            prompt = ZeroShotAgent.create_prompt(
+                self.all_tools_map[name], 
+                prefix=prefix, 
+                suffix=suffix, 
+                input_variables=["input", "agent_scratchpad"]
+            )
+            llm_chain = LLMChain(llm=self.llm, prompt=prompt)
+            logger.info("Full prompt template: {}".format(prompt.template))
+            tool_names = [tool.name for tool in self.all_tools_map[name] ]
+            agent = ZeroShotAgent(llm_chain=llm_chain, allowed_tools=tool_names)
+            if self.stream_output:
+                agent_executor = Executor.from_agent_and_tools(agent=agent, tools=self.all_tools_map[name] , verbose=True, return_intermediate_steps=return_intermediate_steps)
+            else:
+                agent_executor = AgentExecutorWithTranslation.from_agent_and_tools(agent=agent, tools=self.all_tools_map[name], verbose=True, return_intermediate_steps=return_intermediate_steps)
+            return agent_executor
+        elif prompt_type == "babyagi":
+            # customllm = CustomLLM()
+            tool_str = "; ".join([t.name for t in self.all_tools_map[name]] + ["TODO"])
+            prefix = """You are an AI who performs one task based on the following objective: {objective}. Take into account these previously completed tasks: {context}.\n You have access to the following APIs:"""
+            suffix = """YOUR CONSTRAINTS: (1) YOU MUST follow this format:
+            \nThought:\nAction:\nAction Input: \n or \nThought:\nFinal Answer:\n (2) Do not make up anything, and if your Observation has no link, DO NOT hallucihate one. (3) The Action: MUST be one of the following: """ + tool_str + """\nQuestion: {task}\n Agent scratchpad (history actions): {agent_scratchpad}."""
+
+            # tool_str = "; ".join([t.name for t in self.all_tools_map[name]])
+            # todo_prompt = PromptTemplate.from_template("You are a planner who is an expert at coming up with a todo list for a given objective. For a simple objective, do not generate a complex todo list. Generate a todo list that can largely be completed by the following APIs: " + tool_str + ". Come up with a todo list for this objective: {objective}")
+
+            # # todo_chain = LLMChain(llm=self.llm, prompt=todo_prompt)
+            # todo_chain = LLMChain(llm=customllm, prompt=todo_prompt)
+
+            # todo_tool = Tool(
+            #     name = "TODO",
+            #     func=todo_chain.run,
+            #     description="useful for when you need to come up with todo lists. Input: an objective to create a todo list for. Output: a todo list for that objective. Please be very clear what the objective is!"
+            # )
+            # self.all_tools_map[name].append(todo_tool)
+
+            prompt = ZeroShotAgent.create_prompt(
+                self.all_tools_map[name], 
+                prefix=prefix, 
+                suffix=suffix, 
+                input_variables=["objective", "task", "context","agent_scratchpad"]
+            )
+
+            logger.info("Full prompt template: {}".format(prompt.template))
+
+            # specify the maximum number of iterations you want babyAGI to perform
+            max_iterations = 10
+            baby_agi = BabyAGI.from_llm(
+                llm=self.llm,
+                # llm=customllm,
+                prompt=prompt,
+                verbose=False,
+                tools=self.all_tools_map[name],
+                stream_output=self.stream_output,
+                return_intermediate_steps=return_intermediate_steps,
+                max_iterations=max_iterations,
+            )
+
+            return baby_agi
+
+
+if __name__ == "__main__":
+
+    tools_name, tools_config = load_single_tools()
+    print(tools_name, tools_config)
+    
+    qa =  STQuestionAnswerer()
+
+    agent = qa.load_tools(tools_name, tools_config)
+
+    agent("Calc integral of sin(x)+2x^2+3x+1 from 0 to 1")

bmtools/agent/tools_controller.py

@@ -0,0 +1,113 @@
+from langchain.llms import OpenAI
+from langchain import OpenAI, LLMChain
+from langchain.agents import ZeroShotAgent, AgentExecutor
+import importlib
+import json
+import os
+import requests
+import yaml
+from bmtools.agent.apitool import Tool
+from bmtools.agent.singletool import STQuestionAnswerer
+from bmtools.agent.executor import Executor, AgentExecutorWithTranslation
+from bmtools import get_logger
+
+logger = get_logger(__name__)
+
+def load_valid_tools(tools_mappings):
+    tools_to_config = {}
+    for key in tools_mappings:
+        get_url = tools_mappings[key]+".well-known/ai-plugin.json"
+        
+        response = requests.get(get_url)
+
+        if response.status_code == 200:
+            tools_to_config[key] = response.json()
+        else:
+            logger.warning("Load tool {} error, status code {}".format(key, response.status_code))
+
+    return tools_to_config
+    
+
+
+class MTQuestionAnswerer:
+    """Use multiple tools to answer a question. Basically pass a natural question to 
+    """
+    def __init__(self, openai_api_key, all_tools, stream_output=False, llm='ChatGPT'):
+        if len(openai_api_key) < 3: # not valid key (TODO: more rigorous checking)
+            openai_api_key = os.environ.get('OPENAI_API_KEY')
+        self.openai_api_key = openai_api_key
+        self.stream_output = stream_output
+        self.llm_model = llm
+        self.set_openai_api_key(openai_api_key)
+        self.load_tools(all_tools)
+    
+    def set_openai_api_key(self, key):
+        logger.info("Using {}".format(self.llm_model))
+        if self.llm_model == "GPT-3.5":
+            self.llm = OpenAI(temperature=0.0, openai_api_key=key)  # use text-darvinci
+        elif self.llm_model == "ChatGPT":
+            self.llm = OpenAI(model_name="gpt-3.5-turbo", temperature=0.0, openai_api_key=key)  # use chatgpt
+        else:
+            raise RuntimeError("Your model is not available.")
+
+    def load_tools(self, all_tools):
+        logger.info("All tools: {}".format(all_tools))
+        self.all_tools_map = {}
+        self.tools_pool = []
+        for name in all_tools:
+            meta_info = all_tools[name]
+
+            question_answer = STQuestionAnswerer(self.openai_api_key, stream_output=self.stream_output, llm=self.llm_model)
+            subagent = question_answer.load_tools(name, meta_info, prompt_type="react-with-tool-description", return_intermediate_steps=False)
+            tool_logo_md = f'<img src="{meta_info["logo_url"]}" width="32" height="32" style="display:inline-block">'
+            for tool in subagent.tools:
+                tool.tool_logo_md = tool_logo_md
+            tool = Tool(
+                name=meta_info['name_for_model'],
+                description=meta_info['description_for_model'].replace("{", "{{").replace("}", "}}"),
+                func=subagent,
+            )
+            tool.tool_logo_md = tool_logo_md
+            self.tools_pool.append(tool)
+        
+    def build_runner(self, ):
+
+        # 可以修改prompt来让模型表现更好，也可以修改tool的doc
+        prefix = """Answer the following questions as best you can. In this level, you are calling the tools in natural language format, since the tools are actually an intelligent agent like you, but they expert only in one area. Several things to remember. (1) Remember to follow the format of passing natural language as the Action Input. (2) DO NOT use your imagination, only use concrete information given by the tools. (3) If the observation contains images or urls which has useful information, YOU MUST INCLUDE ALL USEFUL IMAGES and links in your Answer and Final Answers using format ![img](url). BUT DO NOT provide any imaginary links. (4) The information in your Final Answer should include ALL the informations returned by the tools. (5) If a user's query is a language other than English, please translate it to English without tools, and translate it back to the source language in Final Answer. You have access to the following tools (Only use these tools we provide you):"""
+        suffix = """\nBegin! Remember to . \nQuestion: {input}\n{agent_scratchpad}"""
+
+    
+        prompt = ZeroShotAgent.create_prompt(
+            self.tools_pool,
+            prefix=prefix,
+            suffix=suffix, 
+            input_variables=["input", "agent_scratchpad"]
+        )
+        llm_chain = LLMChain(llm=self.llm, prompt=prompt)
+        logger.info("Full Prompt Template:\n {}".format(prompt.template))
+        tool_names = [tool.name for tool in self.tools_pool]
+        agent = ZeroShotAgent(llm_chain=llm_chain, allowed_tools=tool_names)
+        if self.stream_output:
+            agent_executor = Executor.from_agent_and_tools(agent=agent, tools=self.tools_pool, verbose=True, return_intermediate_steps=True)
+        else:
+            agent_executor = AgentExecutorWithTranslation.from_agent_and_tools(agent=agent, tools=self.tools_pool, verbose=True, return_intermediate_steps=True)
+        return agent_executor
+
+
+
+if __name__ == "__main__":
+    tools_mappings = {
+        "klarna": "https://www.klarna.com/",
+        "chemical-prop": "http://127.0.0.1:8079/tools/chemical-prop/",
+        "wolframalpha": "http://127.0.0.1:8079/tools/wolframalpha/",
+        "weather": "http://127.0.0.1:8079/tools/weather/",
+    }
+
+    tools = load_valid_tools(tools_mappings)
+    
+    qa =  MTQuestionAnswerer(openai_api_key='', all_tools=tools)
+
+    agent = qa.build_runner()
+    
+    agent("How many carbon elements are there in CH3COOH? How many people are there in China?")
+    

bmtools/agent/translator.py

@@ -0,0 +1,116 @@
+from langchain.llms import OpenAI
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+from bmtools.models import CustomLLM
+
+import py3langid as langid
+from iso639 import languages
+
+from typing import Dict
+from copy import deepcopy
+import os
+
+def detect_lang(text: str):
+    lang_code = langid.classify(text)[0]
+    lang_name = languages.get(part1=lang_code[:2]).name
+    return lang_name
+
+class Translator:
+
+    def __init__(self,
+                 openai_api_key: str = None,
+                 model_name: str = "gpt-3.5-turbo"):
+        llm = self.create_openai_model(openai_api_key, model_name)
+        prompt = self.create_prompt()
+        self.chain = LLMChain(llm=llm, prompt=prompt)
+
+    def __call__(self, inputs: Dict[str, str]) -> Dict[str, str]:
+        question = inputs["input"]
+        answer = inputs["output"]
+
+        src_lang = detect_lang(answer)
+        tgt_lang = detect_lang(question)
+
+        if src_lang != tgt_lang:
+            translated_answer = self.chain.run(text=answer, language=tgt_lang)
+            outputs = deepcopy(inputs)
+            outputs["output"] = translated_answer
+            return outputs
+        else:
+            return inputs
+
+    def create_openai_model(self, openai_api_key: str, model_name: str) -> OpenAI:
+        # if openai_api_key is None:
+        #     openai_api_key = os.environ.get('OPENAI_API_KEY')
+        # llm = OpenAI(model_name=model_name,
+        #              temperature=0.0,
+        #              openai_api_key=openai_api_key)
+        llm = CustomLLM()
+        return llm
+
+    def create_prompt(self) -> PromptTemplate:
+        template = """
+        Translate to {language}: {text} => 
+        """
+        prompt = PromptTemplate(
+            input_variables=["text", "language"],
+            template=template
+        )
+        return prompt
+
+if __name__ == "__main__":
+    lang = {
+        "zh": {
+            "question": "帮我介绍下《深海》这部电影",
+            "answer": "《深海》是一部中国大陆的动画、奇幻电影，由田晓鹏导演，苏鑫、王亭文、滕奎兴等人主演。剧情简介是在大海的最深处，藏着所有秘密。一位现代少女（参宿）误入梦幻的 深海世界，却因此邂逅了一段独特的生命旅程。![img](https://img3.doubanio.com/view/photo/s_ratio_poster/public/p2635450820.webp)",
+        },
+        "ja": {
+            "question": "映画「深海」について教えてください",
+            "answer": "「深海」は、中国本土のアニメーションおよびファンタジー映画で、Tian Xiaopeng が監督し、Su Xin、Wang Tingwen、Teng Kuixing などが出演しています。 あらすじは、海の最深部にはすべての秘密が隠されているというもの。 夢のような深海の世界に迷い込んだ現代少女（さんすけ）は、それをきっかけに独特の人生の旅に出くわす。 ![img](https://img3.doubanio.com/view/photo/s_ratio_poster/public/p2635450820.webp)",
+        },
+        "ko": {
+            "question": "영화 딥씨에 대해 알려주세요",
+            "answer": "\"Deep Sea\"는 Tian Xiaopeng 감독, Su Xin, Wang Tingwen, Teng Kuixing 등이 출연한 중국 본토의 애니메이션 및 판타지 영화입니다. 시놉시스는 바다 가장 깊은 곳에 모든 비밀이 숨겨져 있다는 것입니다. 현대 소녀(산스케)는 꿈 같은 심해 세계로 방황하지만 그것 때문에 독특한 삶의 여정을 만난다. ![img](https://img3.doubanio.com/view/photo/s_ratio_poster/public/p2635450820.webp)",
+        },
+        "en": {
+            "question": "Tell me about the movie '深海'",
+            "answer": "\"Deep Sea\" is an animation and fantasy film in mainland China, directed by Tian Xiaopeng, starring Su Xin, Wang Tingwen, Teng Kuixing and others. The synopsis is that in the deepest part of the sea, all secrets are hidden. A modern girl (Sansuke) strays into the dreamy deep sea world, but encounters a unique journey of life because of it. ![img](https://img3.doubanio.com/view/photo/s_ratio_poster/public/p2635450820.webp)",
+        },
+        "de": {
+            "question": "Erzähl mir von dem Film '深海'",
+            "answer": "\"Deep Sea\" ist ein Animations- und Fantasyfilm in Festlandchina unter der Regie von Tian Xiaopeng mit Su Xin, Wang Tingwen, Teng Kuixing und anderen in den Hauptrollen. Die Zusammenfassung ist, dass im tiefsten Teil des Meeres alle Geheimnisse verborgen sind. Ein modernes Mädchen (Sansuke) verirrt sich in die verträumte Tiefseewelt, trifft dabei aber auf eine einzigartige Lebensreise. ![img](https://img3.doubanio.com/view/photo/s_ratio_poster/public/p2635450820.webp)",
+        },
+        "fr": {
+            "question": "Parlez-moi du film 'Deep Sea'",
+            "answer": "\"Deep Sea\" est un film d'animation et fantastique en Chine continentale, réalisé par Tian Xiaopeng, avec Su Xin, Wang Tingwen, Teng Kuixing et d'autres. Le synopsis est que dans la partie la plus profonde de la mer, tous les secrets sont cachés. Une fille moderne (Sansuke) s'égare dans le monde onirique des profondeurs marines, mais rencontre un voyage de vie unique à cause de cela. ![img](https://img3.doubanio.com/view/photo/s_ratio_poster/public/p2635450820.webp)",
+        },
+        "ru": {
+            "question": "Расскажите о фильме 'Глубокое море'",
+            "answer": "«Глубокое море» — это анимационный и фэнтезийный фильм в материковом Китае, снятый Тянь Сяопином, в главных ролях Су Синь, Ван Тинвэнь, Тэн Куйсин и другие. Суть в том, что в самой глубокой части моря скрыты все секреты. Современная девушка (Сансукэ) заблудилась в мечтательном глубоководном мире, но из-за этого столкнулась с уникальным жизненным путешествием. ![img](https://img3.doubanio.com/view/photo/s_ratio_poster/public/p2635450820.webp)",
+        },
+    }
+
+    translator = Translator()
+    for source in lang:
+        for target in lang:
+            print(source, "=>", target, end=":\t")
+            question = lang[target]["question"]
+            answer = lang[source]["answer"]
+            inputs = {
+                "input": question,
+                "output": answer
+            }
+
+            result = translator(inputs)
+            translated_answer = result["output"]
+
+            if detect_lang(question) == detect_lang(translated_answer) == languages.get(part1=target).name:
+                print("Y")
+            else:
+                print("N")
+                print("====================")
+                print("Question:\t", detect_lang(question), " - ", question)
+                print("Answer:\t", detect_lang(answer), " - ", answer)
+                print("Translated Anser:\t", detect_lang(translated_answer), " - ", translated_answer)
+                print("====================")

bmtools/tools/__init__.py

@@ -0,0 +1,15 @@
+# from . import chemical
+from . import film
+# from . import kg
+# from . import stock
+# from . import weather
+# from . import wikipedia
+# from . import wolframalpha
+# from . import office
+# from . import bing_search
+# from . import translation
+# from . import tutorial
+
+from .tool import Tool
+from .registry import register
+from .serve import ToolServer

bmtools/tools/film/__init__.py

@@ -0,0 +1,6 @@
+from ..registry import register
+
+@register("douban-film")
+def douban_film():
+    from .douban import build_tool
+    return build_tool

bmtools/tools/film/douban/__init__.py

@@ -0,0 +1 @@
+from .api import build_tool

bmtools/tools/film/douban/api.py

@@ -0,0 +1,234 @@
+import requests
+from lxml import etree
+import pandas as pd
+from translate import Translator
+import re
+from ...tool import Tool
+
+
+def build_tool(config) -> Tool:
+    tool = Tool(
+        "Film Search Plugin",
+        "search for up-to-date film information.",
+        name_for_model="Film Search",
+        description_for_model="Plugin for search for up-to-date film information.",
+        logo_url="https://your-app-url.com/.well-known/logo.png",
+        contact_email="[email protected]",
+        legal_info_url="[email protected]"
+    )
+    
+    def fetch_page(url : str):
+        """get_name(url: str) print html text of url
+        """
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) '
+                                'Chrome/108.0.0.0 Safari/537.36'}
+        s = requests.session()
+        s.keep_alive = False
+        response = s.get(url, headers=headers, verify=False)
+
+        return response
+
+    def parse_coming_page():
+        """parse_coming_page() prints the details of the all coming films, including date, title, cate, region, wantWatchPeopleNum, link
+        """
+        # 获取即将上映的电影列表
+        url = 'https://movie.douban.com/coming'
+        response = fetch_page(url)
+
+        df_filmsComing = pd.DataFrame(columns=["date", "title", "cate", "region", "wantWatchPeopleNum", 'link'])
+
+        parser = etree.HTMLParser(encoding='utf-8')
+        tree = etree.HTML(response.text, parser=parser)
+
+        movies_table_path = '//*[@id="content"]/div/div[1]/table/tbody'
+        movies_table = tree.xpath(movies_table_path)
+        for filmChild in movies_table[0].iter('tr'):
+            filmTime = filmChild.xpath('td[1]/text()')[0].strip()
+            filmName = filmChild.xpath('td[2]/a/text()')[0]
+            filmType = filmChild.xpath('td[3]/text()')[0].strip()
+            filmRegion = filmChild.xpath('td[4]/text()')[0].strip()
+            filmWantWatching = filmChild.xpath('td[5]/text()')[0].strip()
+            filmLink = filmChild.xpath('td[2]/a/@href')[0]
+            df_filmsComing.loc[len(df_filmsComing.index)] = [
+                filmTime, filmName, filmType, filmRegion, filmWantWatching, filmLink
+            ]
+        return df_filmsComing
+    
+    def parse_nowplaying_page():
+        """parse_nowplaying_page() prints the details of the all playing films now, including title, score, region, director, actors, link
+        """
+        # 获取正在上映的电影列表
+        url = 'https://movie.douban.com/cinema/nowplaying/beijing/'
+        response = fetch_page(url)
+        df_filmsNowPlaying = pd.DataFrame(columns=["title", "score", "region", "director", "actors", 'link'])
+
+        parser = etree.HTMLParser(encoding='utf-8')
+        tree = etree.HTML(response.text, parser=parser)
+
+        movies_table_path = './/div[@id="nowplaying"]/div[2]/ul'
+        movies_table = tree.xpath(movies_table_path)
+        for filmChild in movies_table[0]:
+            filmName = filmChild.xpath('@data-title')[0]
+            filmScore = filmChild.xpath('@data-score')[0]
+            filmRegion = filmChild.xpath('@data-region')[0]
+            filmDirector = filmChild.xpath('@data-director')[0]
+            filmActors = filmChild.xpath('@data-actors')[0]
+            filmLink = filmChild.xpath('ul/li[1]/a/@href')[0]
+            df_filmsNowPlaying.loc[len(df_filmsNowPlaying.index)] = [
+                filmName, filmScore, filmRegion, filmDirector, filmActors, filmLink
+            ]
+        return df_filmsNowPlaying
+
+    def parse_detail_page(response):
+        """parse_detail_page(response) get information from response.text
+        """
+        parser = etree.HTMLParser(encoding='utf-8')
+        tree = etree.HTML(response.text, parser=parser)
+        info_path = './/div[@class="subject clearfix"]/div[2]'
+
+        director = tree.xpath(f'{info_path}/span[1]/span[2]/a/text()')[0]
+
+        actors = []
+        actors_spans = tree.xpath(f'{info_path}/span[3]/span[2]')[0]
+        for actors_span in actors_spans:
+            actors.append(actors_span.text)
+        actors = '、'.join(actors[:3])
+
+        types = []
+        spans = tree.xpath(f'{info_path}')[0]
+        for span in spans.iter('span'):
+            if 'property' in span.attrib and span.attrib['property']=='v:genre':
+                types.append(span.text)
+        types = '、'.join(types)
+        
+        for span in spans:
+            if span.text=='制片国家/地区:':
+                region = span.tail.strip()
+                break
+        Synopsis = tree.xpath('.//div[@class="related-info"]/div/span')[0].text.strip()
+        detail = f'是一部{region}的{types}电影，由{director}导演，{actors}等人主演.\n剧情简介：{Synopsis}'
+        return detail
+
+    @tool.get("/coming_out_filter")
+    def coming_out_filter(args : str):
+        """coming_out_filter(args: str) prints the details of the filtered [outNum] coming films now according to region, cate and outNum. 
+            args is a list like 'str1, str2, str3, str4'
+            str1 represents Production country or region. If you cannot find a region, str1 is 全部
+            str2 represents movie's category. If you cannot find a category, str2 is 全部
+            str3 can be a integer number that agent want to get. If you cannot find a number, str2 is 100. If the found movie's num is less than str2, Final Answer only print [the found movie's num] movies.
+            str4 can be a True or False that refluct whether agent want the result sorted by people number which look forward to the movie.
+            Final answer should be complete.
+
+            This is an example:
+            Thought: I need to find the upcoming Chinese drama movies and the top 2 most wanted movies
+            Action: coming_out_filter
+            Action Input: {"args" : "中国, 剧情, 2, True"}
+            Observation: {"date":{"23":"04月28日","50":"07月"},"title":{"23":"长空之王","50":"热烈"},"cate":{"23":"剧情 / 动作","50":"剧情 / 喜剧"},"region":{"23":"中国大陆","50":"中国大陆"},"wantWatchPeopleNum":{"23":"39303人","50":"26831人"}}
+            Thought: I now know the top 2 upcoming Chinese drama movies
+            Final Answer: 即将上映的中国剧情电影有2部：长空之王、热烈，大家最想看的前2部分别是：长空之王、热烈。
+        """
+        args = re.findall(r'\b\w+\b', args)
+        region = args[0]
+        if region=='全部':
+            region = ''
+        cate = args[1]
+        if cate=='全部':
+            cate = ''
+        outNum = int(args[2])
+        WantSort = True if args[3]=='True' else False
+
+        df = parse_coming_page()
+        df_recon = pd.DataFrame.copy(df, deep=True)
+        
+        # 即将上映的某类型电影，根据想看人数、地区、类型进行筛选
+        df_recon['wantWatchPeopleNum'] = df_recon['wantWatchPeopleNum'].apply(lambda x: int(x.replace('人', '')))
+        
+        df_recon = df_recon[df_recon['cate'].str.contains(cate)]
+        df_recon = df_recon[df_recon['region'].str.contains(region)]
+        
+        # 最后根据想看人数降序排列 
+        if WantSort:
+            df_recon.sort_values(by="wantWatchPeopleNum" , inplace=True, ascending = not WantSort) 
+        outDf = df_recon[:outNum]
+        return df.loc[outDf.index, 'date':'wantWatchPeopleNum']
+
+
+    @tool.get("/now_playing_out_filter")
+    def now_playing_out_filter(args : str):
+        """NowPlayingOutFilter(args: str) prints the details of the filtered [outNum] playing films now according to region, scoreSort
+            args is a list like 'str1, str2, str3'
+            str1 can be '中国','日本' or other Production country or region. If you cannot find a region, str1 is 全部
+            str2 can be a integer number that agent want to get. If you cannot find a number, str2 is 100. If the found movie's num is less than str2, Final Answer only print [the found movie's num] movies.
+            str3 can be a True or False that refluct whether agent want the result sorted by score.
+            Final answer should be complete.
+
+            This is an example:
+            Input: 您知道现在有正在上映中国的电影吗？请输出3部
+            Thought: I need to find the currently playing movies with the highest scores
+            Action: now_playing_out_filter
+            Action Input: {"args" : "全部, 3, True"}
+            Observation: {"title":{"34":"切腹","53":"吉赛尔","31":"小森林 夏秋篇"},"score":{"34":"9.4","53":"9.2","31":"9.0"},"region":{"34":"日本","53":"西德","31":"日本"},"director":{"34":"小林正树","53":"Hugo Niebeling","31":"森淳一"},"actors":{"34":"仲代达矢 / 石浜朗 / 岩下志麻","53":"卡拉·弗拉奇 / 埃里克·布鲁恩 / Bruce Marks","31":"桥本爱 / 三浦贵大 / 松冈茉优"}}
+            Thought: I now know the currently playing movies with the highest scores
+            Final Answer: 现在上映的评分最高的3部电影是：切腹、吉赛尔、小森林 夏秋篇
+            
+        """
+        args = re.findall(r'\b\w+\b', args)
+        region = args[0]
+        if region=='全部':
+            region = ''
+        outNum = int(args[1])
+        scoreSort = True if args[2]=='True' else False
+
+        df = parse_nowplaying_page()
+        
+        df_recon = pd.DataFrame.copy(df, deep=True)
+        
+        df_recon['score'] = df_recon['score'].apply(lambda x: float(x))
+
+        # 正在上映的某类型电影，根据地区进行筛选
+        df_recon = df_recon[df_recon['region'].str.contains(region)]
+        
+        # 最后根据评分降序排列 
+        if scoreSort:
+            df_recon.sort_values(by="score" , inplace=True, ascending = not scoreSort) 
+        outDf = df_recon[:outNum]
+        return df.loc[outDf.index, 'title':'actors']
+
+    @tool.get("/print_detail")
+    def print_detail(args : str):
+        """parsing_detail_page(args) prints the details of a movie, giving its name.
+            args is a list like 'str1'
+            str1 is target movie's name.
+            step1: apply function parse_coming_page and parse_nowplaying_page and get all movie's links and other infomation.
+            step2: get the target movie's link from df_coming or df_nowplaying
+            step3: get detail from step2's link
+
+            This is an example: 
+            Input: "电影流浪地球2怎么样？"
+            Thought: I need to find the movie's information
+            Action: print_detail
+            Action Input: {"args" : "流浪地球2"}
+            Observation: "是一部中国大陆的科幻、冒险、灾难电影，由郭帆导演，吴京、刘德华、李雪健等人主演.\n剧情简介：太阳即将毁灭，人类在地球表面建造出巨大的推进器，寻找新的家园。然而宇宙之路危机四伏，为了拯救地球，流浪地球时代的年轻人再次挺身而出，展开争分夺秒的生死之战。"
+            Thought: I now know the final answer
+            Final Answer: 流浪地球2是一部中国大陆的科幻、冒险、灾难电影，由郭帆导演，吴京、刘德华、李雪健等人主演，剧情简介是太阳即将毁灭，人类在地球表面建造出巨大的推进器，寻找新的家园，然而宇宙之路危机四伏，为了拯救地球，流浪地球时代的年轻人再次挺身而出，
+            
+        """
+        args = re.findall(r'\b\w+\b', args)
+        filmName = args[0]
+
+        df_coming = parse_coming_page()
+        df_nowplaying = parse_nowplaying_page()
+        
+        if filmName in list(df_coming['title']):
+            df = df_coming
+            url = df[df['title']==filmName]['link'].values[0]
+            response = fetch_page(url)
+            detail = parse_detail_page(response)
+        elif filmName in list(df_nowplaying['title']):
+            df = df_nowplaying
+            url = df[df['title']==filmName]['link'].values[0]
+            response = fetch_page(url)
+            detail = parse_detail_page(response)
+        return f'{filmName}{detail}'
+    return tool

bmtools/tools/film/douban/readme.md

@@ -0,0 +1,3 @@
+# Douban Film Search
+
+Contributor: [Jing Yi](https://github.com/yijing16)

bmtools/tools/film/douban/test.py

@@ -0,0 +1,15 @@
+
+from bmtools.agent.singletool import load_single_tools, STQuestionAnswerer
+
+tool_name, tool_url = 'douban',  "http://127.0.0.1:8079/tools/douban-film/"
+tools_name, tools_config = load_single_tools(tool_name, tool_url)
+# tools_name, tools_config = load_single_tools()
+print(tools_name, tools_config)
+
+qa =  STQuestionAnswerer()
+
+agent = qa.load_tools(tools_name, tools_config)
+
+agent("有哪些即将上映的中国喜剧电影？哪些是大家最想看的前5部？")
+agent("想去电影院看一些国产电影，有评分高的吗？输出3部")
+agent("帮我介绍下《深海》这部电影")

bmtools/tools/registry.py

@@ -0,0 +1,38 @@
+from .tool import Tool
+from typing import Dict, Callable, Any, List
+
+ToolBuilder = Callable[[Any], Tool]
+FuncToolBuilder = Callable[[], ToolBuilder]
+
+
+class ToolsRegistry:
+    def __init__(self) -> None:
+        self.tools : Dict[str, FuncToolBuilder] = {}
+    
+    def register(self, tool_name : str, tool : FuncToolBuilder):
+        print(f"will register {tool_name}")
+        self.tools[tool_name] = tool
+    
+    def build(self, tool_name, config) -> Tool:
+        ret = self.tools[tool_name]()(config)
+        if isinstance(ret, Tool):
+            return ret
+        raise ValueError("Tool builder {} did not return a Tool instance".format(tool_name))
+    
+    def list_tools(self) -> List[str]:
+        return list(self.tools.keys())
+
+tools_registry = ToolsRegistry()
+
+def register(tool_name):
+    def decorator(tool : FuncToolBuilder):
+        tools_registry.register(tool_name, tool)
+        return tool
+    return decorator
+
+def build_tool(tool_name : str, config : Any) -> Tool:
+    print(f"will build {tool_name}")
+    return tools_registry.build(tool_name, config)
+
+def list_tools() -> List[str]:
+    return tools_registry.list_tools()

bmtools/tools/retriever.py

@@ -0,0 +1,45 @@
+from langchain.embeddings import OpenAIEmbeddings
+# from bmtools.models import CustomEmbedding
+from typing import List, Dict
+from queue import PriorityQueue
+import os
+
+class Retriever:
+    def __init__(self,
+                 openai_api_key: str = None,
+                 model: str = "text-embedding-ada-002"):
+        if openai_api_key is None:
+            openai_api_key = os.environ.get("OPENAI_API_KEY")
+        self.embed = OpenAIEmbeddings(openai_api_key=openai_api_key, model=model)
+        # self.embed = CustomEmbedding()
+        self.documents = dict()
+
+    def add_tool(self, tool_name: str, api_info: Dict) -> None:
+        if tool_name in self.documents:
+            return
+        document = api_info["name_for_model"] + ". " + api_info["description_for_model"]
+        document_embedding = self.embed.embed_documents([document])
+        self.documents[tool_name] = {
+            "document": document,
+            "embedding": document_embedding[0]
+        }
+
+    def query(self, query: str, topk: int = 3) -> List[str]:
+        query_embedding = self.embed.embed_query(query)
+
+        queue = PriorityQueue()
+        for tool_name, tool_info in self.documents.items():
+            tool_embedding = tool_info["embedding"]
+            tool_sim = self.similarity(query_embedding, tool_embedding)
+            queue.put([-tool_sim, tool_name])
+
+        result = []
+        for i in range(min(topk, len(queue.queue))):
+            tool = queue.get()
+            result.append(tool[1])
+
+        return result
+
+    def similarity(self, query: List[float], document: List[float]) -> float:
+        return sum([i * j for i, j in zip(query, document)])
+

bmtools/tools/serve.py

@@ -0,0 +1,102 @@
+import fastapi
+import uvicorn
+from .registry import build_tool, list_tools
+from .retriever import Retriever
+from typing import List
+from pydantic import BaseModel
+
+class RetrieveRequest(BaseModel):
+    query: str
+    topk: int = 3
+
+def _bind_tool_server(t : "ToolServer"):
+    """ Add property API to ToolServer.
+    t.api is a FastAPI object
+    """
+    
+    @t.api.get("/") 
+    def health():
+        return {
+            "status": "ok",
+        }
+    
+    @t.api.get("/list")
+    def get_tools_list():
+        return {
+            "tools": t.list_tools(),
+        }
+    
+    @t.api.get("/loaded")
+    def get_loaded_tools():
+        return {
+            "tools": list(t.loaded_tools),
+        }
+
+    @t.api.get("/.well-known/ai-plugin.json", include_in_schema=False)
+    def get_api_info():
+        return {
+            "schema_version": "v1",
+            "name_for_human": "BMTools",
+            "name_for_model": "BMTools",
+            "description_for_human": "tools to big models",
+            "description_for_model": "tools to big models",
+            "auth": {
+                "type": "none",
+            },
+            "api": {
+                "type": "openapi",
+                "url": "/openapi.json",
+                "is_user_authenticated": False,
+            },
+            "logo_url": None,
+            "contact_email": "",
+            "legal_info_url": "",
+        }
+
+    @t.api.post("/retrieve")
+    def retrieve(request: RetrieveRequest):
+        tool_list = t.retrieve(request.query, request.topk)
+        return {
+            "tools": tool_list
+        }
+
+class ToolServer:
+    """ This class host your own API backend.
+    """
+    def __init__(self) -> None:
+        # define the root API server
+        self.api = fastapi.FastAPI(
+            title="BMTools",
+            description="Tools for bigmodels",
+        )
+        self.loaded_tools = dict()
+        self.retriever = Retriever()
+        _bind_tool_server(self)
+    
+    def load_tool(self, name : str, config = {}):
+        if self.is_loaded(name):
+            raise ValueError(f"Tool {name} is already loaded")
+        try:
+            tool = build_tool(name, config)
+        except BaseException as e:
+            print(f"Cannot load tool {name}: {repr(e)}")
+            return
+        # tool = build_tool(name, config)
+        self.loaded_tools[name] = tool.api_info
+        self.retriever.add_tool(name, tool.api_info)
+
+        # mount sub API server to the root API server, thus can mount all urls of sub API server to /tools/{name} route
+        self.api.mount(f"/tools/{name}", tool, name)
+        return
+    
+    def is_loaded(self, name : str):
+        return name in self.loaded_tools
+    
+    def serve(self, host : str = "0.0.0.0", port : int = 8079):
+        uvicorn.run(self.api, host=host, port=port)
+
+    def list_tools(self) -> List[str]:
+        return list_tools()
+
+    def retrieve(self, query: str, topk: int = 3) -> List[str]:
+        return self.retriever.query(query, topk)

bmtools/tools/tool.py

@@ -0,0 +1,87 @@
+import fastapi
+from typing import Optional
+import copy
+from starlette.middleware.sessions import SessionMiddleware
+from fastapi import Request
+
+class Tool(fastapi.FastAPI):
+    """ Tool is inherited from FastAPI class, thus:
+    1. It can act as a server
+    2. It has get method, you can use Tool.get method to bind a function to an url
+    3. It can be easily mounted to another server
+    4. It has a list of sub-routes, each route is a function
+
+    Diagram:
+    Root API server (ToolServer object)
+    │     
+    ├───── "./weather": Tool object
+    │        ├── "./get_weather_today": function_get_weather(location: str) -> str
+    │        ├── "./get_weather_forecast": function_get_weather_forcast(location: str, day_offset: int) -> str
+    │        └── "...more routes"
+    ├───── "./wikidata": Tool object
+    │        ├── "... more routes"
+    └───── "... more routes"
+    """
+    def __init__(
+            self,
+            tool_name : str,
+            description : str,
+            name_for_human : Optional[str] = None,
+            name_for_model : Optional[str] = None,
+            description_for_human : Optional[str] = None,
+            description_for_model : Optional[str] = None,
+            logo_url : Optional[str] = None,
+            author_github : Optional[str] = None,
+            contact_email : str = "",
+            legal_info_url : str = "",
+            version : str = "0.1.0",
+        ):
+        super().__init__(
+            title=tool_name,
+            description=description,
+            version=version,
+        )
+
+        if name_for_human is None:
+            name_for_human = tool_name
+        if name_for_model is None:
+            name_for_model = name_for_human
+        if description_for_human is None:
+            description_for_human = description
+        if description_for_model is None:
+            description_for_model = description_for_human
+        
+        self.api_info = {
+            "schema_version": "v1",
+            "name_for_human": name_for_human,
+            "name_for_model": name_for_model,
+            "description_for_human": description_for_human,
+            "description_for_model": description_for_model,
+            "auth": {
+                "type": "none",
+            },
+            "api": {
+                "type": "openapi",
+                "url": "/openapi.json",
+                "is_user_authenticated": False,
+            },
+            "author_github": author_github,
+            "logo_url": logo_url,
+            "contact_email": contact_email,
+            "legal_info_url": legal_info_url,
+        }
+
+        @self.get("/.well-known/ai-plugin.json", include_in_schema=False)
+        def get_api_info(request : fastapi.Request):
+            openapi_path =  str(request.url).replace("/.well-known/ai-plugin.json", "/openapi.json")
+            info = copy.deepcopy(self.api_info)
+            info["api"]["url"] = str(openapi_path)
+            return info
+
+
+        self.add_middleware(
+            SessionMiddleware,
+            secret_key=tool_name,
+            session_cookie="session_{}".format(tool_name.replace(" ", "_")),
+        )
+        

bmtools/utils/logging.py

@@ -0,0 +1,279 @@
+# coding=utf-8
+# Copyright 2020 Optuna, Hugging Face
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# BMTools copied from Huggingface Transformers
+""" Logging utilities."""
+
+import logging
+import os
+import sys
+import threading
+from logging import CRITICAL  # NOQA
+from logging import DEBUG  # NOQA
+from logging import ERROR  # NOQA
+from logging import FATAL  # NOQA
+from logging import INFO  # NOQA
+from logging import NOTSET  # NOQA
+from logging import WARN  # NOQA
+from logging import WARNING  # NOQA
+from typing import Optional
+
+
+_lock = threading.Lock()
+_default_handler: Optional[logging.Handler] = None
+
+log_levels = {
+    "debug": logging.DEBUG,
+    "info": logging.INFO,
+    "warning": logging.WARNING,
+    "error": logging.ERROR,
+    "critical": logging.CRITICAL,
+}
+
+_default_log_level = logging.INFO
+
+
+def _get_default_logging_level():
+    """
+    If BMTOOLS_VERBOSITY env var is set to one of the valid choices return that as the new default level. If it is
+    not - fall back to ``_default_log_level``
+    """
+    env_level_str = os.getenv("BMTOOLS_VERBOSITY", None)
+    if env_level_str:
+        if env_level_str in log_levels:
+            return log_levels[env_level_str]
+        else:
+            logging.getLogger().warning(
+                f"Unknown option BMTOOLS_VERBOSITY={env_level_str}, "
+                f"has to be one of: { ', '.join(log_levels.keys()) }"
+            )
+    return _default_log_level
+
+
+def _get_library_name() -> str:
+
+    return __name__.split(".")[0]
+
+
+def _get_library_root_logger() -> logging.Logger:
+
+    return logging.getLogger(_get_library_name())
+
+
+def _configure_library_root_logger() -> None:
+
+    global _default_handler
+
+    with _lock:
+        if _default_handler:
+            # This library has already configured the library root logger.
+            return
+        _default_handler = logging.StreamHandler()  # Set sys.stderr as stream.
+        _default_handler.flush = sys.stderr.flush
+        formatter = logging.Formatter(
+            "\033[1;31m[%(levelname)s|(BMTools)%(module)s:%(lineno)d]%(asctime)s >> \033[0m %(message)s")
+        _default_handler.setFormatter(formatter)
+
+        # Apply our default configuration to the library root logger.
+        library_root_logger = _get_library_root_logger()
+        library_root_logger.addHandler(_default_handler)
+        library_root_logger.setLevel(_get_default_logging_level())
+
+        
+        library_root_logger.propagate = False
+
+
+def _reset_library_root_logger() -> None:
+
+    global _default_handler
+
+    with _lock:
+        if not _default_handler:
+            return
+
+        library_root_logger = _get_library_root_logger()
+        library_root_logger.removeHandler(_default_handler)
+        library_root_logger.setLevel(logging.NOTSET)
+        _default_handler = None
+
+
+def get_log_levels_dict():
+    return log_levels
+
+
+
+def get_verbosity() -> int:
+    """
+    Return the current level for the 🤗 Transformers's root logger as an int.
+    Returns:
+        :obj:`int`: The logging level.
+    <Tip>
+    🤗 Transformers has following logging levels:
+    - 50: ``transformers.logging.CRITICAL`` or ``transformers.logging.FATAL``
+    - 40: ``transformers.logging.ERROR``
+    - 30: ``transformers.logging.WARNING`` or ``transformers.logging.WARN``
+    - 20: ``transformers.logging.INFO``
+    - 10: ``transformers.logging.DEBUG``
+    </Tip>"""
+
+    _configure_library_root_logger()
+    return _get_library_root_logger().getEffectiveLevel()
+
+
+def set_verbosity(verbosity: int) -> None:
+    """
+    Set the verbosity level for the 🤗 Transformers's root logger.
+    Args:
+        verbosity (:obj:`int`):
+            Logging level, e.g., one of:
+            - ``transformers.logging.CRITICAL`` or ``transformers.logging.FATAL``
+            - ``transformers.logging.ERROR``
+            - ``transformers.logging.WARNING`` or ``transformers.logging.WARN``
+            - ``transformers.logging.INFO``
+            - ``transformers.logging.DEBUG``
+    """
+
+    _configure_library_root_logger()
+    _get_library_root_logger().setLevel(verbosity)
+
+
+def set_verbosity_info():
+    """Set the verbosity to the ``INFO`` level."""
+    return set_verbosity(INFO)
+
+
+def set_verbosity_warning():
+    """Set the verbosity to the ``WARNING`` level."""
+    return set_verbosity(WARNING)
+
+
+def set_verbosity_debug():
+    """Set the verbosity to the ``DEBUG`` level."""
+    return set_verbosity(DEBUG)
+
+
+def set_verbosity_error():
+    """Set the verbosity to the ``ERROR`` level."""
+    return set_verbosity(ERROR)
+
+
+def disable_default_handler() -> None:
+    """Disable the default handler of the HuggingFace Transformers's root logger."""
+
+    _configure_library_root_logger()
+
+    assert _default_handler is not None
+    _get_library_root_logger().removeHandler(_default_handler)
+
+
+def enable_default_handler() -> None:
+    """Enable the default handler of the HuggingFace Transformers's root logger."""
+
+    _configure_library_root_logger()
+
+    assert _default_handler is not None
+    _get_library_root_logger().addHandler(_default_handler)
+
+
+def add_handler(handler: logging.Handler) -> None:
+    """adds a handler to the HuggingFace Transformers's root logger."""
+
+    _configure_library_root_logger()
+
+    assert handler is not None
+    _get_library_root_logger().addHandler(handler)
+
+
+def remove_handler(handler: logging.Handler) -> None:
+    """removes given handler from the HuggingFace Transformers's root logger."""
+
+    _configure_library_root_logger()
+
+    assert handler is not None and handler not in _get_library_root_logger().handlers
+    _get_library_root_logger().removeHandler(handler)
+
+
+def disable_propagation() -> None:
+    """
+    Disable propagation of the library log outputs. Note that log propagation is disabled by default.
+    """
+
+    _configure_library_root_logger()
+    _get_library_root_logger().propagate = False
+
+
+def enable_propagation() -> None:
+    """
+    Enable propagation of the library log outputs. Please disable the HuggingFace Transformers's default handler to
+    prevent double logging if the root logger has been configured.
+    """
+
+    _configure_library_root_logger()
+    _get_library_root_logger().propagate = True
+
+
+def enable_explicit_format() -> None:
+    """
+    Enable explicit formatting for every HuggingFace Transformers's logger. The explicit formatter is as follows:
+    ```
+        [LEVELNAME|FILENAME|LINE NUMBER] TIME >> MESSAGE
+    ```
+    All handlers currently bound to the root logger are affected by this method.
+    """
+    handlers = _get_library_root_logger().handlers
+
+    for handler in handlers:
+        formatter = logging.Formatter("[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s")
+        handler.setFormatter(formatter)
+
+
+def reset_format() -> None:
+    """
+    Resets the formatting for HuggingFace Transformers's loggers.
+    All handlers currently bound to the root logger are affected by this method.
+    """
+    handlers = _get_library_root_logger().handlers
+
+    for handler in handlers:
+        handler.setFormatter(None)
+
+
+def warning_advice(self, *args, **kwargs):
+    """
+    This method is identical to ``logger.warning()``, but if env var TRANSFORMERS_NO_ADVISORY_WARNINGS=1 is set, this
+    warning will not be printed
+    """
+    no_advisory_warnings = os.getenv("TRANSFORMERS_NO_ADVISORY_WARNINGS", False)
+    if no_advisory_warnings:
+        return
+    self.warning(*args, **kwargs)
+
+
+logging.Logger.warning_advice = warning_advice
+
+
+def get_logger(name: Optional[str] = None, verbosity='info') -> logging.Logger:
+    """
+    Return a logger with the specified name.
+    This function is not supposed to be directly accessed unless you are writing a custom transformers module.
+    """
+
+    if name is None:
+        name = _get_library_name()
+
+    _configure_library_root_logger()
+    logger = logging.getLogger(name)
+    logger.setLevel(log_levels[verbosity])
+    return logger

requirements.txt

@@ -0,0 +1,23 @@
+pandas
+SPARQLWrapper
+Pillow
+oss2
+regex
+matplotlib
+tabulate
+python-pptx
+replicate
+bs4
+langchain
+pandasql
+SQLAlchemy==1.4.46
+openai
+gradio
+fastapi_sessions
+translate
+socksio
+py3langid
+iso-639
+transformers
+cchardet
+faiss-cpu