working app

README.md

@@ -10,3 +10,18 @@ pinned: false
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+## Setup
+
+```
+  pip install virtualenv
+  python -m venv myenv
+  source myenv/bin/activate
+  pip install -r requirements.txt
+```
+
+## Run
+
+```
+  streamlit run app.py
+```

app.py

@@ -1,45 +1,115 @@
+from typing import List, Optional, TypedDict
 import streamlit as st
+import requests
 import openai
-import os
+import pinecone
+import json
+import re
 
-# Set OpenAI API key from Streamlit Secrets
+PINECONE_API_KEY = st.secrets["PINECONE_API_KEY"]
 OPENAI_API_KEY = st.secrets["OPENAI_API_KEY"]
+
+class Metadata(TypedDict):
+    title: str
+    description
+    slides: str
+
+# Initialize Pinecone and OpenAI
+pinecone.init(api_key=PINECONE_API_KEY, environment="asia-southeast1-gcp")
 openai.api_key = OPENAI_API_KEY
 
-# Set maximum token length
-MAX_TOKENS = 1024
+def get_embeddings(texts: List[str]) -> List[List[float]]:
+    """
+    Embed texts using OpenAI's ada model.
+
+    Args:
+        texts: The list of texts to embed.
+
+    Returns:
+        A list of embeddings, each of which is a list of floats.
 
-# Set OpenAI model
-MODEL = "openai-davinci-003"
+    Raises:
+        Exception: If the OpenAI API call fails.
+    """
+    # Call the OpenAI API to get the embeddings
+    response = openai.Embedding.create(input=texts, model="text-embedding-ada-002")
 
-# Set Streamlit page configuration
-st.set_page_config(layout="centered")
+    # Extract the embedding data from the response
+    data = response["data"]  # type: ignore
 
-# Set Streamlit title and description
-st.title("Email Response Generator")
-st.markdown("Generate a response to an email.")
+    # Return the embeddings as a list of lists of floats
+    return [result["embedding"] for result in data]
 
-# Define the email input form
-st.subheader("Input Email")
-email_text = st.text_area("Enter your email here", height=200)
+# Pinecone fetch function
+def fetch_lesson(query: str):
+    vector = get_embeddings([query])[0]
 
-# Define the response generation function
-@st.cache(show_spinner=False)
-def generate_response(email_text):
-    prompt = "You are sharing an email. You have very little time in your schedule but want to be polite in your response. You are expecting a response.\n\nEmail:\n" + email_text
+    index_name = "prequelworkshops"
+    index = pinecone.Index(index_name)
+    return index.query(
+        vector=vector,
+        # filter={
+        #     "genre": {"$eq": "documentary"},
+        #     "year": 2019
+        # },
+        top_k=1,
+        include_metadata=True
+    )
+
+# OpenAI prompt generation function
+def query_openai(prompt) -> str:
     response = openai.Completion.create(
-        engine=MODEL,
+        engine="text-davinci-003",
         prompt=prompt,
-        max_tokens=MAX_TOKENS
+        max_tokens=1024,
+        n=1,
+        stop=None,
+        temperature=0.7,
     )
     return response.choices[0].text.strip()
 
-# Define the submit button
-if st.button("Generate Response"):
-    if email_text.strip() == "":
-        st.warning("Please enter your email.")
+def extract_arrays(s: str) -> Optional[List[str]]:
+    s = s.replace("'", '"')
+
+    try:
+        arrays = json.loads(s)  # try to parse the string as JSON
+    except json.JSONDecodeError as e:
+        print(e)
+        return None  # if parsing fails, return None
+
+    if isinstance(arrays, list):  # if parsing succeeds and the result is a list
+        return arrays  # return the list
+    else:
+        return None 
+
+def generate_curriculum(user_input) -> Optional[List[str]]:
+    # st.write("Generating curriculum...")
+    prompt = f"You are a world class high school teacher. Create a curriculum for a course based on the student's interest below. Output the curriculum as a javascript array of strings, where each string is a description of the lesson. The output should just be the array and nothing else. Student's interest: {user_input}"
+    response = query_openai(prompt)
+    return extract_arrays(response)
+
+def get_metadata(lesson) -> Metadata:
+    return lesson.matches[0].metadata
+
+def format_metadata(metadata) -> List[str]:
+    return f"Title: {metadata['title']}\n\nDescription: {metadata['description']}"
+
+# Streamlit UI
+st.title("Personalized Learning Curriculum Generator")
+user_input = st.text_input("Enter what you want to learn:")
+submit_button = st.button("Generate response")
+status = st.empty()
+
+if submit_button:
+    status.text("Generating curriculum...")
+    curriculum = generate_curriculum(user_input)
+
+    if curriculum is not None:
+        status.text("Fetching relevant courses...")
+        lessons = [fetch_lesson(lesson) for lesson in curriculum]
+        lesson_text = "\n\n".join([format_metadata(get_metadata(lesson)) for lesson in lessons])
+        status.empty()
+        st.markdown(f"**Generated Curriculum:**\n\n{lesson_text}")
     else:
-        with st.spinner("Generating response..."):
-            response_text = generate_response(email_text)
-        st.subheader("Generated Response")
-        st.markdown(response_text)
+        status.text("Error generating curriculum. Please try again")
+    

requirements.txt

@@ -1,2 +1,3 @@
+streamlit
 openai
-streamlit
+pinecone-client