Update app.py

app.py

@@ -5,19 +5,6 @@ os.environ["OPENAI_API_KEY"] = os.getenv('open_ai')
 
 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()
 
 
 
@@ -32,128 +19,6 @@ wolfram.run("What is 2x+5 = -3x + 7?")
 """## Standard Tool"""
 
 
-from langchain.agents import Tool
-from langchain.tools import BaseTool
-from langchain.agents import load_tools, initialize_agent, AgentType
-
-
-# defining a single tool
-tools = [
-    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 by ensuring that the response is atleast 500 words.
-
-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
@@ -161,25 +26,21 @@ 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)
+    output_text = wolfram.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"]
+    ["what is (4.5*2.1)^2.2?"],
+    ["Calculate 73*2-3*4"],
+    ["What is square root of 89898998"]
 ]
 
 
 # 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!")
+iface = gr.Interface(fn=davinci_output, inputs=gr.inputs.Textbox(placeholder="Enter the math problem"), outputs="text", title="Ask DaVinci",
+                     description="Enter a math problem and see the genius of Leonardo DaVinci in action!")
 
 # Run the Gradio app
 iface.launch()