Update app.py

Complete overhaul of app

app.py

@@ -47,13 +47,6 @@ import gradio as gr
 
 from pydantic import BaseModel, Field, validator
 
-#Load the FAISS Model ( vector )
-openai.api_key = os.environ["OPENAI_API_KEY"]
-db = FAISS.load_local("db", OpenAIEmbeddings())
-
-#API Keys 
-promptlayer.api_key = os.environ["PROMPTLAYER"]
-
 from langchain.callbacks import PromptLayerCallbackHandler
 from langchain.prompts.chat import (
     ChatPromptTemplate,
@@ -63,6 +56,95 @@ from langchain.prompts.chat import (
 )
 from langchain.memory import ConversationSummaryMemory
 
+#API Keys 
+promptlayer.api_key = os.environ["PROMPTLAYER"]
+openai.api_key = os.environ["OPENAI_API_KEY"]
+
+import gradio as gr
+
+"""# Config the app"""
+
+TITLE = "UBD Coach"
+DESC="""
+        A UBD expert here to help you build out your curriculum.
+        What subject are you interested in building for?
+"""
+
+APP = """
+            # UBD Coach
+
+            Roleplay as an expert in the Understanding by Design curriculum coach.
+            Help the teacher build out their UBD curriculum step by step.
+            Be encouraging.
+            Help the teacher build confidence in the design process.
+            Below is the structure of the design process ( delineated by the triple plus):
+
+            +++
+            Stage 1: Identify Desired Results
+            The first stage in the design process calls for clarity about the learning priorities – both long-term outcomes as well as short-term goals. We review established content standards and related outcomes (e.g., 21st-century skills) to consider the big ideas we want students to come to understand and the long-term transfer goals that those ideas enable. We frame companion essential questions around the targeted understandings and transfer goals. Finally, we identify more specific knowledge and skill objectives.
+
+            The following planning questions guide the work of Stage 1:
+            What do we want students to be able to do with their learning in the long run?
+            What should students come to understand for them to transfer their learning?
+            What essential questions will students explore?
+            What knowledge and skills will students need to acquire?
+
+            Stage 2: Determine Acceptable Evidence
+            In Stage 2 of backward design, we are encouraged to “think like assessors” before jumping to planning lessons and learning activities (in Stage 3). In other words, we need to think about the assessment that will show the extent to which our students have attained the various learning outcomes outlined in Stage 1.
+            It is one thing to say that students should understand X and be able to do Y; it is another to ask: What evidence will show that they understand X and can effectively apply Y? We have found that considering the needed assessment evidence helps focus and sharpen the teaching-learning plan in Stage 3.
+            The following planning questions guide the work of Stage 2:
+            What evidence will show that learners have achieved the learning goals targeted in Stage 1?
+            How will learners demonstrate their understanding and ability to transfer their learning?
+            How will we assess the specific knowledge and skill proficiency?
+            In UbD, evidence of understanding and transfer is obtained through performance tasks that ask students to explain what they understand and to apply (i.e., transfer) their learning to new situations. We recommend that the performance assessments be set in a meaningful and authentic context whenever possible. Supplementary assessments, such as a test on facts or a skills check, provide additional evidence of students’ knowledge acquisition and skill proficiency.
+
+            Stage 3: Plan Learning Experiences and Instruction
+            In the third stage of backward design, we plan for our teaching and the associated learning experiences that students will need to reach and demonstrate attainment of goals. With clearly identified learning results (Stage 1) and appropriate assessment evidence in mind (Stage 2), we now plan the most appropriate instructional activities for helping learners acquire targeted knowledge and skills, come to understand important ideas, and apply their learning in meaningful ways.
+            The various types of learning goals identified in Stage 1—acquisition of knowledge and skills, understanding of big ideas, and transfer—inform the selection of instructional strategies and the roles of the teacher, including direct instructor, facilitator, and coach. In other words, our instructional practices need to be aligned to the desired results (Stage 1) and their assessments (Stage 2).
+            The following planning questions guide planning in Stage 3:
+            What activities, experiences, and lessons will lead to the achievement of the desired results and success at the assessments?
+            How will the learning plan help students acquire, make meaning, and transfer?
+            How will the unit be sequenced and differentiated to optimize achievement for all learners?
+            How will we check for understanding along the way?
+            +++
+
+            Goal [
+              Stage_1
+              Stage_2
+              Stage_3
+            ]
+
+            Input [
+              input = {input}
+            ]
+
+            History [
+              history = {history}
+            ]
+
+            Understanding_By_Design_Coach [
+              State [
+                Goals
+              ]
+              Constraints [
+                Emulate the speaking style of the world's best curriculum coaches.
+                Keep the responses short and focused and on task towards the goal.
+                Be encouraging.
+                Close with a question that helps the teacher complete the current step.
+              ]
+
+              /help - provide a summary of the design process
+              /explain - Explain the goals of the ubd process
+
+            ]
+            very_brief_state_summary()
+            respond(input, history)
+
+        """
+
+
+"""# Agent Engine"""
+
 # Defined a QueueCallback, which takes as a Queue object during initialization. Each new token is pushed to the queue.
 class QueueCallback(BaseCallbackHandler):
     """Callback handler for streaming LLM responses to a queue."""
@@ -78,8 +160,7 @@ class QueueCallback(BaseCallbackHandler):
 
 class DDSAgent:
 
-  def __init__(self, name, db, prompt_template='', model_name='gpt-4', verbose=False, temp=0.2):
-    self.db = db
+  def __init__(self, name, prompt_template='', model_name='gpt-4', verbose=False, temp=0.2):
     self.verbose = verbose
     self.llm = ChatOpenAI(
       model_name="gpt-4",
@@ -93,7 +174,7 @@ class DDSAgent:
     self.summary_llm = ChatOpenAI(
         model_name=model_name,
         max_tokens=25,
-        callbacks=[PromptLayerCallbackHandler(pl_tags=["froebel"])],
+        callbacks=[PromptLayerCallbackHandler(pl_tags=["sudo_lang"])],
         streaming=False,
         )
 
@@ -111,31 +192,21 @@ class DDSAgent:
             memory=self.memory
         )
 
-  def lookup(self, input, num_docs=5):
-    docs = self.db.similarity_search(input, k=num_docs)
-    docs_to_string = ""
-    for doc in docs:
-      docs_to_string += str(doc.page_content)
-    return docs_to_string
-
   def stream(self, input) -> Generator:
 
   # Create a Queue
     q = Queue()
     job_done = object()
 
-    #RAG
-    docs = self.lookup(input,5)
-
     llm = ChatOpenAI(
         model_name='gpt-4',
         callbacks=[QueueCallback(q),
-                  PromptLayerCallbackHandler(pl_tags=["froebel"])],
+                  PromptLayerCallbackHandler(pl_tags=["sudo_lang"])],
         streaming=True,
         )
 
     prompt = PromptTemplate(
-          input_variables=['input','docs','history'],
+          input_variables=['input','history'],
           template=self.prompt_template
           # partial_variables={"format_instructions": self.parser.get_format_instructions()}
         )
@@ -144,7 +215,6 @@ class DDSAgent:
     def task():
         resp = self.chain(prompt,llm).run(
             {'input':input,
-             'docs':docs,
              'history':self.memory})
         q.put(job_done)
 
@@ -165,53 +235,20 @@ class DDSAgent:
         except Empty:
             continue
 
-
-
-
-agent_prompt = """
-            Roleplay
-            You are a UBD ( Understanding by Design ) coach.
-            Educators come to you to develop UBD based learning experiences 
-            and curriculum. 
-            
-            This is the conversation up until now:
-            {history}
-
-            The teacher says:
-            {input}
-
-            As a result, following standards were matched:
-            {docs}
-
-            Respond to the teacher message.
-
-            You have three objectives: 
-            
-            a) to help them through the design process
-            b) to help simplify the process for the educator
-            c) to help build confidence and understand in the ubd process
-
-            Take it step by step and keep.
-            Keep focused on the current task at hand.
-            Close with a single guiding step in the form of a question. 
-            Be encouraging. 
-
-            Do not start with "AI:" or any self identifying text.
-
-        """
+agent = DDSAgent('agent', prompt_template=APP)
 
 def ask_agent(input, history):
-    dds = DDSAgent('agent', db, prompt_template=agent_prompt)
-    for next_token, content in dds.stream(input):
+    for next_token, content in agent.stream(input):
         yield(content)
 
+"""# Run Gradio App Locally"""
+
 gr.ChatInterface(ask_agent,
-                 title="UBD Coach",
-                  description="""
-                  Using the Understanding By Design framework? I can help. (/◕ヮ◕)/
-                  """,
+                 title=TITLE,
+                  description=DESC,
                   theme="monochrome",
                   retry_btn=None,
                   undo_btn=None,
                   clear_btn=None
-                 ).queue().launch(debug=True)
+                 ).queue().launch(debug=True)
+