Upload with huggingface_hub

#agent.pmpt.txt#

@@ -0,0 +1,35 @@
+Assistant is a large language model trained by OpenAI.
+
+Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
+
+Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.
+
+Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.
+
+TOOLS:
+------
+
+Assistant has access to the following tools:
+
+{{tools_names}}
+
+To use a tool, please use the following format:
+
+```
+Thought: Do I need to use a tool? Yes
+Action: the action to take, should be one of [{{tool_names}}]
+Action Input: the input to the action
+Observation: the result of the action
+```
+
+When you have a response to say to the Human, or if you do not need to use a tool, you MUST use the format:
+
+```
+Thought: Do I need to use a tool? No
+AI: [your response here]
+```
+
+Begin!
+
+New input: {{input}}
+{{agent_scratchpad}}

#chat.py#

@@ -1,23 +1,20 @@
 # + tags=["hide_inp"]
 desc = """
-# ChatGPT
+### Chat
+
+A chat-like example for multi-turn chat with state. [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/srush/MiniChain/blob/master/examples/chat.ipynb)
+
+(Adapted from [LangChain](https://langchain.readthedocs.io/en/latest/modules/memory/examples/chatgpt_clone.html)'s version of this [blog post](https://www.engraved.blog/building-a-virtual-machine-inside/).)
 
-"ChatGPT" like examples.  Adapted from
-[LangChain](https://langchain.readthedocs.io/en/latest/modules/memory/examples/chatgpt_clone.html)'s
-version of this [blog post](https://www.engraved.blog/building-a-virtual-machine-inside/).
 """
 # -
 
 
-import warnings
-from dataclasses import dataclass
-from typing import List, Tuple
-import minichain
-
-# + tags=["hide_inp"]
-warnings.filterwarnings("ignore")
-# -
+# $
 
+from dataclasses import dataclass, replace
+from typing import List, Tuple
+from minichain import OpenAI, prompt, show, transform, Mock
 
 # Generic stateful Memory
 
@@ -32,26 +29,28 @@ class State:
         memory = self.memory if len(self.memory) < MEMORY else self.memory[1:]
         return State(memory + [(self.human_input, response)])
 
+    def __str__(self):
+        return self.memory[-1][-1]
+
 # Chat prompt with memory
 
-class ChatPrompt(minichain.TemplatePrompt):
-    template_file = "chatgpt.pmpt.tpl"
-    def parse(self, out: str, inp: State) -> State:
-        result = out.split("Assistant:")[-1]
-        return inp.push(result)
+@prompt(OpenAI(), template_file="chat.pmpt.tpl")
+def chat_response(model, state: State) -> State:
+    return model.stream(state)
 
-# class Human(minichain.Prompt):
-#     def parse(self, out: str, inp: State) -> State:
-#         return inp.human_input = out
-    
+@transform()
+def update(state, chat_output):
+    result = chat_output.split("Assistant:")[-1]
+    return state.push(result)
 
-with minichain.start_chain("chat") as backend:
-    prompt = ChatPrompt(backend.OpenAI())
-    state = State([])
 
+def chat(command, state):
+    state = replace(state, human_input=command)
+    return update(state, chat_response(state))
     
+# $
+
 examples = [
-    "I want you to act as a Linux terminal. I will type commands and you will reply with what the terminal should show. I want you to only reply with the terminal output inside one unique code block, and nothing else. Do not write explanations. Do not type commands unless I instruct you to do so. When I need to tell you something in English I will do so by putting text inside curly brackets {like this}. My first command is pwd.",
     "ls ~",
     "cd ~",
     "{Please make a file jokes.txt inside and put some jokes inside}",
@@ -61,16 +60,17 @@ examples = [
     "nvidia-smi"
 ]
 
-gradio = prompt.to_gradio(fields= ["human_input"],
-                          initial_state= state,
-                          examples=examples,
-                          out_type="json",
-                          description=desc
+print(chat("ls", State([])).run())
+
+gradio = show(chat,
+              initial_state=State([]),
+              subprompts=[chat_response],
+              examples=examples,
+              out_type="json",
+              description=desc,
+              code=open("chat.py", "r").read().split("$")[1].strip().strip("#").strip(),
 )
 if __name__ == "__main__":
-    gradio.launch()
+    gradio.queue().launch()
 
-# for i in range(len(fake_human)):
-#     human.chain(prompt)
 
-    

#ner.py#

@@ -1,71 +1,46 @@
 # + tags=["hide_inp"]
 
 desc = """
-# NER
+### Named Entity Recognition
 
-Notebook implementation of named entity recognition.
-Adapted from [promptify](https://github.com/promptslab/Promptify/blob/main/promptify/prompts/nlp/templates/ner.jinja).
+Chain that does named entity recognition with arbitrary labels. [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/srush/MiniChain/blob/master/examples/ner.ipynb)
+
+(Adapted from [promptify](https://github.com/promptslab/Promptify/blob/main/promptify/prompts/nlp/templates/ner.jinja)).
 """
 # -
 
-import json
-
-import minichain
+# $
 
-# Prompt to extract NER tags as json
-
-class NERPrompt(minichain.TemplatePrompt):
-    template_file = "ner.pmpt.tpl"
+from minichain import prompt, transform, show, OpenAI
+import json
 
-    def parse(self, response, inp):
-        return json.loads(response)
+@prompt(OpenAI(), template_file = "ner.pmpt.tpl")
+def ner_extract(model, kwargs):
+    return model(kwargs)
 
-# Use NER to ask a simple queston.
+@transform()
+def to_json(chat_output):
+    return json.loads(chat_output)
 
-class TeamPrompt(minichain.Prompt):
-    def prompt(self, inp):
-        return "Can you describe these basketball teams? " + \
-            " ".join([i["E"] for i in inp if i["T"] =="Team"])
+@prompt(OpenAI())
+def team_describe(model, inp):
+    query = "Can you describe these basketball teams? " + \
+        " ".join([i["E"] for i in inp if i["T"] =="Team"])
+    return model(query)
 
-    def parse(self, response, inp):
-        return response
 
-# Run the system.
+def ner(text_input, labels, domain):
+    extract = to_json(ner_extract(dict(text_input=text_input, labels=labels, domain=domain)))
+    return team_describe(extract)
 
-with minichain.start_chain("ner") as backend:
-    ner_prompt = NERPrompt(backend.OpenAI())
-    team_prompt = TeamPrompt(backend.OpenAI())
-    prompt = ner_prompt.chain(team_prompt)
-    # results = prompt(
-    #     {"text_input": "An NBA playoff pairing a year ago, the 76ers (39-20) meet the Miami Heat (32-29) for the first time this season on Monday night at home.",
-    #      "labels" : ["Team", "Date"],
-    #      "domain": "Sports"
-    #      }
-    # )
-    # print(results)
+# $
 
-gradio = prompt.to_gradio(fields =["text_input", "labels", "domain"],
-                          examples=[["An NBA playoff pairing a year ago, the 76ers (39-20) meet the Miami Heat (32-29) for the first time this season on Monday night at home.", "Team, Date", "Sports"]],
-                          description=desc)
+gradio = show(ner,
+              examples=[["An NBA playoff pairing a year ago, the 76ers (39-20) meet the Miami Heat (32-29) for the first time this season on Monday night at home.", "Team, Date", "Sports"]],
+              description=desc,
+              subprompts=[ner_extract, team_describe],
+              code=open("ner.py", "r").read().split("$")[1].strip().strip("#").strip(),
+              )
 
-    
 if __name__ == "__main__":
-    gradio.launch()
-
-    
-# View prompt examples.
-
-# + tags=["hide_inp"]
-# NERPrompt().show(
-#     {
-#         "input": "I went to New York",
-#         "domain": "Travel",
-#         "labels": ["City"]
-#     },
-#     '[{"T": "City", "E": "New York"}]',
-# )
-# # -
-
-# # View log.
-
-# minichain.show_log("ner.log")
+    gradio.queue().launch()

agent.pmpt.tpl

@@ -0,0 +1,37 @@
+Assistant is a large language model trained by OpenAI.
+
+Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
+
+Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.
+
+Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.
+
+TOOLS:
+------
+
+Assistant has access to the following tools:
+
+{% for tool in tools%}
+{{tool[0]}}: {{tool[1]}}
+{% endfor %}
+
+To use a tool, you MUST use exactly the following format:
+
+```
+Thought: Do I need to use a tool? Yes
+Action: the action to take, should be one of [{% for tool in tools%}{{tool[0]}}, {% endfor %}]
+Action Input: the input to the action
+Observation: the result of the action
+```
+
+When you have a response to say to the Human, or if you do not need to use a tool, you MUST use the format:
+
+```
+Thought: Do I need to use a tool? No
+AI: [your response here]
+```
+
+Do NOT output in any other format. Begin!
+
+New input: {{input}}
+{{agent_scratchpad}}

agent.pmpt.tpl~

@@ -0,0 +1,38 @@
+Assistant is a large language model trained by OpenAI.
+
+Assistant is designed to be able to assist with a wide range of tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. As a language model, Assistant is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
+
+Assistant is constantly learning and improving, and its capabilities are constantly evolving. It is able to process and understand large amounts of text, and can use this knowledge to provide accurate and informative responses to a wide range of questions. Additionally, Assistant is able to generate its own text based on the input it receives, allowing it to engage in discussions and provide explanations and descriptions on a wide range of topics.
+
+Overall, Assistant is a powerful tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics. Whether you need help with a specific question or just want to have a conversation about a particular topic, Assistant is here to assist.
+
+TOOLS:
+------
+
+Assistant has access to the following tools:
+
+{{tools_names}}
+
+To use a tool, please use the following format:
+
+```
+Thought: Do I need to use a tool? Yes
+Action: the action to take, should be one of [{{tool_names}}]
+Action Input: the input to the action
+Observation: the result of the action
+```
+
+When you have a response to say to the Human, or if you do not need to use a tool, you MUST use the format:
+
+```
+Thought: Do I need to use a tool? No
+AI: [your response here]
+```
+
+Begin!
+
+Previous conversation history:
+{{chat_history}}
+
+New input: {{input}}
+{{agent_scratchpad}}

agent.pmpt.txt

@@ -11,6 +11,8 @@ TOOLS:
 
 Assistant has access to the following tools:
 
+{{tools_names}}
+
 To use a tool, please use the following format:
 
 ```
@@ -29,8 +31,5 @@ AI: [your response here]
 
 Begin!
 
-Previous conversation history:
-{{chat_history}}
-
 New input: {{input}}
 {{agent_scratchpad}}

agent.pmpt.txt~

@@ -11,6 +11,8 @@ TOOLS:
 
 Assistant has access to the following tools:
 
+{{tools_names}}
+
 To use a tool, please use the following format:
 
 ```
@@ -24,13 +26,13 @@ When you have a response to say to the Human, or if you do not need to use a too
 
 ```
 Thought: Do I need to use a tool? No
-{{ai_prefix}}: [your response here]
-```"""
+AI: [your response here]
+```
 
 Begin!
 
 Previous conversation history:
-{chat_history}
+{{chat_history}}
 
-New input: {input}
-{agent_scratchpad}
+New input: {{input}}
+{{agent_scratchpad}}

agent.py

@@ -1,51 +1,82 @@
 # + tags=["hide_inp"]
 
 desc = """
-### Gradio Tool
+### Agent
 
-Chain that ask for a command-line question and then runs the bash command. [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/srush/MiniChain/blob/master/examples/bash.ipynb)
+Chain that executes different tools based on model decisions. [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/srush/MiniChain/blob/master/examples/bash.ipynb)
 
-(Adapted from LangChain [BashChain](https://langchain.readthedocs.io/en/latest/modules/chains/examples/llm_bash.html))
+(Adapted from LangChain )
 """
 # -
 
 # $
 
-from minichain import show, prompt, OpenAI
-from gradio_tools.tools import StableDiffusionTool, ImageCaptioningTool
-
-class Tool1:
-    description: str = "Tool 1"
-    def run(self, prompt):
-        return prompt
-
-class Tool2:
-    description: str = "Tool 2"
-    def run(self, prompt):
-        return prompt
-
-
-@prompt(StableDiffusionTool())
-def gen(model, query):
-    return model(query)
-
-@prompt(ImageCaptioningTool())
-def caption(model, img_src):
-    return model(img_src)
-
-
-def gradio_example(query):
-    return caption(gen(query))
-
+from minichain import Id, prompt, OpenAI, show, transform, Mock, Break
+from gradio_tools.tools import StableDiffusionTool, ImageCaptioningTool, ImageToMusicTool
+
+
+# class ImageCaptioningTool:
+#     def run(self, inp):
+#         return "This is a picture of a smiling huggingface logo."
+
+#     description = "Image Captioning"
+
+tools = [StableDiffusionTool(), ImageCaptioningTool(), ImageToMusicTool()]
+
+
+@prompt(OpenAI(stop=["Observation:"]),
+        template_file="agent.pmpt.tpl")
+def agent(model, query, history):
+    return model(dict(tools=[(str(tool.__class__.__name__), tool.description)
+                             for tool in tools],
+                      input=query,
+                      agent_scratchpad=history
+                      ))
+@transform()
+def tool_parse(out):
+    lines = out.split("\n")
+    if lines[0].split("?")[-1].strip() == "Yes":
+        tool = lines[1].split(":", 1)[-1].strip()
+        command = lines[2].split(":", 1)[-1].strip()
+        return tool, command
+    else:
+        return Break()
+
+@prompt(tools)
+def tool_use(model, usage):
+    selector, command = usage
+    for i, tool in enumerate(tools):
+        if selector == tool.__class__.__name__:
+            return model(command, tool_num=i)
+    return ("",)
+
+@transform()
+def append(history, new, observation):
+    return history + "\n" + new + "Observation: " + observation
+
+def run(query):
+    history = ""
+    observations = []
+    for i in range(3):
+        select_input = agent(query, history)
+        observations.append(tool_use(tool_parse(select_input)))
+        history = append(history, select_input, observations[i])
+
+    return observations[-1]
 
 # $
 
-gradio = show(gradio_example,
-              subprompts=[caption],
-              examples=['/home/srush/Projects/MiniChain/examples/63dd90c7-9b8d-4ba4-bc07-a378fd932304/tmph3xi9ylr.jpg', 'Make me a flower'],
+gradio = show(run,
+              subprompts=[agent, tool_use] * 3,
+              examples=[
+                  "I would please like a photo of a dog riding a skateboard. "
+                  "Please caption this image and create a song for it.",
+                  'Use an image generator tool to draw a cat.',
+                  'Caption the image https://huggingface.co/datasets/huggingface/brand-assets/resolve/main/hf-logo.png from the internet'],
               out_type="markdown",
-              description=desc
+              description=desc,
+              show_advanced=False
               )
 if __name__ == "__main__":
-    gradio.launch()
+    gradio.queue().launch()
 

agent.py~

@@ -0,0 +1,75 @@
+# + tags=["hide_inp"]
+
+desc = """
+### Gradio Tool
+
+Chain that ask for a command-line question and then runs the bash command. [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/srush/MiniChain/blob/master/examples/bash.ipynb)
+
+(Adapted from LangChain [BashChain](https://langchain.readthedocs.io/en/latest/modules/chains/examples/llm_bash.html))
+"""
+# -
+
+# $
+
+from minichain import Id, prompt, OpenAIStream
+from gradio_tools.tools import StableDiffusionTool, ImageCaptioningTool
+
+    
+
+@prompt(StableDiffusionTool())
+def gen(model, query):
+    return model(query)
+
+@prompt(ImageCaptioningTool())
+def caption(model, img_src):
+    return model(img_src)
+
+tools = [gen, caption]
+
+@prompt(Id(),
+        #OpenAIStream(), stream=True,
+        template_file="agent.pmpt.tpl")
+def agent(model, query):
+    print(model(dict(tools=[(str(tool.backend.__class__), tool.backend.description)
+                            for tool in tools],
+                     input=query
+                     )))
+    return ("StableDiffusionTool", "Draw a flower")
+    # out = ""
+    # for t in model.stream(dict(tools=[(str(tool.backend.__class__), tool.backend.description)
+    #                                   for tool in tools],
+    #                       input=query
+    #                       )):
+    #     out += t
+    #     yield out
+    # lines = out.split("\n")
+    # response = lines[0].split("?")[1].strip()
+    # if response == "Yes":
+    #     tool = lines[1].split(":")[1].strip()
+    #     yield tool
+
+@prompt(dynamic=tools)
+def selector(model, input):
+    selector, input = input
+    if selector == "StableDiffusionTool":
+        return model.tool(input, tool_num=0)
+    else:
+        return model.tool(input, tool_num=1)
+        
+
+def run(query):
+    select_input = agent(query)
+    return selector(select_input)
+
+run("make a pic").run()
+# $
+
+gradio = show(run,
+              subprompts=[agent, selector],
+              examples=['Draw me a flower'],
+              out_type="markdown",
+              description=desc
+              )
+if __name__ == "__main__":
+    gradio.launch()
+

app.py

@@ -8,22 +8,26 @@ from gatsby import gradio as gatsby
 from qa import gradio as qa
 from stats import gradio as stats
 from selfask import gradio as selfask
-from backtrack import gradio as backtrack
 from table import gradio as table
+from agent import gradio as agent
 from gradio_example import gradio as gradio_example
 
 CSS = """
-#clean div.form {border: 0px} 
-#response {border: 0px; background: #ffeec6} 
-#prompt {border: 0px;background: aliceblue} 
-div.gradio-container {color: black}
+#clean div.form {border: 0px}
+#response {border: 0px; background: #ffeec6}
+#prompt {border: 0px;background: aliceblue}
+#json {border: 0px}
 span.head {font-size: 60pt; font-family: cursive;}
+div.gradio-container {color: black}
+div.form {background: inherit}
+div.form div.block {padding: 0px; background: #fcfcfc}
 body {
   --text-sm: 12px;
   --text-md: 16px;
   --text-lg: 18px;
   --input-text-size: 16px;
   --section-text-size: 16px;
+  --input-background: --neutral-50;
 }
 """
 
@@ -32,8 +36,8 @@ body {
 with gr.Blocks(css=CSS, theme=gr.themes.Monochrome()) as demo:
     gr.HTML("<center style='background:#B6B7BA'> <span class='head'>Mini</span><img src='https://user-images.githubusercontent.com/35882/227017900-0cacdfb7-37e2-47b1-9347-a233810d3544.png' width='20%' style='display:inline'><span class='head'>Chain</span></center><center> <br><a href='https://github.com/srush/minichain'>[library]</a> </center>")
 
-    gr.TabbedInterface([math_demo, qa,  chat, gatsby,  ner, bash, pal, table, gradio_example, stats, selfask, backtrack],
-                       ["Math", "QA", "Chat", "Book", "NER", "Bash", "PAL", "Table", "Gradio", "Stats", "SelfAsk", "Backtrack"],
+    gr.TabbedInterface([math_demo, qa,  agent, chat, gatsby,  ner, bash, pal, table, gradio_example, stats, selfask],
+                       ["Math", "QA", "Agent", "Chat", "Book", "NER", "Bash", "PAL", "Table", "Gradio", "Stats", "SelfAsk"],
                        css = CSS)
 
 demo.queue().launch()

app.py~

@@ -9,15 +9,13 @@ from qa import gradio as qa
 from stats import gradio as stats
 from selfask import gradio as selfask
 from backtrack import gradio as backtrack
+from table import gradio as table
+from gradio_example import gradio as gradio_example
 
 CSS = """
 #clean div.form {border: 0px} 
 #response {border: 0px; background: #ffeec6} 
 #prompt {border: 0px;background: aliceblue} 
-#json {border: 0px} 
-#result {border: 0px; background: #c5e0e5} 
-#inner {margin: 10px; padding: 10px; font-size: 20px; } 
-#inner textarea {border: 0px}
 div.gradio-container {color: black}
 span.head {font-size: 60pt; font-family: cursive;}
 body {
@@ -34,9 +32,9 @@ body {
 with gr.Blocks(css=CSS, theme=gr.themes.Monochrome()) as demo:
     gr.HTML("<center style='background:#B6B7BA'> <span class='head'>Mini</span><img src='https://user-images.githubusercontent.com/35882/227017900-0cacdfb7-37e2-47b1-9347-a233810d3544.png' width='20%' style='display:inline'><span class='head'>Chain</span></center><center> <br><a href='https://github.com/srush/minichain'>[library]</a> </center>")
 
-    gr.TabbedInterface([math_demo, qa,  chat, gatsby,  ner, bash, pal, stats, selfask, backtrack],
-                       ["Math", "QA", "Chat", "Book", "NER", "Bash", "PAL", "Stats", "SelfAsk", "Backtrack"],
+    gr.TabbedInterface([math_demo, qa,  chat, gatsby,  ner, bash, pal, table, gradio_example, stats, selfask, backtrack],
+                       ["Math", "QA", "Chat", "Book", "NER", "Bash", "PAL", "Table", "Gradio", "Stats", "SelfAsk", "Backtrack"],
                        css = CSS)
 
-demo.launch()
+demo.queue().launch()
 

bash.py

@@ -16,11 +16,11 @@ from minichain import show, prompt, OpenAI, Bash
 
 @prompt(OpenAI(), template_file = "bash.pmpt.tpl")
 def cli_prompt(model, query):
-    x = model(dict(question=query))
-    return "\n".join(x.strip().split("\n")[1:-1])
+    return model(dict(question=query))
 
 @prompt(Bash())
 def bash_run(model, x):
+    x = "\n".join(x.strip().split("\n")[1:-1])
     return model(x)
 
 def bash(query):

chat.py

@@ -14,7 +14,7 @@ A chat-like example for multi-turn chat with state. [![Open In Colab](https://co
 
 from dataclasses import dataclass, replace
 from typing import List, Tuple
-from minichain import OpenAI, prompt, show
+from minichain import OpenAI, prompt, show, transform, Mock
 
 # Generic stateful Memory
 
@@ -35,11 +35,19 @@ class State:
 # Chat prompt with memory
 
 @prompt(OpenAI(), template_file="chat.pmpt.tpl")
-def chat_prompt(model, state: State) -> State:
-    out = model(state)
-    result = out.split("Assistant:")[-1]
+def chat_response(model, state: State) -> State:
+    return model.stream(state)
+
+@transform()
+def update(state, chat_output):
+    result = chat_output.split("Assistant:")[-1]
     return state.push(result)
 
+
+def chat(command, state):
+    state = replace(state, human_input=command)
+    return update(state, chat_response(state))
+
 # $
 
 examples = [
@@ -52,9 +60,11 @@ examples = [
     "nvidia-smi"
 ]
 
-gradio = show(lambda command, state: chat_prompt(replace(state, human_input=command)),
+print(chat("ls", State([])).run())
+
+gradio = show(chat,
               initial_state=State([]),
-              subprompts=[chat_prompt],
+              subprompts=[chat_response],
               examples=examples,
               out_type="json",
               description=desc,

fake_agent.py

@@ -0,0 +1,59 @@
+# + tags=["hide_inp"]
+
+desc = """
+### Gradio Tool
+
+Chain that ask for a command-line question and then runs the bash command. [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/srush/MiniChain/blob/master/examples/bash.ipynb)
+
+(Adapted from LangChain [BashChain](https://langchain.readthedocs.io/en/latest/modules/chains/examples/llm_bash.html))
+"""
+# -
+
+# $
+
+from minichain import Mock, prompt, OpenAIStream, show
+from gradio_tools.tools import StableDiffusionTool, ImageCaptioningTool
+
+    
+@prompt(Mock(["Tool1"]))
+def tool1(model, query):
+    return model(query)
+
+@prompt(Mock(["Tool2"]))
+def tool2(model, img_src):
+    return model(img_src)
+
+tools = [tool1, tool2]
+
+@prompt(Mock(["Tool1: draw a flower", "Tool2: call mom"]))
+def agent(model, query):
+    return model(query).split(":")
+
+@prompt(dynamic=tools)
+def selector(model, input):
+    selector, input = input
+    if selector == "Tool1":
+        return model.tool(input, tool_num=0)
+    else:
+        return model.tool(input, tool_num=1)
+        
+
+def run(query):
+    select_input = agent(query)
+    out = selector(select_input)
+    select_input = agent(out)
+    return selector(select_input)
+
+run("make a pic").run()
+# $
+
+gradio = show(run,
+              subprompts=[agent, selector, agent, selector],
+              examples=['Draw me a flower'],
+              out_type="markdown",
+              description=desc,
+              show_advanced=False
+              )
+if __name__ == "__main__":
+    gradio.queue().launch()
+

fake_agent.py~

@@ -0,0 +1,75 @@
+# + tags=["hide_inp"]
+
+desc = """
+### Gradio Tool
+
+Chain that ask for a command-line question and then runs the bash command. [![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/srush/MiniChain/blob/master/examples/bash.ipynb)
+
+(Adapted from LangChain [BashChain](https://langchain.readthedocs.io/en/latest/modules/chains/examples/llm_bash.html))
+"""
+# -
+
+# $
+
+from minichain import Id, prompt, OpenAIStream
+from gradio_tools.tools import StableDiffusionTool, ImageCaptioningTool
+
+    
+
+@prompt(StableDiffusionTool())
+def gen(model, query):
+    return model(query)
+
+@prompt(ImageCaptioningTool())
+def caption(model, img_src):
+    return model(img_src)
+
+tools = [gen, caption]
+
+@prompt(Id(),
+        #OpenAIStream(), stream=True,
+        template_file="agent.pmpt.tpl")
+def agent(model, query):
+    print(model(dict(tools=[(str(tool.backend.__class__), tool.backend.description)
+                            for tool in tools],
+                     input=query
+                     )))
+    return ("StableDiffusionTool", "Draw a flower")
+    # out = ""
+    # for t in model.stream(dict(tools=[(str(tool.backend.__class__), tool.backend.description)
+    #                                   for tool in tools],
+    #                       input=query
+    #                       )):
+    #     out += t
+    #     yield out
+    # lines = out.split("\n")
+    # response = lines[0].split("?")[1].strip()
+    # if response == "Yes":
+    #     tool = lines[1].split(":")[1].strip()
+    #     yield tool
+
+@prompt(dynamic=tools)
+def selector(model, input):
+    selector, input = input
+    if selector == "StableDiffusionTool":
+        return model.tool(input, tool_num=0)
+    else:
+        return model.tool(input, tool_num=1)
+        
+
+def run(query):
+    select_input = agent(query)
+    return selector(select_input)
+
+run("make a pic").run()
+# $
+
+gradio = show(run,
+              subprompts=[agent, selector],
+              examples=['Draw me a flower'],
+              out_type="markdown",
+              description=desc
+              )
+if __name__ == "__main__":
+    gradio.launch()
+

gatsby.py

@@ -12,7 +12,7 @@ Chain that does question answering with Hugging Face embeddings. [![Open In Cola
 
 import datasets
 import numpy as np
-from minichain import prompt, show, HuggingFaceEmbed, OpenAI
+from minichain import prompt, show, HuggingFaceEmbed, OpenAI, transform
 
 # Load data with embeddings (computed beforehand)
 
@@ -22,18 +22,20 @@ gatsby.add_faiss_index("embeddings")
 # Fast KNN retrieval prompt
 
 @prompt(HuggingFaceEmbed("sentence-transformers/all-mpnet-base-v2"))
-def get_neighbors(model, inp, k=1):
-    embedding = model(inp)
+def embed(model, inp):
+    return model(inp)
+
+@transform()
+def get_neighbors(embedding, k=1):
     res = gatsby.get_nearest_examples("embeddings", np.array(embedding), k)
     return res.examples["passages"]
 
-@prompt(OpenAI(),
-        template_file="gatsby.pmpt.tpl")
+@prompt(OpenAI(), template_file="gatsby.pmpt.tpl")
 def ask(model, query, neighbors):
     return model(dict(question=query, docs=neighbors))
 
 def gatsby_q(query):
-    n = get_neighbors(query)
+    n = get_neighbors(embed(query))
     return ask(query, n)
 
 
@@ -41,7 +43,7 @@ def gatsby_q(query):
 
 
 gradio = show(gatsby_q,
-              subprompts=[get_neighbors, ask],
+              subprompts=[ask],
               examples=["What did Gatsby do before he met Daisy?",
                         "What did the narrator do after getting back to Chicago?"],
               keys={"HF_KEY"},

gradio_example.py

@@ -10,24 +10,25 @@ Examples using the gradio tool [![Open In Colab](https://colab.research.google.c
 
 # $
 
-from minichain import show, prompt, OpenAI, OpenAIStream
+from minichain import show, prompt, OpenAI, GradioConf
 import gradio as gr
 from gradio_tools.tools import StableDiffusionTool, ImageCaptioningTool
 
-@prompt(OpenAIStream(), stream=True)
+@prompt(OpenAI())
 def picture(model, query):
-    out = ""
-    for r in model.stream(query):
-        out += r
-        yield out
+    return model(query)
 
-@prompt(StableDiffusionTool(), stream=True, block_input=lambda: gr.Textbox(label=""))
+@prompt(StableDiffusionTool(),
+        gradio_conf=GradioConf(
+            block_output= lambda: gr.Image(),
+            block_input= lambda: gr.Textbox(show_label=False)))
 def gen(model, query):
-    for r in model.stream(query):
-        yield "https://htmlcolorcodes.com/assets/images/colors/baby-blue-color-solid-background-1920x1080.png"
-    yield r
+    return model(query)
 
-@prompt(ImageCaptioningTool(), block_output=lambda: gr.Textbox(label=""))
+@prompt(ImageCaptioningTool(),
+        gradio_conf=GradioConf(
+            block_input= lambda: gr.Image(),
+            block_output=lambda: gr.Textbox(show_label=False)))
 def caption(model, img_src):
     return model(img_src)
 
@@ -43,8 +44,7 @@ gradio = show(gradio_example,
                         'Describe a one-sentence scene happening on the moon.'],
               out_type="markdown",
               description=desc,
-              css="#advanced {display: none}"
-
+              show_advanced=False
               )
 if __name__ == "__main__":
     gradio.queue().launch()

math_demo.py

@@ -10,11 +10,14 @@ Chain that solves a math word problem by first generating and then running Pytho
 
 # $
 
-from minichain import show, prompt, OpenAI, Python
+from minichain import show, prompt, OpenAI, Python, GradioConf
+import gradio as gr
 
 
-@prompt(OpenAI(), template_file="math.pmpt.tpl")
-def math_prompt(model, question):
+@prompt(OpenAI(), template_file="math.pmpt.tpl",
+        gradio_conf=GradioConf(block_input=gr.Markdown))
+def math_prompt(model, question
+                ):
     "Prompt to call GPT with a Jinja template"
     return model(dict(question=question))
 
@@ -22,7 +25,7 @@ def math_prompt(model, question):
 def python(model, code):
     "Prompt to call Python interpreter"
     code = "\n".join(code.strip().split("\n")[1:-1])
-    return int(model(dict(code=code)))
+    return model(dict(code=code))
 
 def math_demo(question):
     "Chain them together"
@@ -36,7 +39,6 @@ gradio = show(math_demo,
                         "What is the sum of the 10 first positive integers?",],
                         # "Carla is downloading a 200 GB file. She can download 2 GB/minute, but 40% of the way through the download, the download fails. Then Carla has to restart the download from the beginning. How load did it take her to download the file in minutes?"],
               subprompts=[math_prompt, python],
-              out_type="json",
               description=desc,
               code=open("math_demo.py", "r").read().split("$")[1].strip().strip("#").strip(),
               )

ner.py

@@ -11,12 +11,17 @@ Chain that does named entity recognition with arbitrary labels. [![Open In Colab
 
 # $
 
-from minichain import prompt, show, OpenAI
+from minichain import prompt, transform, show, OpenAI
+import json
 
-@prompt(OpenAI(), template_file = "ner.pmpt.tpl", parser="json")
+@prompt(OpenAI(), template_file = "ner.pmpt.tpl")
 def ner_extract(model, kwargs):
     return model(kwargs)
 
+@transform()
+def to_json(chat_output):
+    return json.loads(chat_output)
+
 @prompt(OpenAI())
 def team_describe(model, inp):
     query = "Can you describe these basketball teams? " + \
@@ -25,7 +30,7 @@ def team_describe(model, inp):
 
 
 def ner(text_input, labels, domain):
-    extract = ner_extract(dict(text_input=text_input, labels=labels, domain=domain))
+    extract = to_json(ner_extract(dict(text_input=text_input, labels=labels, domain=domain)))
     return team_describe(extract)
 
 

pal.py

@@ -8,20 +8,17 @@ Chain for answering complex problems by code generation and execution. [![Open I
 
 # $
 
-from minichain import prompt, show, OpenAIStream, Python
+from minichain import prompt, show, GradioConf, OpenAI, Python
 import gradio as gr
 
-@prompt(OpenAIStream(), template_file="pal.pmpt.tpl", stream=True)
+@prompt(OpenAI(), template_file="pal.pmpt.tpl")
 def pal_prompt(model, question):
-    out = ""
-    for t in model.stream(dict(question=question)):
-        out += t
-        yield out
+    return model(dict(question=question))
 
-@prompt(Python(), block_input=lambda: gr.Code(language="python"))
+@prompt(Python(),
+        gradio_conf=GradioConf(block_input = lambda: gr.Code(language="python")))
 def python(model, inp):
-    print(inp)
-    return float(model(inp + "\nprint(solution())"))
+    return model(inp + "\nprint(solution())")
 
 def pal(question):
     return python(pal_prompt(question))

qa.py

@@ -12,7 +12,7 @@ Chain that answers questions with embeedding based retrieval. [![Open In Colab](
 
 import datasets
 import numpy as np
-from minichain import prompt, show, OpenAIEmbed, OpenAI
+from minichain import prompt, transform, show, OpenAIEmbed, OpenAI
 from manifest import Manifest
 
 # We use Hugging Face Datasets as the database by assigning
@@ -25,18 +25,20 @@ olympics.add_faiss_index("embeddings")
 # Fast KNN retieval prompt
 
 @prompt(OpenAIEmbed())
-def get_neighbors(model, inp, k):
-    embedding = model(inp)
-    res = olympics.get_nearest_examples("embeddings", np.array(embedding), k)
+def embed(model, inp):
+    return model(inp)
+
+@transform()
+def get_neighbors(inp, k):
+    res = olympics.get_nearest_examples("embeddings", np.array(inp), k)
     return res.examples["content"]
 
-@prompt(OpenAI(),
-        template_file="qa.pmpt.tpl")
+@prompt(OpenAI(), template_file="qa.pmpt.tpl")
 def get_result(model, query, neighbors):
     return model(dict(question=query, docs=neighbors))
 
 def qa(query):
-    n = get_neighbors(query, 3)
+    n = get_neighbors(embed(query), 3)
     return get_result(query, n)
 
 # $
@@ -50,7 +52,7 @@ questions = ["Who won the 2020 Summer Olympics men's high jump?",
 
 gradio = show(qa,
               examples=questions,
-              subprompts=[get_neighbors, get_result],
+              subprompts=[embed, get_result],
               description=desc,
               code=open("qa.py", "r").read().split("$")[1].strip().strip("#").strip(),
               )

requirements.gradio_example.txt

@@ -0,0 +1,2 @@
+minichain
+git+https://github.com/freddyaboulton/gradio-tools/

selfask.py

@@ -11,7 +11,7 @@ desc = """
 
 from dataclasses import dataclass, replace
 from typing import Optional
-from minichain import prompt, show, OpenAI, Google
+from minichain import prompt, show, OpenAI, Google, transform
 
 
 @dataclass
@@ -22,12 +22,14 @@ class State:
     final_answer: Optional[str] = None
 
 
-@prompt(OpenAI(),
-        template_file = "selfask.pmpt.tpl",
-        stop_template = "\nIntermediate answer:")
+@prompt(OpenAI(stop="\nIntermediate answer:"),
+        template_file = "selfask.pmpt.tpl")
 def self_ask(model, state):
-    out = model(state)
-    res = out.split(":", 1)[1]
+    return model(state)
+
+@transform()
+def next_step(ask):
+    res = ask.split(":", 1)[1]
     if out.startswith("Follow up:"):
         return replace(state, next_query=res)
     elif out.startswith("So the final answer is:"):
@@ -36,17 +38,22 @@ def self_ask(model, state):
 @prompt(Google())
 def google(model, state):
     if state.next_query is None:
-        return state
+        return ""
 
-    result = model(state.next_query)
+    return model(state.next_query)
+
+@transform()
+def update(state, result):
+    if not result:
+        return state
     return State(state.question,
                  state.history + "\nIntermediate answer: " + result + "\n")
 
 def selfask(question):
     state = State(question)
     for i in range(3):
-        state = self_ask(state)
-        state = google(state)
+        state = next_step(self_ask(state))
+        state = update(google(state))
     return state
 
 # $

stats.py

@@ -9,10 +9,41 @@ Information extraction that is automatically generated from a typed specificatio
 
 # $
 
-from minichain import prompt, show, type_to_prompt, OpenAI
-from dataclasses import dataclass
-from typing import List
+from minichain import prompt, show, OpenAI, transform
+from dataclasses import dataclass, is_dataclass, fields
+from typing import List, Type, Dict, Any, get_origin, get_args
 from enum import Enum
+from jinja2 import select_autoescape, FileSystemLoader, Environment
+import json
+
+def enum(x: Type[Enum]) -> Dict[str, int]:
+    d = {e.name: e.value for e in x}
+    return d
+
+
+def walk(x: Any) -> Any:
+    if issubclass(x if get_origin(x) is None else get_origin(x), List):
+        return {"_t_": "list", "t": walk(get_args(x)[0])}
+    if issubclass(x, Enum):
+        return enum(x)
+
+    if is_dataclass(x):
+        return {y.name: walk(y.type) for y in fields(x)}
+    return x.__name__
+
+
+def type_to_prompt(out: type) -> str:
+    tmp = env.get_template("type_prompt.pmpt.tpl")
+    d = walk(out)
+    return tmp.render({"typ": d})
+
+env = Environment(
+    loader=FileSystemLoader("."),
+    autoescape=select_autoescape(),
+    extensions=["jinja2_highlight.HighlightExtension"],
+)
+
+
 
 # Data specification
 
@@ -34,15 +65,18 @@ class Player:
 # -
 
 
-@prompt(OpenAI(), template_file="stats.pmpt.tpl", parser="json")
+@prompt(OpenAI(), template_file="stats.pmpt.tpl")
 def stats(model, passage):
-    out = model(dict(passage=passage, typ=type_to_prompt(Player)))
-    return [Player(**j) for j in out]
+    return model.stream(dict(passage=passage, typ=type_to_prompt(Player)))
+
+@transform()
+def to_data(s:str):
+    return [Player(**j) for j in json.loads(s)]
 
 # $
 
 article = open("sixers.txt").read()
-gradio = show(lambda passage: stats(passage),
+gradio = show(lambda passage: to_data(stats(passage)),
               examples=[article],
               subprompts=[stats],
               out_type="json",

table.py

@@ -9,12 +9,13 @@ Example of extracting tables from a textual document. [![Open In Colab](https://
 
 # $
 import pandas as pd
-from minichain import prompt, Mock, show, OpenAIStream
+from minichain import prompt, Mock, show, OpenAI, GradioConf
 import minichain
 import json
 import gradio as gr
+import requests
 
-rotowire = json.load(open("data.json"))
+rotowire = requests.get("https://raw.githubusercontent.com/srush/text2table/main/data.json").json()
 names = {
     '3-pointer percentage': 'FG3_PCT',
     '3-pointers attempted': 'FG3A',
@@ -52,30 +53,26 @@ for i in range(few_shot_examples):
     examples.append({"input": rotowire[i][1],
                      "output": to_df(rotowire[i][0][1]).transpose().set_index("player").to_csv(sep="\t")})
 
-@prompt(OpenAIStream(),
-        template_file="table.pmpt.txt",
-        block_output=gr.HTML,
-        stream=True)
-def extract(model, passage, typ):
-    state = []
-    out = ""
-    for token in model.stream(dict(player_keys=names.items(), examples=examples, passage=passage, type=typ)):
-        out += token
-        html = "<table><tr><td>" + out.replace("\t", "</td><td>").replace("\n", "</td></tr><tr><td>")  + "</td></td></table>"
-        yield html
-    yield html
-
+def make_html(out):
+    return "<table><tr><td>" + out.replace("\t", "</td><td>").replace("\n", "</td></tr><tr><td>")  + "</td></td></table>"
 
+@prompt(OpenAI(), template_file="table.pmpt.txt",
+        gradio_conf=GradioConf(block_output=gr.HTML,
+                               postprocess_output = make_html)
+        )
+def extract(model, passage, typ):
+    return model(dict(player_keys=names.items(), examples=examples, passage=passage, type=typ))
 
 def run(query):
     return extract(query, "Player")
 
 # $
 
+import os
 gradio = show(run,
               examples = [rotowire[i][1] for i in range(50, 55)],
               subprompts=[extract],
-              code=open("table.py", "r").read().split("$")[1].strip().strip("#").strip(),
+              code=open("table.py" if os.path.exists("table.py") else "app.py", "r").read().split("$")[1].strip().strip("#").strip(),
               out_type="markdown"
             )
 

type_prompt.pmpt.tpl

@@ -0,0 +1,26 @@
+You are a highly intelligent and accurate information extraction system. You take passage as input and your task is to find parts of the passage to answer questions.
+
+{% macro describe(typ) -%}
+{% for key, val in typ.items() %}
+You need to classify in to the following types for key: "{{key}}":
+{% if val == "str" %}String
+{% elif val == "int" %}Int {% else %}
+{% if val.get("_t_") == "list" %}List{{describe(val["t"])}}{% else %}
+
+{% for k, v in val.items() %}{{k}}
+{% endfor %}
+
+Only select from the above list.
+{% endif %}
+{%endif%}
+{% endfor %}
+{% endmacro -%}
+{{describe(typ)}}
+{% macro json(typ) -%}{% for key, val in typ.items() %}{% if val in ["str", "int"] or val.get("_t_") != "list"  %}"{{key}}" : "{{key}}" {% else %} "{{key}}" : [{ {{json(val["t"])}} }] {% endif %}{{"" if loop.last else ", "}} {% endfor %}{% endmacro -%}
+
+[{ {{json(typ)}} }, ...]
+
+
+
+Make sure every output is exactly seen in the document. Find as many as you can.
+You need to output only JSON.