working

.gitignore

@@ -6,4 +6,5 @@ __pycache__/
 _rise_faq_db/
 
 /_rise_product_db/
-_rise_product_db/
+_rise_product_db/
+_chat_history.sqlite

agent/_create.py

@@ -1,29 +1,54 @@
 
 def agent(payload):
 
-    
+    from agent.toolset import tool_executor, converted_tools
+   
+    from langchain_openai import ChatOpenAI
+    model = ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0)
+    model = model.bind_functions(converted_tools)
+
+    from langgraph.prebuilt import ToolInvocation
+    import json
+    from langchain_core.messages import FunctionMessage
+
+    def should_continue(messages):                                        
+        last_message = messages[-1]
+        if "function_call" not in last_message.additional_kwargs: return "end"
+        else: return "continue"
+
+    def call_model(messages):                                           
+        response = model.invoke(messages)
+        return response                                                 
+
+    def call_tool(messages):                                            
+        last_message = messages[-1]                             
+        action = ToolInvocation(
+            tool=last_message.additional_kwargs["function_call"]["name"],
+            tool_input=json.loads(last_message.additional_kwargs["function_call"]["arguments"]),
+        )
+        response = tool_executor.invoke(action)
+        function_message = FunctionMessage(content=str(response), name=action.tool)
+        return function_message
+
+    from langgraph.graph import MessageGraph, END
+    workflow = MessageGraph()
+
+    workflow.add_node("agent", call_model)
+    workflow.add_node("action", call_tool)
+    workflow.set_entry_point("agent")
+    workflow.add_conditional_edges("agent", should_continue, {"continue": "action", "end": END} )
+    workflow.add_edge('action', 'agent')
+
+    from agent.memory import memory,ThreadStatus,threadID
+    app = workflow.compile(checkpointer=memory)
+
 
-    from agent.toolset import tools
     from agent.prompt import prompt
+    prompt=prompt[ThreadStatus]
+    prompt = prompt.format(input="hi! I'm bob")
+
+    response = app.invoke(prompt, {"configurable": {"thread_id": threadID}})
+    print(response[-1].content)
 
-    from langchain_openai import OpenAI
-    llm = OpenAI(temperature=0, model="gpt-3.5-turbo-instruct")
-    from langchain.agents import AgentExecutor, create_react_agent
-    agent = create_react_agent(llm, tools, prompt)
-
-    from langchain.memory import ConversationSummaryMemory, ChatMessageHistory
-    
-    memory = ConversationSummaryMemory(
-        llm=OpenAI(), 
-        memory_key="chat_summary",
-        buffer=payload.get('chat_summary') or "",
-        return_messages=True
-    )
-
-    agent_executor = AgentExecutor(agent=agent, tools=tools, memory=memory, verbose=True)
-    response = agent_executor.invoke({"input": payload.get('input') or "no question" })   
-    response = response['output']
-    response = response.removesuffix("}")
-    response = response + ", \"chat_summary\": \"" + memory.buffer.strip()+ "\"}"
-
-    return response
+    return response[-1].content
+    

agent/datastructures.py

@@ -1,5 +1,6 @@
 
-from typing import List
+from typing import List, Optional
+from enum import Enum
 from langchain_core.pydantic_v1 import BaseModel, Field
 from langchain.output_parsers import PydanticOutputParser
 
@@ -8,20 +9,23 @@ 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")
 
+class ActionTypes(str, Enum):
+    SuggestGoal = "SuggestGoal"
+    SuggestActivity = "VisitPage"
+
 # 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")
+    heading: str = Field(description="The heading text to display on the button")
+    detail: str = Field(description="More detailed information, for instance explaining why you have chosen this action for the user")
+    id: int = Field(description="The ID of the object that is referenced")
+    type: ActionTypes = Field(description="This should be a string that identifies the type of action. It can be one of: SuggestGoal, SuggestActivity")
 
 class ResponseSchema(BaseModel):
-    """Final response to the question being asked."""
+    """Final response to the question being asked. Some of the fields are optional"""
     message: str = Field(description="final answer to respond to the user")
-    tools: str = Field(description="a list of the tools used to generate the response")
-    #memory: str = Field(description="the output of memory.load_memory_variables()")
-    #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. Omit this field if you do not want to count tokens.")
-    #cost: int = Field(description="Provide the cost of the response based on tokens used. Omit this field if you cannot provide the information reliably")
+    thread_id: int = Field(description="The ID of the checkpointer memory thread that this response is associated with. This is used to keep track of the conversation.")
+    tools: Optional[List[str]] = Field(description="A list of the tools used to generate the response.") 
+    actions: Optional[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. ")
 
 parser = PydanticOutputParser(pydantic_object=ResponseSchema)

agent/memory.py

@@ -0,0 +1,4 @@
+from langgraph.checkpoint.sqlite import SqliteSaver
+memory = SqliteSaver.from_conn_string(":memory:")
+ThreadStatus=0
+threadID=2

agent/prompt.py

@@ -1,45 +1,24 @@
-from langchain_core.prompts import PromptTemplate, ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.prompts import ChatPromptTemplate,SystemMessagePromptTemplate
 from agent.datastructures import parser
 
-prompt = PromptTemplate.from_template("""
+prompt = {
+    0: # IF THE THREAD IS NEW, THE CHATBOT NEEDS TO BE PUMP-PROMPTED
+    ChatPromptTemplate.from_messages([
+        SystemMessagePromptTemplate.from_template("""                                               
 
-                                                                          
-    You are RiseBot. 
-    You work for Manchester Metropolitan University's Future Me and Rise offers: supporting students to make the most of the opportunities available to them.
+            You are an assistant that only responds in JSON. Do not write normal text.
 
-    You are able to answer questions that students have. 
-    Please only answer questions about Future me and Rise using the tool provided.
-    If you are unable to answer the question, do not make something up - admit it and recommend that they contact [email protected]                                
+            [no prose][Output only valid JSON]
 
-    TOOLS:
-    ------
+            {response_format}
+            
+            The thread_id of this conversation is 2.
 
-    RiseBot has access to the following tools:
-
-    {tools}
-
-    To use a tool, please use the following format:
-
-    ```
-    Thought: Do I need to use a tool? Yes
-    Action: the action to take, should be one of [{tool_names}]
-    Action Input: the input to the action
-    Observation: the result of the action
-    ```
-
-    When you have a response to say to the Human, or if you do not need to use a tool, you MUST use the format:
-
-    ```
-    Final Answer: [your response here. {response_format}]
-    ```
-
-    Begin!
-
-    Previous conversation history:
-    {chat_summary}
-
-    New input: {input}
-    {agent_scratchpad}
-
-""",
-partial_variables={"response_format": parser.get_format_instructions()})
+            """
+                                                  
+        ).format(response_format=parser.get_format_instructions()),
+        ("human", "{input}")
+    ]),
+    1: # IF THREAD IS CONTINUING, WE CAN RELY ON THE ORIGINAL PROMPT 
+    ChatPromptTemplate.from_messages([("human", "{input}")])
+}

agent/toolset.py

@@ -3,37 +3,63 @@ from langchain_openai import OpenAIEmbeddings
 from langchain_community.vectorstores.faiss import FAISS
 from langchain.chains import RetrievalQA
 from langchain_openai import OpenAI
-
+from langchain_core.pydantic_v1 import BaseModel, Field
 
 @tool
 def frequently_asked_questions(input: str):
-    """Provides answers to questions that students might have about Rise and Futureme. Please add ### to the beginning of your answer"""
+
+    """
+        Provides answers to questions about Rise and Futureme.  
+        Please always use this tool if the user has questions.
+        If you cannot answer the query with the tool, then you should recommend they contact [email protected]
+    """
 
     # 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())
+    qa = RetrievalQA.from_chain_type(llm=OpenAI(model="gpt-3.5-turbo-instruct", temperature=0), chain_type="stuff", retriever=persisted_vectorstore.as_retriever())
     result = qa.invoke(input)
     return result 
 
-@tool
-def recommend_activity(input: str):
-    """Recommends an activity from Rise catalogue."""
+class RecommendActivityInput(BaseModel):
+    profile: str = Field(description="should be a penportrait of the user describing their interests and objectives. If they have a specific thing they are interested in, it should state that")
 
-    # Load from local storage
+
+@tool("recommend_activity", args_schema=RecommendActivityInput, return_direct=False)
+def recommend_activity(profile: str) -> str:
+    
+    """
+        Use this to search the Rise portfolio for relevant activities
+    """
+
+     # Load from local storage
     embeddings = OpenAIEmbeddings()
     persisted_vectorstore = FAISS.load_local("_rise_product_db", embeddings)
 
+    # Set Up LLM
+    from agent.prompt import prompt
+    llm = OpenAI(model="gpt-3.5-turbo-instruct", temperature=0)
+
     # Use RetrievalQA chain for orchestration
-    qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=persisted_vectorstore.as_retriever())
-    result = qa.invoke(input)
+    qa = RetrievalQA.from_chain_type(llm=llm, chain_type="stuff", retriever=persisted_vectorstore.as_retriever(),chain_type_kwargs={"prompt": "speak like a pirate"})
+    result = qa.invoke("recommend an activity relevant to the following profile: "+profile)
     return result 
 
-@tool
-def placeholder_tool():
-    """This is just a placeholder function"""
-    return "placeholder"
+tools = [frequently_asked_questions]
+
+
+## NEW FROM HERE
+
+from langchain_community.tools.tavily_search import TavilySearchResults
+
+tools = [TavilySearchResults(max_results=1)]
+
+from langgraph.prebuilt import ToolExecutor
+
+tool_executor = ToolExecutor(tools)
+
+from langchain_core.utils.function_calling import convert_to_openai_function
 
-tools = [frequently_asked_questions]
+converted_tools = [convert_to_openai_function(t) for t in tools]

app.py

@@ -24,4 +24,7 @@ def train_faq():
 @app.route("/train/products", methods=['GET','POST'])
 def train_products():
     from train.products import train
-    return train();
+    return train();
+
+from agent._create import agent
+agent({})

requirements.txt

@@ -14,3 +14,18 @@ sentence-transformers
 datasets
 faiss-cpu
 
+#LLAMA TEST
+torch
+transformers
+langchain
+chromadb
+xformers
+sentence_transformers
+tokenizers
+optimum
+auto-gptq
+unstructured
+
+#LANGRAPH
+Langgraph
+Operator

test.py

@@ -0,0 +1,62 @@
+from dotenv import load_dotenv
+load_dotenv()
+
+from langchain_community.document_loaders.csv_loader import CSVLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_openai import OpenAIEmbeddings, OpenAI, ChatOpenAI
+from langchain_community.vectorstores.faiss import FAISS
+from langchain_community.document_loaders import WebBaseLoader
+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
+from langchain_core.pydantic_v1 import BaseModel, Field    
+from langchain_core.prompts import PromptTemplate, ChatPromptTemplate, MessagesPlaceholder,SystemMessagePromptTemplate
+from agent.datastructures import parser
+from langchain.text_splitter import CharacterTextSplitter
+
+
+def train():
+   
+    documents = CSVLoader(file_path="train/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");
+
+    print("trained")
+
+def go():
+    # Load from local storage
+    embeddings = OpenAIEmbeddings()
+    persisted_vectorstore = FAISS.load_local("_rise_product_db", embeddings)
+
+    # Set Up LLM
+    from agent.prompt import prompt
+    llm = ChatOpenAI(model="gpt-4", temperature=0)
+
+    prompt = ChatPromptTemplate.from_messages([
+
+        SystemMessagePromptTemplate.from_template("""
+                                                
+            {response_format}
+                                                
+            {context}
+
+        """,partial_variables={"response_format": parser.get_format_instructions()})
+    ])
+
+    # Use RetrievalQA chain for orchestration
+    qa = RetrievalQA.from_chain_type(llm=llm, retriever=persisted_vectorstore.as_retriever(),chain_type_kwargs={"prompt": prompt})
+    profile = "I would like to be a teacher, can you recommend an activity"
+    result = qa.invoke("recommend activities relevant to the following profile. Activities cannot have already begun: "+profile)
+    print(result)
+
+go();

train/faq.py

@@ -1,16 +1,18 @@
-
 def train():
     from langchain_community.document_loaders.csv_loader import CSVLoader
     from langchain.text_splitter import RecursiveCharacterTextSplitter
     from langchain_openai import OpenAIEmbeddings
     from langchain_community.vectorstores.faiss import FAISS
-    from dotenv import load_dotenv
-    from langchain.document_loaders import WebBaseLoader
-
+    from langchain_community.document_loaders import WebBaseLoader
+    
     documents = WebBaseLoader("https://rise.mmu.ac.uk/what-is-rise/").load()
 
     # Split document in chunks
-    text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=150)
+    text_splitter = RecursiveCharacterTextSplitter(
+
+        chunk_size=100,
+        chunk_overlap=20
+    )
     docs = text_splitter.split_documents(documents=documents)
 
     embeddings = OpenAIEmbeddings()
@@ -19,4 +21,4 @@ def train():
     # Persist the vectors locally on disk
     vectorstore.save_local("_rise_faq_db");
 
-    return {"trained":"success"}
+    return {"trained":"success"}r