basic chat is working again

agent/_create.py

@@ -1,27 +1,32 @@
 
 def agent(payload):
 
-    
-    from langchain_openai import ChatOpenAI
-    llm = ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0)
+    DEBUG=True
+
+    from agent.memory import Memory
+    memory = Memory(payload)
+
+    from agent.jsonencoder import json_parse_chain
+    from agent.agent_main import Chain_Main_Agent
 
+    chain_main_agent = Chain_Main_Agent(memory)
+
+    
     from agent.toolset import tool_executor, converted_tools
-    model = llm.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)
+    def call_main_agent(messages):   
+        response = chain_main_agent.invoke({"conversation":messages, "thread_id": memory.thread_id})
+        
+        if DEBUG: print("call_main_agent called");                                        
+
         return response                                                 
 
-    def call_tool(messages):                                            
+    def use_tool(messages):    
         last_message = messages[-1]                             
         action = ToolInvocation(
             tool=last_message.additional_kwargs["function_call"]["name"],
@@ -29,37 +34,70 @@ def agent(payload):
         )
         response = tool_executor.invoke(action)
         function_message = FunctionMessage(content=str(response), name=action.tool)
+
+        if DEBUG: print("Suggesting Tool to use..."+action.tool);                                                                                
+
         return function_message
 
+    def render_output(messages):
+
+        import json
+
+        response = json_parse_chain.invoke({"conversation":messages, "thread_id": memory.thread_id})
+
+        if DEBUG: print("Rendering output");   
+
+        from langchain_core.messages import AIMessage                                     
+
+        response = json.dumps(response)
+        return AIMessage(content=response)
+
     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')
+    workflow.add_node("main_agent", call_main_agent)
+    workflow.add_node("use_tool", use_tool)
+    workflow.add_node("render_output", render_output)
 
-    from agent.memory import Memory
-    memory = Memory(payload)
+    workflow.set_entry_point("main_agent")
 
-    app = workflow.compile(checkpointer=memory.checkpoints)
+    def should_continue(messages):                                        
+        last_message = messages[-1]
+        if "function_call" not in last_message.additional_kwargs: return "render_output"
+        else: return "continue"
 
-    from agent.prompt import prompt
-    prompt=prompt[memory.isNew]
 
-    input = payload.get("input") or "What is Rise for?"
+    workflow.add_conditional_edges(
+        "main_agent", should_continue, 
+        {
+            "continue": "use_tool", 
+            "render_output":"render_output",
+            "end": END
+        }
+    )
+    workflow.add_edge('use_tool', 'main_agent')
+    workflow.add_edge('render_output', END)
 
-    prompt = prompt.format(input=input, thread_id=memory.thread_id)
 
+    app = workflow.compile(checkpointer=memory.checkpoints)
+    
+    from langchain_core.messages import HumanMessage
 
+    input = payload.get("input") or "What is Rise for?"
+    inputs = [HumanMessage(content=input)]
 
-    response = app.invoke(prompt, {"configurable": {"thread_id": memory.thread_id}})
-    print(response[-1].content)
+    response = app.invoke(inputs, {"configurable": {"thread_id": memory.thread_id} } )
 
-    #for s in app.stream(prompt, {"configurable": {"thread_id": memory.thread_id}}):
-    #    print(list(s.values())[0])
-    #    print("----")
+    '''
+    inputs = [HumanMessage(content="My name is Mark")]
+    response = app.invoke(inputs, {"configurable": {"thread_id": memory.thread_id} } )
+    print(response[-1].content)
 
+    inputs = [HumanMessage(content="What is my name?")]
+    response = app.invoke(inputs, {"configurable": {"thread_id": memory.thread_id} } )
+    print(response[-1].content)
+    '''
+    
+    print(response[-1].content)
     return response[-1].content
     

agent/agent_main.py

@@ -0,0 +1,20 @@
+
+def Chain_Main_Agent(memory):
+
+    from langchain_openai import ChatOpenAI
+
+    from agent.prompt import prompt
+    prompt=prompt[memory.isNew]
+
+    llm = ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0)
+    from agent.toolset import converted_tools
+    llm_with_tools = llm.bind_functions(converted_tools)
+
+    from agent.datastructures import parser
+
+    chain_main_agent = (
+        prompt
+        | llm_with_tools
+    )
+
+    return chain_main_agent

agent/datastructures.py

@@ -3,6 +3,8 @@ from typing import List, Optional
 from enum import Enum
 from langchain_core.pydantic_v1 import BaseModel, Field
 from langchain.output_parsers import PydanticOutputParser
+from langchain_core.output_parsers import JsonOutputParser
+
 
 ## DEFINE INPUT FRAMEWORK
 class InputSchema(BaseModel):
@@ -25,7 +27,7 @@ class ResponseSchema(BaseModel):
     """Always use this to format the final response to the user. This will be passed back to the frontend."""
     message: str = Field(description="final answer to respond to the user")
     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. ")
+    tools: List[str] = Field(description="A list of the tools used to generate the response.") 
+    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. ")
 
-parser = PydanticOutputParser(pydantic_object=ResponseSchema)
+parser = JsonOutputParser(pydantic_object=ResponseSchema)

agent/jsonencoder.py

@@ -0,0 +1,41 @@
+from langchain_openai import ChatOpenAI
+from agent.datastructures import parser
+
+
+model = ChatOpenAI(model="gpt-3.5-turbo-0125", temperature=0)
+
+#from langchain_core.utils.function_calling import convert_pydantic_to_openai_function
+#from agent.datastructures import ResponseSchema
+
+#converted_tools = [convert_pydantic_to_openai_function(ResponseSchema)]
+
+#model.bind_functions(convert_pydantic_to_openai_function(ResponseSchema))
+
+
+from langchain.prompts import ChatPromptTemplate,PromptTemplate, MessagesPlaceholder,SystemMessagePromptTemplate
+
+prompt = PromptTemplate(
+    template="""
+
+        {format_instructions} 
+        Only provide a single JSON blob, beginning with '{{' and ending with '}}'
+        /n {input} /n
+        
+    """,
+    input_variables=["input"],
+    partial_variables={"format_instructions": parser.get_format_instructions()},
+    
+
+)
+
+prompt = ChatPromptTemplate.from_messages(
+    [
+        ("system", "The thread_id of this conversation is {thread_id}."),     
+        ("system", "You will be given the chat so far, you should render the final answer as a JSON object"),        
+        SystemMessagePromptTemplate.from_template("{format_instructions}").format(format_instructions=parser.get_format_instructions()),
+        MessagesPlaceholder(variable_name="conversation"),
+    ]
+)
+
+
+json_parse_chain = prompt | model | parser

agent/memory.py

@@ -10,8 +10,6 @@ class extended_sqliteSaver(SqliteSaver):
         import sqlite3
         return SqliteSaver(conn=sqlite3.connect(conn_string, check_same_thread=False))
 
-#memory = extended_sqliteSaver.from_conn_string("_chat_history.sqlite")
-
 class Memory: 
 
     def __init__(self, payload):

agent/prompt.py

@@ -1,6 +1,7 @@
-from langchain_core.prompts import ChatPromptTemplate,SystemMessagePromptTemplate
+from langchain_core.prompts import ChatPromptTemplate,SystemMessagePromptTemplate,MessagesPlaceholder
 from agent.datastructures import parser
 
+'''
 prompt = {
     0: # IF THREAD IS CONTINUING, WE CAN RELY ON THE ORIGINAL PROMPT 
     ChatPromptTemplate.from_messages([
@@ -21,23 +22,26 @@ prompt = {
 
             You have been provided with the FrequentlyAskedQuestions tool to answer questions that students might have about the Rise programme and Future me initiative. Please rely on this tool and do not make up answers if you are unsure. 
 
-            If a question seems relevant to Rise and Future me, but you are unsure of the answer, you are able to refer it to the Rise team using the EmailTeam tool. Before you do this, please confirm with the user.
-
-            ###########
-            
-            ### PROVIDING A FINAL ANSWER ###
-
-            {response_format}
-
-            Never output anything outside of the JSON Blob beginning with '{{' and ending with '}}'
-
-            ###########
-                                                
-
+            If a question seems relevant to Rise and Future me, but you are unsure of the answer, you are able to refer it to the Rise team using the EmailTeam tool. Before you do this, please confirm with the user.                                                                                             
+                                            
             """
                                                   
-        ).format(response_format=parser.get_format_instructions()),
+        ),
         ("system", "The thread_id of this conversation is {thread_id}."),
         ("human", "{input}")
     ])
-}
+}
+'''
+prompt = {
+
+        0: ChatPromptTemplate.from_messages([
+            MessagesPlaceholder(variable_name="conversation")
+         ]),
+        
+        1: ChatPromptTemplate.from_messages([
+            ("system", "The thread_id of this conversation is {thread_id}."),     
+            ("system", "In your answer you should list the tools used to produce this answer"),     
+            MessagesPlaceholder(variable_name="conversation")
+         ])
+          
+    }

test.py

@@ -1,62 +1,40 @@
+
 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();
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_openai import ChatOpenAI
+
+from typing import List
+
+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
+
+
+
+class Joke(BaseModel):
+    setup: str = Field(description="question to set up a joke")
+    punchline: str = Field(description="answer to resolve the joke")
+
+parser = JsonOutputParser(pydantic_object=Joke)
+
+prompt = PromptTemplate(
+    template="Answer the user query.\n{format_instructions}\n{query}\n",
+    input_variables=["query"],
+    partial_variables={"format_instructions": parser.get_format_instructions()},
+)
+
+model = ChatOpenAI(model="gpt-4")
+output_parser = StrOutputParser()
+from langchain_core.output_parsers import JsonOutputParser
+
+
+chain = prompt | model | parser
+
+response=chain.invoke({"query": "ice cream"})
+
+print(response)
+

train/faq.py

@@ -6,7 +6,7 @@ def train():
     from langchain_community.document_loaders import WebBaseLoader
     
     documents = WebBaseLoader("https://rise.mmu.ac.uk/what-is-rise/").load()
-    documents[0].page_content = documents[0].page_content.split("Everything You Need To Know About Rise – Students")[1].strip();
+    documents[0].page_content = documents[0].page_content.split("Student FAQ")[1].strip();
 
     # Split document in chunks
     text_splitter = RecursiveCharacterTextSplitter(