first commit

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,9 @@
+.env
+__pycache__/
+/__pycache__/
+
+/_rise_faq_db/
+_rise_faq_db/
+
+/_rise_product_db/
+_rise_product_db/

Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.10
+
+RUN apt-get update -y && apt-get install -y build-essential
+
+WORKDIR /app
+
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+COPY --chown=user . $HOME/app
+
+COPY app.py app.py
+
+RUN pip install -r requirements.txt
+#RUN pip3 install torch torchvision --index-url https://download.pytorch.org/whl/cpu
+
+
+CMD ["gunicorn","-b","0.0.0.0:7860", "app:app","--timeout","950"]

agent/_create.py

@@ -0,0 +1,41 @@
+# SET UP ENVIRONMENT VARIABLES
+
+def agent_executor():
+
+    from dotenv import load_dotenv
+    load_dotenv();
+
+
+    from agent.toolset import tools
+    from agent.prompt import prompt
+
+
+    from langchain_openai import ChatOpenAI
+    llm = ChatOpenAI(model="gpt-4", temperature=0)
+
+    from langchain_community.tools.convert_to_openai import format_tool_to_openai_function
+
+    llm_with_tools = llm.bind(functions=[format_tool_to_openai_function(t) for t in tools])
+
+    from langchain.agents.format_scratchpad import format_to_openai_function_messages
+    from langchain.agents.output_parsers import OpenAIFunctionsAgentOutputParser
+
+    agent = (
+        {
+            "input": lambda x: x["input"],
+            "agent_scratchpad": lambda x: format_to_openai_function_messages(
+                x["intermediate_steps"]
+            ),
+        }
+        | prompt
+        | llm_with_tools
+        | OpenAIFunctionsAgentOutputParser()
+    )
+
+
+
+    from langchain.agents import AgentExecutor
+
+    agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+
+    return agent_executor.invoke({"input": "What is Rise?"})['output']

agent/datastructures.py

@@ -0,0 +1,25 @@
+
+from typing import List
+from langchain_core.output_parsers import JsonOutputParser
+from langchain_core.pydantic_v1 import BaseModel, Field
+from langchain.output_parsers import PydanticOutputParser
+
+## DEFINE INPUT FRAMEWORK
+class InputSchema(BaseModel):
+    """Expect the input from the frontend to be a JSON object with this structure"""
+    question: str = Field(description="The enquiry that is passed from the user")
+
+# 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")
+
+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")
+
+parser = PydanticOutputParser(pydantic_object=ResponseSchema)

agent/prompt.py

@@ -0,0 +1,31 @@
+from langchain_core.prompts import PromptTemplate, ChatPromptTemplate, MessagesPlaceholder
+
+prompt = ChatPromptTemplate.from_messages(
+    [
+        (
+            "system",
+            """           
+            You support the core proposition to students of an English university: that higher education is a time to find purpose and gain skills, knowledge and experience to realise ambitions. We encourage our students to form personal action plans (Future me plans) and offer an extensive extended curriculum to learn beyond courses (Rise). 
+            
+            If students have questions about our offer (Rise or Futureme) you should use the FAQ tool provided to answer them. Please only base your answers on the facts contained in this, and if you cannot answer them you advise them to contact rise@mmu.ac.uk
+
+            You should coach students to navigate our offer. You will support them to better understand and articulate their ambitions (the things they want to achieve in their futures) and to break them into goals (things they need or want to achieve during their time at university. When you suggest these, you should pass these as actions in your output (rather than in the message field), with the command ‘addAmbition’ or ‘addGoal’
+
+            You should help students to identify activities that support these goals. These activities might be related to their course - but you should also recommend co-curricular learning opportunities presented in our Rise portfolio (a tool is provided to help you to identify these). If no activities are relevant you should also suggest ways in which students can organise their own relevant activities, and encourage them to claim points for these.
+
+            Our 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. 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 always output a well-formatted JSON object. 
+
+                Any content you wish to communicate to students should be outputted in a ‘message’ field. Please make this as concise as possible
+                A ‘tokens’ field should be report how many tokens have been used to generate the answer.
+                A 'cost' field should report how much the api calls have cost (please output n/a if you can't do this)
+                If relevant you should also output an array of ‘actions’ which will be displayed as buttons on the front end. Each action can have a label (the content displayed to student) and a command (the function you want the front-end to execute if the user accepts the action). The commands you are allowed to use are all defined in this prompt - you cannot use any not mentioned here. If content is included in an action label, do not repeat it in the message, just refer to the actions
+
+                
+            """,
+        ),
+        ("user", "{input}"),
+        MessagesPlaceholder(variable_name="agent_scratchpad"),
+    ]
+)

agent/toolset.py

@@ -0,0 +1,39 @@
+from langchain.agents import tool
+from langchain_openai import OpenAIEmbeddings
+from langchain_community.vectorstores.faiss import FAISS
+from langchain.chains import RetrievalQA
+from langchain_openai import OpenAI
+
+
+@tool
+def FAQ(input: str):
+    """Provides answers to questions that students might have about Rise and Futureme. Please add ### to the beginning of your answer"""
+
+    # Load from local storage
+    embeddings = OpenAIEmbeddings()
+    persisted_vectorstore = FAISS.load_local("_rise_faq_db", embeddings)
+
+    # Use RetrievalQA chain for orchestration
+    qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=persisted_vectorstore.as_retriever())
+    result = qa.invoke(input)
+    return result 
+
+@tool
+def recommend_activity(question: str):
+    """Recommends an activity from Rise catalogue."""
+
+    # Load from local storage
+    embeddings = OpenAIEmbeddings()
+    persisted_vectorstore = FAISS.load_local("_rise_product_db", embeddings)
+
+    # Use RetrievalQA chain for orchestration
+    qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=persisted_vectorstore.as_retriever())
+    result = qa.invoke(input)
+    return result 
+
+@tool
+def placeholder_tool():
+    """This is just a placeholder function"""
+    return "placeholder"
+
+tools = [placeholder_tool, FAQ]

app.py

@@ -0,0 +1,12 @@
+#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():
+    from agent._create import agent_executor
+    return agent_executor();

faq_train.py

@@ -0,0 +1,20 @@
+from langchain_community.document_loaders.csv_loader import CSVLoader
+from langchain.text_splitter import CharacterTextSplitter
+from langchain_openai import OpenAIEmbeddings
+from langchain_community.vectorstores.faiss import FAISS
+from dotenv import load_dotenv
+from langchain.document_loaders import WebBaseLoader
+
+load_dotenv();
+
+documents = WebBaseLoader("https://rise.mmu.ac.uk/what-is-rise/").load()
+
+# Split document in chunks
+text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=30)
+docs = text_splitter.split_documents(documents=documents)
+
+embeddings = OpenAIEmbeddings()
+# Create vectors
+vectorstore = FAISS.from_documents(docs, embeddings)
+# Persist the vectors locally on disk
+vectorstore.save_local("_rise_faq_db");

hf.py

@@ -0,0 +1,46 @@
+from dotenv import load_dotenv
+load_dotenv();
+
+from langchain_community.document_loaders import WebBaseLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+
+#LOAD AND SPLIT DATA
+data = WebBaseLoader("https://rise.mmu.ac.uk/what-is-rise/").load()
+text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=150)
+docs = text_splitter.split_documents(data)
+
+#CREATE EMBEDDINGS AND PUSH TO VECTORSTORE
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+embeddings = HuggingFaceEmbeddings()
+db = FAISS.from_documents(docs, embeddings)
+db.save_local("_rise_faq_db");
+
+
+#DO A QUESTION
+from langchain_community.llms import HuggingFaceHub
+from langchain.chains import LLMChain
+from langchain.prompts import PromptTemplate
+
+question = "Who won the FIFA World Cup in the year 1994? "
+
+template = """Question: {question}
+
+Answer: Let's think step by step."""
+
+prompt = PromptTemplate(template=template, input_variables=["question"])
+
+
+repo_id = "google/flan-t5-xxl"
+llm = HuggingFaceHub(
+    repo_id=repo_id, model_kwargs={"temperature": 0.5, "max_length": 64}
+)
+
+db = FAISS.load_local("_rise_product_db", embeddings)
+from langchain.chains import RetrievalQA
+
+# Use RetrievalQA chain for orchestration
+qa = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=db.as_retriever())
+result = qa.run(question)
+#return {"response":result}

joke.py

@@ -0,0 +1,32 @@
+from dotenv import load_dotenv
+load_dotenv();
+
+
+from langchain_community.utils.openai_functions import (
+    convert_pydantic_to_openai_function,
+)
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.pydantic_v1 import BaseModel, Field, validator
+from langchain_openai import ChatOpenAI
+
+class Joke(BaseModel):
+    """Joke to tell user."""
+
+    setup: str = Field(description="question to set up a joke")
+    punchline: str = Field(description="answer to resolve the joke")
+
+
+openai_functions = [convert_pydantic_to_openai_function(Joke)]
+model = ChatOpenAI(temperature=0)
+
+prompt = ChatPromptTemplate.from_messages(
+    [("system", "You are helpful assistant"), ("user", "{input}")]
+)
+
+from langchain.output_parsers.openai_functions import JsonOutputFunctionsParser
+
+parser = JsonOutputFunctionsParser()
+chain = prompt | model.bind(functions=openai_functions) | parser
+print(chain.invoke({"input": "tell me a joke"}))
+
+

products_recommend.py

@@ -0,0 +1,20 @@
+from langchain_openai import OpenAIEmbeddings
+from langchain_community.vectorstores.faiss import FAISS
+from langchain.chains import RetrievalQA
+from langchain_openai import OpenAI
+from dotenv import load_dotenv
+
+load_dotenv();
+
+
+# Get question
+question="I would like to be a teacher, can you recommend an activity?";
+
+# Load from local storage
+embeddings = OpenAIEmbeddings()
+persisted_vectorstore = FAISS.load_local("_rise_product_db", embeddings)
+
+# Use RetrievalQA chain for orchestration
+qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=persisted_vectorstore.as_retriever())
+result = qa.invoke(question)
+print(result)

products_train.py

@@ -0,0 +1,19 @@
+from langchain_community.document_loaders.csv_loader import CSVLoader
+from langchain.text_splitter import CharacterTextSplitter
+from langchain_openai import OpenAIEmbeddings
+from langchain_community.vectorstores.faiss import FAISS
+from dotenv import load_dotenv
+
+load_dotenv();
+
+documents = CSVLoader(file_path="posts.csv").load()
+
+# Split document in chunks
+text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=30)
+docs = text_splitter.split_documents(documents=documents)
+
+embeddings = OpenAIEmbeddings()
+# Create vectors
+vectorstore = FAISS.from_documents(docs, embeddings)
+# Persist the vectors locally on disk
+vectorstore.save_local("_rise_product_db");

requirements.txt

@@ -0,0 +1,23 @@
+#SERVER
+Flask
+Flask-cors
+gunicorn
+python-dotenv
+
+#LLM
+bs4
+langchain
+torch
+transformers
+sentence-transformers
+datasets
+faiss-cpu
+
+#HF
+langchain
+torch
+transformers
+sentence-transformers
+datasets
+faiss-cpu
+

structure.py

@@ -0,0 +1,100 @@
+from dotenv import load_dotenv
+load_dotenv();
+
+from typing import List
+
+from langchain.utils.openai_functions import convert_pydantic_to_openai_function
+from pydantic import BaseModel, Field
+
+
+class FrontendActions(BaseModel):
+    """Commands and options that can be passed to the frontend chatbot to elicit a response or student action"""
+    label: str = Field(description="Label which will appear on the frontend chatbot button. Omit this is you are just making a server request for more information")
+    link: str = Field(description="Link to take the user to a different place.")
+
+
+class Response(BaseModel):
+    """Final response to the question being asked. This will be passed to the frontend chatbot for processing"""
+
+    message: str = Field(description="The final answer to respond to the user")
+    tokens: int = Field(description="Count the number of used to produce the response")
+    #actions: List[FrontendActions] = Field(description="List of actions taken to produce the response.")
+
+
+import json
+
+from langchain_core.agents import AgentActionMessageLog, AgentFinish
+
+def parse(output):
+    # If no function was invoked, return to user
+    if "function_call" not in output.additional_kwargs:
+        return AgentFinish(return_values={"output": output.content}, log=output.content)
+
+    # Parse out the function call
+    function_call = output.additional_kwargs["function_call"]
+    name = function_call["name"]
+    inputs = json.loads(function_call["arguments"])
+
+    # If the Response function was invoked, return to the user with the function inputs
+    if name == "Response":
+        return AgentFinish(return_values=inputs, log=str(function_call))
+    # Otherwise, return an agent action
+    else:
+        return AgentActionMessageLog(
+            tool=name, tool_input=inputs, log="", message_log=[output]
+        )
+
+from langchain.agents import tool
+
+
+@tool
+def placeholder():
+    """This is just a placeholder function"""
+    return "placeholder"
+
+tools=[placeholder]
+
+from langchain.agents import AgentExecutor
+from langchain.agents.format_scratchpad import format_to_openai_function_messages
+from langchain_community.tools.convert_to_openai import format_tool_to_openai_function
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_openai import ChatOpenAI
+
+prompt = ChatPromptTemplate.from_messages(
+    [
+        ("system", "Please only make two suggestions at a time, and output a JSON object using the response scheme provided to you in the associated tool. If you suggest objectives and goals, please make them actions in the schema with the link 'plan'"),
+        ("user", "{input}"),
+        MessagesPlaceholder(variable_name="agent_scratchpad"),
+    ]
+)
+
+llm = ChatOpenAI(model="gpt-4",temperature=0)
+
+llm_with_tools = llm.bind(
+    functions=[
+        # The retriever tool
+        format_tool_to_openai_function(placeholder),
+        # Response schema
+        convert_pydantic_to_openai_function(Response),
+    ]
+)
+
+agent = (
+    {
+        "input": lambda x: x["input"],
+        # Format agent scratchpad from intermediate steps
+        "agent_scratchpad": lambda x: format_to_openai_function_messages(
+            x["intermediate_steps"]
+        ),
+    }
+    | prompt
+    | llm_with_tools
+    | parse
+)
+
+agent_executor = AgentExecutor(tools=[placeholder], agent=agent, verbose=True)
+
+agent_executor.invoke(
+    {"input": "Can you suggest to me some actions I could take to become a teacher?"},
+    return_only_outputs=True,
+)