Update app.py

app.py

@@ -780,180 +780,82 @@ Standalone question:""")
     return chain,memory
 
 
-"""
-# 1. load memory using RunnableLambda. Retrieves the chat_history attribute using itemgetter.
-# `RunnablePassthrough.assign` adds the chat_history to the assign function
-
-loaded_memory = RunnablePassthrough.assign(
-    chat_history=RunnableLambda(memory.load_memory_variables) | itemgetter("chat_history"),
-)
-
-# 2. Pass the follow-up question along with the chat history to the LLM, and parse the answer (standalone_question).
-
-condense_question_prompt = PromptTemplate(
-    input_variables=['chat_history', 'question'], 
-    template=standalone_question_template
-)
-
-condense_question_llm = instantiate_LLM(
-    LLM_provider="Google",api_key=google_api_key,temperature=0.1,
-    model_name="gemini-pro"
-)
-
-standalone_question_chain = {
-    "standalone_question": {
-        "question": lambda x: x["question"],
-        "chat_history": lambda x: get_buffer_string(x["chat_history"]),
-    }
-    | condense_question_prompt
-    | condense_question_llm
-    | StrOutputParser(),
-}
-
-# 3. Combine load_memory and standalone_question_chain
-
-chain_question = loaded_memory | standalone_question_chain
-
-
-memory.clear()
-memory.save_context(
-    {"question": "What does Google stand for?"},
-    {"answer": "Diffuse to Choose."}
-)
-
-
-
-print("Chat history:\n",memory.load_memory_variables({}))
-
-follow_up_question = "plaese give more details about it, including its use cases and implementation."
-print("\nFollow-up question:\n",follow_up_question)
-
-# invoke chain_question
-response = chain_question.invoke({"question":follow_up_question})["standalone_question"]
-print("\nStandalone_question:\n",response)
-
-
-
-def _combine_documents(docs, document_prompt, document_separator="\n\n"):
-    doc_strings = [format_document(doc, document_prompt) for doc in docs]
-    return document_separator.join(doc_strings)
-
-# 1. Retrieve relevant documents
-
-retrieved_documents = {
-    "docs": itemgetter("standalone_question") | retriever,
-    "question": lambda x: x["standalone_question"],
-}
-
-# 2. Get variables ['chat_history', 'context', 'question'] that will be passed to `answer_prompt`
-
-DEFAULT_DOCUMENT_PROMPT = PromptTemplate.from_template(template="{page_content}")
-answer_prompt = ChatPromptTemplate.from_template(answer_template()) # 3 variables are expected ['chat_history', 'context', 'question']
-
-answer_prompt_variables = {
-    "context": lambda x: _combine_documents(docs=x["docs"],document_prompt=DEFAULT_DOCUMENT_PROMPT),
-    "question": itemgetter("question"),
-    "chat_history": itemgetter("chat_history") # get chat_history from `loaded_memory` variable
-}
-
-llm = instantiate_LLM(
-    LLM_provider="Google",api_key=google_api_key,temperature=0.5,
-    model_name="gemini-pro"
-)
-
-# 3. Load memory, format `answer_prompt` with variables (context, question and chat_history) and pass the `answer_prompt to LLM.
-# return answer, docs and standalone_question
-
-chain_answer = {
-    "answer": loaded_memory | answer_prompt_variables | answer_prompt | llm,
-    "docs": lambda x: [
-        Document(page_content=doc.page_content,metadata=doc.metadata) # return only page_content and metadata 
-        for doc in x["docs"]
-    ], 
-    "standalone_question": lambda x:x["question"] # return standalone_question
-}
 
 
-conversational_retriever_chain = chain_question | retrieved_documents | chain_answer
-follow_up_question = "plaese give more details about it, including its use cases and implementation."
-
-response = conversational_retriever_chain.invoke({"question":follow_up_question})
-gr.Markdown(response['answer'].content)
-
 
-memory.save_context( 
- {"question": follow_up_question},
- {"answer": response['answer'].content} 
-)
+def submit_message_OLD(prompt, prompt_template, temperature, max_tokens, context_length, state):
+    
+    
+    history = state['messages']
 
+    if not prompt:
+        return gr.update(value=''), [(history[i]['content'], history[i+1]['content']) for i in range(0, len(history)-1, 2)], state
+    
+    prompt_template = prompt_templates[prompt_template]
 
+    with open("prompts_archive.csv", "a") as csvfile:
+        writer = csv.DictWriter(csvfile, fieldnames=["prompt", "time"])
+        writer.writerow(
+            {"prompt": str(prompt), "time": str(datetime.now())}
+        )
+    
+   # with open(prompts_archive_file, "a") as csvfile:
+   #     writer = csv.DictWriter(csvfile, fieldnames=["prompt", "time"])
+   #     writer.writerow(
+   #         {"prompt": str(prompt), "time": str(datetime.now())}
+   #     )
+   # commit_url = repo.push_to_hub()
+   # print(commit_url)
 
+    system_prompt = []
+    if prompt_template:
+        system_prompt = [{ "role": "system", "content": prompt_template }]
 
-questions = ["what does DTC stands for?",
-             "plaese give more details about it, including its use cases and implementation.",
-             "does it outperform other diffusion-based models? explain in details.",
-             "what is Langchain?"]
+    prompt_msg = { "role": "user", "content": prompt }
 
-# Instantiate the retriever and the ConversationalRetrievalChain :
 
+    #try:
 
-retriever_HF = retrieval_blocks(
-    create_vectorstore=False,
-    LLM_service="HuggingFace",
-    vectorstore_name="Vit_All_HF_Embeddings",
-    retriever_type="Cohere_reranker",
-    base_retriever_search_type="similarity", base_retriever_k=16,
-    compression_retriever_k=20,
-    cohere_api_key=cohere_api_key,cohere_top_n=10,
-)
-
-chain_HF,memory_HF = custom_ConversationalRetrievalChain(
-    llm = instantiate_LLM(
-        LLM_provider="HuggingFace",api_key=HF_key,temperature=0.5,
-        model_name="mistralai/Mistral-7B-Instruct-v0.2"
-    ),
-    condense_question_llm = instantiate_LLM(
-        LLM_provider="HuggingFace",api_key=HF_key,temperature=0.5,
-        model_name="mistralai/Mistral-7B-Instruct-v0.2"
-    ),
-    retriever=retriever_HF,
-    language="english",
-    llm_provider="HuggingFace",
-    model_name="Mistral-7B-Instruct-v0.2"
-)
-
-
-memory_HF.clear()
+    with open("embeddings.pkl", 'rb') as f: 
+        new_docsearch = pickle.load(f)
+        
 
-response = chain_HF.invoke({"question":questions[0]})
+    query = str(system_prompt + history +  [prompt_msg])
     
-answer = response['answer']
-answer = answer[answer.find("\nAnswer: ")+len("\nAnswer: "):]
-
-gr.markdown("**Question:** "+questions[0]+"\n\n"\
-+"**Standalone_question:**"+response['standalone_question']+"\n\n"\
-+"**Answer:** "+answer)
-
-
-
-
+    docs = new_docsearch.similarity_search(query)
 
+    chain = load_qa_chain(ChatOpenAI(temperature=temperature, max_tokens=max_tokens, model_name="gpt-3.5-turbo"), chain_type="stuff")
+    #completion = chain.run(input_documents=docs, question=query)
+    
 
+    
+    get_empty_state()
+    state['content'] = completion
+    #state.append(completion.copy())
+    
+    completion = { "content": completion }
+    
+    
+    #state['total_tokens'] += completion['usage']['total_tokens']
 
 
-for i,question in enumerate(questions):
-    response = chain_gemini.invoke({"question":question})
-    answer = response['answer'].content
-    print(f"Question[{i}]:",question)
-    print("Standalone_question:",response['standalone_question'])
-    print("Answer:\n",answer,f"\n\n{'-' * 100}\n")
     
-    memory_gemini.save_context( {"question": question}, {"answer": answer} ) # update memory
-"""
+    #except Exception as e:
+    #    history.append(prompt_msg.copy())
+    #    error  = {
+    #        "role": "system",
+    #        "content": f"Error: {e}"
+    #    }
+    #    history.append(error.copy())
 
+    #total_tokens_used_msg = f"Total tokens used: {state['total_tokens']}"
 
+    chat_messages = [(prompt_msg['content'], completion['content'])]    
+    return '', chat_messages,  state    # total_tokens_used_msg,
 
 
+def clear_conversation():
+    return gr.update(value=None, visible=True), None, "", get_empty_state()