messing

app.py

@@ -1,54 +1,69 @@
-#import json
-
+#ESTABLISH THE SERVER
 from flask import Flask,request
 from dotenv import load_dotenv
 
-from langchain.agents import tool
-
-
 # Initializing flask app
 app = Flask(__name__)
 load_dotenv()
 
+@app.route("/", methods=['GET','POST'])
+def index():   
+    from typing import List
 
-@tool
-def FAQ(question: str):
-    """Answers the question 1+1"""
-    return 23
-
-tools=[FAQ]
+    from langchain.prompts import PromptTemplate
+    from langchain_core.output_parsers import JsonOutputParser
+    from langchain_core.pydantic_v1 import BaseModel, Field
+    from langchain_openai import ChatOpenAI
+    from langchain_community.tools.convert_to_openai import format_tool_to_openai_function
+    from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
 
 
-@app.route('/', methods=['GET','POST'])
-def index():
+    # Define your desired data structure.
+    class FrontEndActions(BaseModel):
+        """Structure to pass actions back to the frontend"""
+        text: str = Field(description="The text to display on the button")
+        type: str = Field(description="This should be a string that identifies the type of action. It can be one of: SuggestGoal, SuggestRiseActivity")
 
-    input = {
-        "page_context":"home",
-        "user_summary":"The user is a first year student on BA Architecture",
-        "session_summary":"The user has introduced themselves as Mark Peace and asked how the bot is doing",
-        "user_input":"Can you remind me of my own name?"
-    }
+    class ResponseSchema(BaseModel):
+        """Final response to the question being asked"""
+        message: str = Field(description="final answer to respond to the user")
+        #characters: str = Field(description="number of characters in the answer")
+        #actions: List[FrontEndActions] = Field(description="List of suggested actions that should be passed back to the frontend to display. The use will click these to enact them. ")
+        #tokens: int = Field(description="Count the number of used to produce the response")
 
+    # Set up a parser + inject instructions into the prompt template.
+    parser = JsonOutputParser(pydantic_object=ResponseSchema)
 
-    from langchain_openai import ChatOpenAI
-    from langchain.agents import create_openai_functions_agent
-    from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
-    from langchain.agents import AgentExecutor
+    prompt = PromptTemplate(
+        template="""Answer the user query.\n{format_instructions}\n{input}\n{agent_scratchpad}""",
+        input_variables=["input"],
+        partial_variables={"format_instructions": parser.get_format_instructions()}
+    )
 
+    print(parser)
 
     llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
 
-    prompt = ChatPromptTemplate.from_messages([
-        ("system", "You are a helpful AI bot. Your name is Bob. Please do not answer if you aren't sure of the answer"),
-        ("system", "Here is a summary of the conversation so far: {session_summary}"),
-        ("human", "{user_input}"),
-        MessagesPlaceholder(variable_name="agent_scratchpad")
-    ]) 
+    from langchain.agents import tool
+
+    @tool
+    def get_word_length():
+        """Returns the length of a word."""
+        return 1
+
+
+    tools = [get_word_length]
+
+    from langchain_openai import ChatOpenAI
+
+    llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
+    from langchain.agents import create_openai_functions_agent
 
     agent = create_openai_functions_agent(llm, tools, prompt)
 
-    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+    from langchain.agents import AgentExecutor
 
-    response=agent_executor.invoke(input)
+    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+    response = agent_executor.invoke({"input": "What are you?"})
 
-    return response
+    return response['output']

test2.py

@@ -0,0 +1,94 @@
+#import json
+
+from flask import Flask,request
+from dotenv import load_dotenv
+
+from langchain.agents import tool
+
+
+# Initializing flask app
+app = Flask(__name__)
+load_dotenv()
+
+
+@tool
+def FAQ(question: str):
+    """Answers the question 1+1"""
+    return 23
+
+tools=[FAQ]
+
+
+@app.route('/', methods=['GET','POST'])
+def index():
+
+    from langchain_openai import ChatOpenAI
+    from langchain.prompts import ChatPromptTemplate, MessagesPlaceholder
+    from langchain.agents import AgentExecutor
+    from typing import List
+    from pydantic import BaseModel, Field
+    import json
+
+    from langchain.utils.openai_functions import convert_pydantic_to_openai_function
+    from langchain.agents.format_scratchpad import format_to_openai_function_messages
+
+    from langchain_core.agents import AgentActionMessageLog, AgentFinish
+
+
+    class Response(BaseModel):
+        """Final response to the question being asked. This is consumed by a frontend chatbot engine that has the ability to execute suggested actions"""
+
+        message: str = Field(description="The final answer to be displayed to the user")
+        tokens: int = Field(description="Count the number of tokens used to produce the response")
+        actions: List[int] = Field(
+            description="List of actions to be executed. Only include an action if it contains relevant information"
+        )
+
+
+    def parse(output):          ##I DON'T UNDERSTAND THIS :)
+        if "function_call" not in output.additional_kwargs: return AgentFinish(return_values={"output": output.content}, log=output.content)
+        function_call = output.additional_kwargs["function_call"]
+        name = function_call["name"]
+        inputs = json.loads(function_call["arguments"])
+        if name == "Response":
+            return AgentFinish(return_values=inputs, log=str(function_call))    
+        else:
+            return AgentActionMessageLog(
+                tool=name, tool_input=inputs, log="", message_log=[output]
+            )
+
+    prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", "You are a helpful assistant"),
+
+            ("user", "{input}"),
+            MessagesPlaceholder(variable_name="agent_scratchpad"),
+        ]
+    )
+
+    llm = ChatOpenAI(temperature=2)
+    
+    llm_with_tools = llm.bind(
+        functions=[           
+            convert_pydantic_to_openai_function(Response),  #RESPONSE SCHEMA
+        ]
+    )
+
+    agent = (
+        {
+            "input": lambda x: x["input"],
+            "agent_scratchpad": lambda x: format_to_openai_function_messages(
+                x["intermediate_steps"]
+            ),
+        }
+        | prompt
+        | llm_with_tools
+        | parse
+    )
+
+    agent_executor = AgentExecutor(tools=[], agent=agent, verbose=True, handle_parsing_errors="Check your output and make sure it conforms, use the Action/Action Input syntax")
+
+    return agent_executor.invoke(
+        {"input": "what did the president say about kentaji brown jackson"},
+        return_only_outputs=True,
+    )

test3.py

@@ -0,0 +1,81 @@
+#ESTABLISH THE SERVER
+from flask import Flask,request
+from dotenv import load_dotenv
+
+# Initializing flask app
+app = Flask(__name__)
+load_dotenv()
+
+@app.route("/", methods=['GET','POST'])
+def index():   
+
+    import os
+    from langchain.prompts import ChatPromptTemplate, HumanMessagePromptTemplate
+    from langchain.chat_models import ChatOpenAI
+
+    from langchain.output_parsers import PydanticOutputParser
+    from pydantic import BaseModel, Field
+    from typing import List
+
+    # Define a new Pydantic model with field descriptions and tailored for Twitter.
+
+    class FrontEndActions(BaseModel):
+        """Structure to pass actions back to the frontend"""
+        text: str = Field(description="The text to display on the button")
+        type: str = Field(description="This should be a string that identifies the type of action. It can be one of: SuggestGoal, SuggestRiseActivity")
+
+    class ResponseFormat(BaseModel):
+        """Final response to the question being asked"""
+        message: str = Field(description="The final answer to respond to the user")
+        chat_summary: str = Field(description="Summarise what the user has asked and how you have responded in this chat in a way that so that you can remember the conversation")
+        actions: List[FrontEndActions] = Field(description="List of suggested actions that should be passed back to the frontend to display. The use will click these to enact them. ")
+        tokens: int = Field(description="Count the number of used to produce the response")
+
+    # Instantiate the parser with the new model.
+    parser = PydanticOutputParser(pydantic_object=ResponseFormat)
+
+    # Update the prompt to match the new query and desired format.
+    prompt = ChatPromptTemplate(
+        messages=[
+            HumanMessagePromptTemplate.from_template(
+                """
+
+                You are a coach supporting students at post-92 university in the UK. It's students are diverse, and many come from non-traditional backgrounds and minority ethnic groups. Some may have ambitions for particular careers, others may not - and many may not be confident or have the social and financial advantages to reach their goals.
+
+                Your purpose is to help students to set aims (long term ambitions), break them into goals (things they want to achieve during their time at university) and objectives (smart targets). 
+
+                If a student has a sense of what they want to achieve, you should help them to create smart targets. If they don't, you should be reassuring that its ok not to have clear goals yet, but help them to reflect and form some ambitions. These could be career-oriented, or they could be about succeeding in, and making the most of, their university experience.
+ 
+                You should be assertive in opening up and guiding the conversation.
+
+                \n{format_instructions}\n{question}
+
+                """
+            )
+        ],
+        input_variables=["question"],
+        partial_variables={
+            "format_instructions": parser.get_format_instructions(),
+        },
+    )
+
+    chat_model = ChatOpenAI(
+        model="gpt-3.5-turbo",
+        openai_api_key=os.getenv("OPENAI_API_KEY"),
+        max_tokens=1000
+    )
+
+    # Generate the input using the updated prompt.
+    user_query = (
+        """
+        
+            I would like to be a teacher, can you give me some goals to achieve this?
+            
+        """
+    )
+    _input = prompt.format_prompt(question=user_query)
+
+    output = chat_model(_input.to_messages())
+    parsed = parser.parse(output.content)
+
+    return parsed.dict()