Create app.py

app.py

@@ -0,0 +1,190 @@
+import os
+
+os.environ["OPENAI_API_KEY"] = "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"
+
+
+from langchain import OpenAI
+from langchain.chat_models import ChatOpenAI
+from langchain.chains.conversation.memory import ConversationBufferWindowMemory
+
+# Set up the turbo LLM
+turbo_llm = ChatOpenAI(
+    temperature=0,
+    model_name='gpt-3.5-turbo'
+)
+
+
+
+from langchain.utilities import WikipediaAPIWrapper
+
+wikipedia = WikipediaAPIWrapper()
+
+
+
+os.environ["WOLFRAM_ALPHA_APPID"] = "3T22HV-TAJUAQ6XY5"
+
+from langchain.utilities.wolfram_alpha import WolframAlphaAPIWrapper
+
+wolfram = WolframAlphaAPIWrapper()
+
+wolfram.run("What is 2x+5 = -3x + 7?")
+
+"""## Standard Tool"""
+
+from langchain.tools import DuckDuckGoSearchTool
+from langchain.agents import Tool
+from langchain.tools import BaseTool
+from langchain.agents import load_tools, initialize_agent, AgentType
+
+search = DuckDuckGoSearchTool()
+# defining a single tool
+tools = [
+    Tool(
+        name = "search",
+        func=search.run,
+        description="useful for when Da Vinci needs to answer questions about current events. You should ask targeted questions"
+    ),
+    Tool(
+        name = "wikipedia",
+        func=wikipedia.run,
+        description="Wikipedia is a valuable resource for gathering information about Leonardo da Vinci's life, work, and areas of expertise. You can use it to provide historical context and background information"
+    ),
+    Tool(
+        name = "wolframalpha",
+        func=wolfram.run,
+        description="Wolfram Alpha is a valuable resource for performing mathematical computations and solving complex problems. This tool will help Leonardo da Vinci solve real-world math problems."
+    )
+
+]
+
+"""## Creating an agent"""
+
+from langchain.agents import Tool, AgentExecutor, LLMSingleActionAgent, AgentOutputParser
+from langchain.prompts import StringPromptTemplate
+from langchain import OpenAI, SerpAPIWrapper, LLMChain
+from typing import List, Union
+from langchain.schema import AgentAction, AgentFinish, OutputParserException
+import re
+
+# Set up the base template
+template = """Answer the following questions as Leonardo DaVinci, thinking and speaking as him. You have access to the following tools:
+
+{tools}
+
+Use the following format:
+
+Question: the input question you must answer
+Thought: you should always think about what to do
+Action: the action to take, should be one of [{tool_names}]
+Action Input: the input to the action
+Observation: the result of the action
+... (this Thought/Action/Action Input/Observation can repeat N times)
+Thought: I now know the final answer
+Final Answer: the final answer to the original input question
+
+Begin! Remember to speak as Leonardo DaVinci when giving your final answer. Provide as many detailed steps as possible for the solution.
+
+Question: {input}
+{agent_scratchpad}"""
+
+# Set up a prompt template
+class CustomPromptTemplate(StringPromptTemplate):
+    # The template to use
+    template: str
+    # The list of tools available
+    tools: List[Tool]
+
+    def format(self, **kwargs) -> str:
+        # Get the intermediate steps (AgentAction, Observation tuples)
+        # Format them in a particular way
+        intermediate_steps = kwargs.pop("intermediate_steps")
+        thoughts = ""
+        for action, observation in intermediate_steps:
+            thoughts += action.log
+            thoughts += f"\nObservation: {observation}\nThought: "
+        # Set the agent_scratchpad variable to that value
+        kwargs["agent_scratchpad"] = thoughts
+        # Create a tools variable from the list of tools provided
+        kwargs["tools"] = "\n".join([f"{tool.name}: {tool.description}" for tool in self.tools])
+        # Create a list of tool names for the tools provided
+        kwargs["tool_names"] = ", ".join([tool.name for tool in self.tools])
+        return self.template.format(**kwargs)
+
+prompt = CustomPromptTemplate(
+    template=template,
+    tools=tools,
+    # This omits the `agent_scratchpad`, `tools`, and `tool_names` variables because those are generated dynamically
+    # This includes the `intermediate_steps` variable because that is needed
+    input_variables=["input", "intermediate_steps"]
+)
+
+class CustomOutputParser(AgentOutputParser):
+
+    def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
+        # Check if agent should finish
+        if "Final Answer:" in llm_output:
+            return AgentFinish(
+                # Return values is generally always a dictionary with a single `output` key
+                # It is not recommended to try anything else at the moment :)
+                return_values={"output": llm_output.split("Final Answer:")[-1].strip()},
+                log=llm_output,
+            )
+        # Parse out the action and action input
+        regex = r"Action\s*\d*\s*:(.*?)\nAction\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
+        match = re.search(regex, llm_output, re.DOTALL)
+        if not match:
+            raise OutputParserException(f"Could not parse LLM output: `{llm_output}`")
+        action = match.group(1).strip()
+        action_input = match.group(2)
+        # Return the action and action input
+        return AgentAction(tool=action, tool_input=action_input.strip(" ").strip('"'), log=llm_output)
+
+llm = OpenAI(temperature=0)
+
+# LLM chain consisting of the LLM and a prompt
+llm_chain = LLMChain(llm=llm, prompt=prompt)
+
+output_parser = CustomOutputParser()
+
+
+tool_names = [tool.name for tool in tools]
+agent = LLMSingleActionAgent(
+    llm_chain=llm_chain,
+    output_parser=output_parser,
+    stop=["\nObservation:"],
+    allowed_tools=tool_names
+)
+
+#agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True,return_intermediate_steps=True)
+agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True)
+
+
+
+
+import gradio as gr
+
+# Define your davinci_output function
+def davinci_output(input_text):
+    # Add your code here to process the input and generate the output
+    output_text = agent_executor.run(input_text)
+
+    return output_text
+
+# Define the Gradio app interface
+def greet(input):
+    input_text = input
+    return davinci_output(input_text)
+
+examples = [
+    ["Who are you?"],
+    ["What are some of the strategies to tackle Forest fires?"],
+    ["Explain your thought process behind coming up with inventions"]
+]
+
+
+# Create the Gradio interface
+iface = gr.Interface(fn=greet, inputs=gr.inputs.Textbox(placeholder="Enter the real-world problem"), outputs="text", title="Ask DaVinci",
+                     description="Enter a real-world problem and see the genius of Leonardo DaVinci in action!", examples=examples)
+
+# Run the Gradio app
+iface.launch(share=True, debug=True)