Update utils.py

utils.py

@@ -15,6 +15,10 @@ import sys
 import gc
 from pygments.lexers import guess_lexer, ClassNotFound
 import time
+import json
+import operator
+from typing import Annotated, Sequence, TypedDict
+import pprint
 
 import gradio as gr
 from pypinyin import lazy_pinyin
@@ -26,22 +30,37 @@ from pygments.lexers import guess_lexer,get_lexer_by_name
 from pygments.formatters import HtmlFormatter
 
 from langchain.chains import LLMChain, RetrievalQA
-from langchain.chat_models import ChatOpenAI
-from langchain.document_loaders import PyPDFLoader, WebBaseLoader, UnstructuredWordDocumentLoader, DirectoryLoader
+from langgraph.graph import END, StateGraph
+from langchain_openai import ChatOpenAI
+from langchain_community.document_loaders import PyPDFLoader, WebBaseLoader, UnstructuredWordDocumentLoader, DirectoryLoader
 from langchain.document_loaders.blob_loaders.youtube_audio import YoutubeAudioLoader
 from langchain.document_loaders.generic import GenericLoader
 from langchain.document_loaders.parsers import OpenAIWhisperParser
 from langchain.schema import AIMessage, HumanMessage
-from langchain.llms import HuggingFaceHub
-from langchain.llms import HuggingFaceTextGenInference
-from langchain.embeddings import HuggingFaceInstructEmbeddings, HuggingFaceEmbeddings, HuggingFaceBgeEmbeddings, HuggingFaceInferenceAPIEmbeddings
-from langchain.tools import DuckDuckGoSearchRun
+from langchain_community.llms import HuggingFaceHub
+from langchain_community.llms import HuggingFaceTextGenInference
+from langchain_community.embeddings import HuggingFaceInstructEmbeddings, HuggingFaceEmbeddings, HuggingFaceBgeEmbeddings, HuggingFaceInferenceAPIEmbeddings
+from langchain_community.tools import DuckDuckGoSearchRun
 from langchain.retrievers.tavily_search_api import TavilySearchAPIRetriever
+from typing import Dict, TypedDict
+from langchain_core.messages import BaseMessage
+from langchain_openai import OpenAIEmbeddings
+from langchain.prompts import PromptTemplate
 
-from langchain.embeddings.openai import OpenAIEmbeddings
+
+from langchain import hub
+from langchain.output_parsers.openai_tools import PydanticToolsParser
 from langchain.prompts import PromptTemplate
+from langchain.schema import Document
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_community.vectorstores import Chroma
+from langchain_core.messages import BaseMessage, FunctionMessage
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.pydantic_v1 import BaseModel, Field
+from langchain_core.runnables import RunnablePassthrough
+from langchain_core.utils.function_calling import convert_to_openai_tool
 from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.vectorstores import Chroma
+from langchain_community.vectorstores import Chroma
 from chromadb.errors import InvalidDimensionException
 import io
 from PIL import Image, ImageDraw, ImageOps, ImageFont
@@ -63,9 +82,7 @@ from reportlab.platypus import SimpleDocTemplate, Frame, Spacer
 from reportlab.lib import colors
 from reportlab.lib.units import mm
 from reportlab.platypus import Paragraph, SimpleDocTemplate, Frame, Image, Table, ListFlowable, ListItem
-from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
-from reportlab.lib.units import cm
-
+from reportlab.lib.styles import get
 
 logging.basicConfig(
     level=logging.INFO,
@@ -121,7 +138,13 @@ WEB_URL       = "https://openai.com/research/gpt-4"
 YOUTUBE_URL_1 = "https://www.youtube.com/watch?v=--khbXchTeE"
 YOUTUBE_URL_2 = "https://www.youtube.com/watch?v=hdhZwyf24mE"
 #YOUTUBE_URL_3 = "https://www.youtube.com/watch?v=vw-KWfKwvTQ"
-
+#spezielle Webseiten als Datenbasis laden
+urls = [
+    "https://kkg.hamburg.de/unser-leitbild/"
+    "https://kkg.hamburg.de/unsere-schulcharta/",
+    "https://kkg.hamburg.de/koordination-unterrichtsentwicklung/",
+    "https://kkg.hamburg.de/konzept-medien-und-it-am-kkg/",
+]
 
 #################################################
 # Retrieval Funktion, um KI-Antwort mit vorgegebenen zu vergleichen
@@ -206,10 +229,20 @@ def document_loading_splitting():
     pdf_documents = pdf_loader.load()
     word_documents = word_loader.load()
 
-    #alle zusammen in docs...
-    docs.extend(pdf_documents)
-    docs.extend(word_documents)
+    #urls -zum Thema passend
+    docs_web = [WebBaseLoader(url).load() for url in urls]
+    docs_list = [item for sublist in docs_web for item in sublist]
 
+    #alle zusammen in docs...
+    #pdf_docs als Liste umschreiben, um es mit den anderen Materialien in der docs_list zusammenzubringen
+    pdf_list = [pdf_documents]
+    word_list = [word_documents]
+    #die neuen Dokeumente der Gesamt-Liste von material hinzufügen
+    #alle zusammen in docs...
+    for doc in pdf_list:
+        docs_list.extend(doc)
+    for doc in word_list:
+        docs_list.extend(doc)
 
     #andere loader...
     # Load PDF
@@ -223,26 +256,154 @@ def document_loading_splitting():
     #docs.extend(loader.load())
     ################################
     # Document splitting
-    text_splitter = RecursiveCharacterTextSplitter(chunk_overlap = 150, chunk_size = 1500)
-    splits = text_splitter.split_documents(docs)
+    text_splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(chunk_size=1500, chunk_overlap=250)
+    doc_splits = text_splitter.split_documents(docs_list)
+    #text_splitter = RecursiveCharacterTextSplitter(chunk_overlap = 150, chunk_size = 1500)
+    #splits = text_splitter.split_documents(docs)
     
-    return splits
+    return doc_splits
 
 ###########################################
 #Chroma DB die splits ablegen - vektorisiert...
 def document_storage_chroma(splits):
-    #OpenAi embeddings----------------------------------
-    Chroma.from_documents(documents = splits, embedding = OpenAIEmbeddings(disallowed_special = ()),  persist_directory = PATH_WORK + CHROMA_DIR)  
+    # Add to vectorDB - mit Embeddings von OpenAi - Embeddings sind zur Klassifizierung der Dokumente im Vektorraum nötig
+    vectorstore = Chroma.from_documents(documents = splits, embedding = OpenAIEmbeddings(disallowed_special = ()),  persist_directory = PATH_WORK + CHROMA_DIR) 
+    retriever = vectorstore.as_retriever(search_kwargs = {"k": 5})
 
     #HF embeddings--------------------------------------
     #Chroma.from_documents(documents = splits, embedding = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2", model_kwargs={"device": "cpu"}, encode_kwargs={'normalize_embeddings': False}),  persist_directory = PATH_WORK + CHROMA_DIR)  
+    return vectorstore, retriever
+
+    
+#Dokumente, die vom Retriever rausgesucht wurden auf Relevanz untersuchen
+def grade_documents_direct(prompt, documents):
+    print("---CHECK RELEVANCE---")
+    
+    # Data model
+    class grade(BaseModel):
+        #Binary score for relevance check. 
+        binary_score: str = Field(description="Relevanz Bewertung 'ja' oder 'nein'")
+    
+    # LLM
+    model = ChatOpenAI(temperature=0.3, model="gpt-3.5-turbo-1106", streaming=True)
+
+    # Tool
+    grade_tool_oai = convert_to_openai_tool(grade)
+
+    # LLM with tool and enforce invocation
+    llm_with_tool = model.bind(
+        tools=[convert_to_openai_tool(grade_tool_oai)],
+        tool_choice={"type": "function", "function": {"name": "grade"}},
+    )
+
+    # Parser
+    parser_tool = PydanticToolsParser(tools=[grade])
+
+    # Prompt
+    prompt_gesamt = PromptTemplate(
+        template="""Du bist ein Bewerter, der die Relevanz von einem erhaltenen Dokument zu einer Nutzeranfrage bewerten soll. \n
+        Hier ist das erhaltene Dokument: \n\n {context} \n\n
+        Hier ist die Nutzeranfrage: {question} \n
+        Wenn das erhaltene Dokument Keywörter oder semantische Bedeutung in Bezug auf die Nutzeranfrage hat, bewerte es als relevant. \n
+        Gib eine binäre Bewertung von 'ja' oder 'nein' Bewertung, um anzuzeigen ob das Dokuemnt relevant ist zur Nutzeranfrage oder nicht.""",
+        input_variables=["context", "question"],
+    )
+    
+    # Chain
+    chain = prompt_gesamt | llm_with_tool | parser_tool
+
+    # Score
+    filtered_docs = []
+    for d in documents:
+        #print(d.page_content)
+        score = chain.invoke({"question": prompt, "context": d.page_content})
+        grade = score[0].binary_score
+        if grade == "ja":
+            print("---Bewertung: Dokument ist relevant---")
+            filtered_docs.append(d)
+        else:
+            print("---Bewertung: Dokument irrelevant---")
+            continue
+        
+    return filtered_docs
+
+#Prompt überarbeiten, wenn RAG angeschaltet, aber der Relevanz Check nicht genügend positive Eergebnisse gebracht hat
+#ChatGPT selbst formuliert den neuen Prompt
+def transform_query_direct(question):
+    print("---TRANSFORM QUERY---")
+
+    # Create a prompt template with format instructions and the query
+    prompt = PromptTemplate(
+        template="""Du generierst Fragen, die optimiert sind für das Retrieval von Dokumenten. \n
+        Schaue auf den input und versuche die zugrundeliegende Absicht / Bedeutung zu bewerten. \n
+        Hier ist die ursprüngliche Frage:
+        \n ------- \n
+        {question} 
+        \n ------- \n
+        Formuliere eine verbesserte Frage: """,
+        input_variables=["question"],
+    )
+
+    # Grader
+    model = ChatOpenAI(temperature=0, model="gpt-4-0125-preview", streaming=True)
+
+    # Prompt
+    chain = prompt | model | StrOutputParser()
+    better_question = chain.invoke({"question": question})
+
+    return better_question
+
+
+###############################################
+#Langchain anlegen
+###############################################
+#langchain nutzen, um prompt an LLM zu leiten - llm und prompt sind austauschbar
+def llm_chain(llm, prompt):
+    llm_chain = LLMChain(llm = llm, prompt = LLM_CHAIN_PROMPT)
+    result = llm_chain.run({"question": prompt})
+    return result
+
+#nur für HF-um bei chatverlauf kurzbeschreibung zu erzeugen
+def llm_chain2(llm, prompt):
+    llm_chain = LLMChain(llm = llm, prompt = LLM_CHAIN_PROMPT2)
+    result = llm_chain.run({"question": prompt})
+    return result
+
+    
+#############################################
+#langchain nutzen, um prompt an llm zu leiten, aber vorher in der VektorDB suchen, um passende splits zum Prompt hinzuzufügen
+#die erhaltenen dokumente (vom retriever) werden einem Relevanzcheck unterzogen, bevor sie an ChatGPT zum Beantworten gehen
+#den Relevanzcheck macht ebenfalls ein anderes KI-Modell. Wenn zu wenig relevante Dokumente rausgesucht wurden, wird die ursprüngliche Freage neu formuliert - und ein zweiter Versuch findet statt
+def rag_chain(llm, prompt,  retriever):
+    #Langgraph nutzen für ein wenig mehr Intelligenz beim Dokumente suchen
+    relevant_docs=[]
+    filtered_docs=[]
+    relevant_docs = retriever.get_relevant_documents(prompt)
+    print("releant docs1......................")
+    print(relevant_docs)
+    if (len(relevant_docs)>0):
+        filtered_docs = grade_documents_direct(prompt, relevant_docs)
+    
+    neu_prompt=prompt
+    if (len(filtered_docs)<2): #frage neu formulieren
+        relevant_docs=[]
+        neu_prompt = transform_query_direct(prompt)
+        relevant_docs = retriever.get_relevant_documents(neu_prompt)
+        if (len(relevant_docs)>0):
+            print("releant docs2......................")
+            print(relevant_docs)
+            filtered_docs = grade_documents_direct(neu_prompt, relevant_docs)
+
+    if (len(filtered_docs)>0):
+        llm_chain = LLMChain(llm = llm, prompt = RAG_CHAIN_PROMPT)
+        result = llm_chain.run({"context": filtered_docs, "question": neu_prompt})
+    else:
+        #Normale Abfrage, da keine relevanten Dokumente gefunden
+        llm_chain = LLMChain(llm = llm, prompt = LLM_CHAIN_PROMPT)
+        result = llm_chain.run({"question": neu_prompt})
+    return result
+
     
-#Mongo DB die splits ablegen - vektorisiert...
-def document_storage_mongodb(splits):
-    MongoDBAtlasVectorSearch.from_documents(documents = splits,
-                                            embedding = OpenAIEmbeddings(disallowed_special = ()),
-                                            collection = MONGODB_COLLECTION,
-                                            index_name = MONGODB_INDEX_NAME)
 ############################################
 #dokumente in chroma db vektorisiert ablegen können - die Db vorbereiten daüfur
 def document_retrieval_chroma(llm, prompt):