Delete app.py

app.py

@@ -1,1019 +0,0 @@
-import requests
-import os, sys, json
-import gradio as gr
-import openai
-from openai import OpenAI
-import time
-import re
-import io
-from PIL import Image, ImageDraw, ImageOps, ImageFont
-import base64
-import tempfile
-
-from PyPDF2 import PdfReader, PdfWriter
-
-from hugchat import hugchat
-from hugchat.login import Login
-from tavily import TavilyClient
-
-from langchain.chains import LLMChain, RetrievalQA
-from langchain.chat_models import ChatOpenAI
-from langchain.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.retrievers.tavily_search_api import TavilySearchAPIRetriever
-
-from langchain.embeddings.openai import OpenAIEmbeddings
-from langchain.prompts import PromptTemplate
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.vectorstores import Chroma
-from chromadb.errors import InvalidDimensionException
-from utils import *
-from beschreibungen import *
-
-
-#from langchain.vectorstores import MongoDBAtlasVectorSearch
-#from pymongo import MongoClient
-
-from dotenv import load_dotenv, find_dotenv
-_ = load_dotenv(find_dotenv())
-
-
-###############################################
-#globale Variablen
-##############################################
-#nur bei ersten Anfrage splitten der Dokumente - um die Vektordatenbank entsprechend zu füllen
-#splittet = False
-#DB für Vektorstore
-db = None
-
-#############################################
-# Allgemeine Konstanten
-#Filepath zu temp Folder (temp) mit File von ausgewähltem chatverlauf
-file_path_download = ""
-
-##################################################
-#Für MongoDB statt Chroma als Vektorstore
-#MONGODB_URI = os.environ["MONGODB_ATLAS_CLUSTER_URI"]
-#client = MongoClient(MONGODB_URI)
-#MONGODB_DB_NAME = "langchain_db"
-#MONGODB_COLLECTION_NAME = "gpt-4"
-#MONGODB_COLLECTION = client[MONGODB_DB_NAME][MONGODB_COLLECTION_NAME]
-#MONGODB_INDEX_NAME = "default"
-
-
-
-#Plattform Keys aus den Secrets holen zu diesem Space
-HUGGINGFACEHUB_API_TOKEN = os.getenv("HF_ACCESS_READ")
-OAI_API_KEY=os.getenv("OPENAI_API_KEY")
-HEADERS = {"Authorization": f"Bearer {HUGGINGFACEHUB_API_TOKEN}"}
-TAVILY_KEY = os.getenv("TAVILY_KEY")
-os.environ["TAVILY_API_KEY"] = TAVILY_KEY
-ANTI_BOT_PW = os.getenv("CORRECT_VALIDATE")
-
-
-################################################
-#LLM Model mit dem gearbeitet wird
-#openai-------------------------------------
-#MODEL_NAME  = "gpt-3.5-turbo-16k"
-#MODEL_NAME = "gpt-3.5-turbo-1106"
-MODEL_NAME= "gpt-4-1106-preview"
-MODEL_NAME_IMAGE = "gpt-4-vision-preview"
-MODEL_NAME_CODE = "code-davinci-002"
-
-
-#verfügbare Modelle anzeigen lassen
-#HuggingFace Reop ID--------------------------------
-#repo_id = "meta-llama/Llama-2-13b-chat-hf"   
-repo_id = "HuggingFaceH4/zephyr-7b-alpha"   #das Modell ist echt gut!!! Vom MIT
-#repo_id = "TheBloke/Yi-34B-Chat-GGUF"
-#repo_id = "meta-llama/Llama-2-70b-chat-hf"    
-#repo_id = "tiiuae/falcon-40b"  
-#repo_id = "Vicuna-33b"
-#repo_id = "alexkueck/ChatBotLI2Klein"
-#repo_id = "mistralai/Mistral-7B-v0.1"
-#repo_id = "internlm/internlm-chat-7b"
-#repo_id = "Qwen/Qwen-7B"
-#repo_id = "Salesforce/xgen-7b-8k-base"
-#repo_id = "Writer/camel-5b-hf" 
-#repo_id = "databricks/dolly-v2-3b"
-#repo_id = "google/flan-t5-xxl"
-#repo_id  = "mistralai/Mixtral-8x7B-Instruct-v0.1"
-#repo_id = "abacusai/Smaug-72B-v0.1"
-
-#HuggingFace Model name--------------------------------
-MODEL_NAME_HF  = "mistralai/Mixtral-8x7B-Instruct-v0.1"
-#MODLE_NAME_HF = "abacusai/Smaug-72B-v0.1"
-MODEL_NAME_OAI_ZEICHNEN = "dall-e-3"
-#Alternativ zeichnen: Stabe Diffusion from HF:
-#API Inference allgemien: https://api-inference.huggingface.co/models/{model}
-#Zeichnen
-API_URL = "https://api-inference.huggingface.co/models/stabilityai/stable-diffusion-2-1"
-#Textgenerierung
-API_URL_TEXT = "https://api-inference.huggingface.co/models/argilla/notux-8x7b-v1"
-
-###############################################
-# Formatierung im PDF - Konstanten setzen
-# Breite und Höhe für Spalten
-COLUMN_WIDTH = 150
-ROW_HEIGHT = 20
-# Bereiche für Spalten
-TIMESTAMP_X = 50
-USER_X = TIMESTAMP_X + COLUMN_WIDTH
-ASSISTANT_X = USER_X + COLUMN_WIDTH
-# Rand und Abstand zwischen Zeilen
-MARGIN = 50
-LINE_SPACING = 10
-
-
-
-################################################
-#HF Hub Zugriff ermöglichen
-###############################################
-os.environ["HUGGINGFACEHUB_API_TOKEN"] = HUGGINGFACEHUB_API_TOKEN
-
-###############################################
-#Alternativ: HuggingChat API nutzen
-pw=os.getenv("HFPW")
-email= os.getenv("HFEMail")
-#sign = Login(email, pw)
-#cookies = sign.login()
-# Save cookies to the local directory
-#cookie_path_dir = "cookies_hf"
-#sign.saveCookiesToDir(cookie_path_dir)
-
-
-################################################
-#OpenAI Zugang, client und Assistant einmal erzeugen.
-################################################
-#zentral einmal erzeugen!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
-client = OpenAI()
-general_assistant_file = client.beta.assistants.create(name="File Analysator",instructions=template, model="gpt-4-1106-preview",)
-thread_file = client.beta.threads.create()
-general_assistant_suche= openai_assistant_suche(client)
-
-
-#################################################
-#################################################
-#################################################
-#Funktionen zur Verarbeitung
-################################################
-
-##############################################
-#wenn löschen Button geklickt
-def clear_all(history, uploaded_file_paths, chats):
-    dic_history = {schluessel: wert for schluessel, wert in history}
-    #später wird die summary auf 50 tokens verkürzt, um die Anfrage nicht so teuer werden zu lassen
-    #summary wird gebraucht für die Anfrage beim NN, um eine Überschrift des Eintrages zu generieren
-    summary = "\n\n".join(f'{schluessel}: \n  {wert}' for schluessel, wert in dic_history.items())
-   
-    #falls file mit summay für download existiert hat: das zunächst löschen
-    #cleanup(file_path_download)
-    #noch nicht im Einsatz, aber hier werden alle Chats einer Sitzung gespeichert
-    #den aktuellen Chatverlauf zum Download bereitstellen:
-    if chats != {} :
-        id_neu = len(chats)+1
-        chats[id_neu]= summary 
-    else:
-        chats[0]= summary
-
-    #Eine Überschrift zu dem jeweiligen Chatverlauf finden - abhängig vom Inhalt
-    #file_path_download = save_and_download(summary)
-    headers, payload = process_chatverlauf(summary, MODEL_NAME, OAI_API_KEY)
-    response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload)
-    #als json ausgeben
-    data = response.json()
-    # Den "content" auswählen, da dort die Antwort der Ki enthalten ist
-    result = data['choices'][0]['message']['content']
-    worte = result.split()
-    if len(worte) > 2:
-        file_path_download = "data/" + str(len(chats)) + "_Chatverlauf.pdf"
-    else:
-        file_path_download = "data/" + str(len(chats)) + "_" + result + ".pdf"
-
-    erstellePdf(file_path_download, result, dic_history)
-
-    
-    #die session variable in gradio erweitern und alle fliepath neu in das gr.File hochladen
-    uploaded_file_paths=  uploaded_file_paths + [file_path_download]
- 
-    return None, gr.Image(visible=False), uploaded_file_paths, [], gr.File(uploaded_file_paths, label="Download-Chatverläufe",  visible=True, file_count="multiple", interactive = False), chats
-    
-
-#wenn löschen Button geklickt
-def clear_all3(history):          
-    #die session variable in gradio erweitern und alle fliepath neu in das gr.File hochladen
-    uploaded_file_paths=  ""
-    return None, gr.Image(visible=False), [],  
-    
-
-
-##############################################
-#History - die Frage oder das File eintragen...
-#in history_file ist ein file gespeichert, falls voher im Verlauf schon ein File hochgeladen wurde.
-#wird ein neuer File hochgeladen, so wird history_fiel dadurch ersetzt
-def add_text(chatbot, history, prompt, file, file_history):
-    if (file == None):
-        chatbot = chatbot +[(prompt, None)]
-    else:
-        file_history = file
-        if (prompt == ""):
-            chatbot=chatbot + [((file.name,), "Prompt fehlt!")]
-        else:
-            ext = analyze_file(file)
-            if (ext == "png" or ext == "PNG" or ext == "jpg" or ext == "jpeg" or ext == "JPG" or ext == "JPEG"):
-                chatbot = chatbot +[((file.name,), None), (prompt, None)]
-            else:
-                chatbot = chatbot +[("Hochgeladenes Dokument: "+ get_filename(file) +"\n" + prompt, None)]
-
-    return chatbot, history, prompt, file, file_history, gr.Image(visible = False), "" #gr.Image( label=None, size=(30,30), visible=False, scale=1) #gr.Textbox(value="", interactive=False)
-
-def add_text2(chatbot, prompt):   
-    if (prompt == ""):
-        chatbot = chatbot + [("", "Prompt fehlt!")]
-    else:
-        chatbot = chatbot + [(prompt, None)]
-    print("chatbot nach add_text............")
-    print(chatbot)
-    return chatbot, prompt, ""
-
-    
-############################################
-#nach dem Upload soll das zusätzliche Fenster mit dem image drinnen angezeigt werden
-def file_anzeigen(file):
-    ext = analyze_file(file)
-    if (ext == "png" or ext == "PNG" or ext == "jpg" or ext == "jpeg" or ext == "JPG" or ext == "JPEG"):
-        return gr.Image(width=47, visible=True, interactive = False,  height=47,  min_width=47,  show_label=False, show_share_button=False, show_download_button=False, scale = 0.5), file, file
-    else:
-        return gr.Image(width=47, visible=True, interactive = False,  height=47,  min_width=47,  show_label=False, show_share_button=False, show_download_button=False, scale = 0.5), "data/file.png", file
-        
-def file_loeschen():
-    return None, gr.Image(visible = False)
-
-############################################
-#wenn 'Stop' Button geklickt, dann Message dazu und das Eingabe-Fenster leeren
-def cancel_outputing():
-    reset_textbox()
-    return "Stop Done"
-
-def reset_textbox():
-    return gr.update(value=""),""
-
-    
-##########################################
-#Hilfsfunktion, um ein von Stable Diffusion erzeugtes Bild für die Ausgabe in der History vorzubereiten
-def umwandeln_fuer_anzeige(image):
-        buffer = io.BytesIO()  
-        image.save(buffer, format='PNG')
-        return buffer.getvalue()
-    
-
-
-##################################################
-#openassistant um uploaded Files zu analysieren
-def create_assistant_file(prompt, file):
-    global client, general_assistant_file
-    #neues File dem Assistant hinzufügen
-    file_neu = client.files.create(file=open(file,"rb",),purpose="assistants",)
-    # Update Assistant
-    #wenn type: code_interpreter, wird das file mit angehängt an den Prpmt, aber vorher nicht bearbeitet
-    #wenn type: retrieval, wird das Dokument vorher embedded in einem vektorstore und nur entsprechende chunks mitgegeben.
-    #pro Assistant 20 cent pro Tag als Nutzung - egal wie viele Fragen dazu.
-    updated_assistant = client.beta.assistants.update(general_assistant_file.id,tools=[{"type": "code_interpreter"}, {"type": "retrieval"}],file_ids=[file_neu.id],)
-    thread_file, run = create_thread_and_run(prompt, client, updated_assistant.id)
-    run = wait_on_run(run, thread_file, client)
-    response = get_response(thread_file, client, updated_assistant.id)
-    result = response.data[1].content[0].text.value
-    return result
-
-##################################################
-#openassistant um im Netz zu suchen
-def create_assistant_suche(prompt):
-    #global client, general_assistant_suche
-
-    retriever = TavilySearchAPIRetriever(k=4)
-    result = retriever.invoke(template + prompt)
-    erg = "Aus dem Internet: " + result[0].page_content + ".\n Quelle: "
-    src = result[0].metadata['source']
-
-    """
-    #neues Thread mit akt. prompt dem Assistant hinzufügen
-    thread_suche, run = create_thread_and_run(prompt, client, general_assistant_suche.id)
-    run = wait_on_run(run, thread_suche, client)
-    response = get_response(thread_suche, client, general_assistant_suche.id)
-    result = response.data[1].content[0].text.value
-    """
-    return erg + src
-
-
-#huggingchat um im Netz zu suchen
-def create_assistant_suche_hf(chatbot, prompt):
-    erg, src = hugchat_search(chatbot, prompt)
-    return erg + src    
-
-###################################################
-#Funktion von Gradio aus, die den dort eingegebenen Prompt annimmt und weiterverarbeitet
-###################################################
-#########################################################
-#Funktion wird direkt aufgerufen aus der GUI - von hier muss auch die Rückmeldung kommen....
-#man kann einen Text-Prompt eingeben (mit oder ohne RAG), dazu ein Image hochladen, ein Bild zu einem reinen textprompt erzeugen lassen
-def generate_auswahl(prompt_in, file, file_history, chatbot, history, rag_option, model_option, openai_api_key, k=3, top_p=0.6, temperature=0.5, max_new_tokens=4048, max_context_length_tokens=2048, repetition_penalty=1.3,top_k=35, websuche="Aus", validate=False):
-        global db
-        #nur wenn man sich validiert hat, kann die Anwendung los legen
-        if (validate and not prompt_in == "" and not prompt_in == None):
-            #wenn RAG angeschaltet - Vektorstore initialisieren
-            #aber nur, wenn es noch nicht geshehen ist (splittet = False)
-            #falls schon ein File hochgeladen wurde, ist es in history_file gespeichert - falls ein neues File hochgeladen wurde, wird es anschließend neu gesetzt
-            neu_file = file_history
-        
-            #prompt normalisieren bevor er an die KIs geht
-            prompt = normalise_prompt(prompt_in)
-        
-            if (rag_option == "An"):
-                #muss nur einmal ausgeführt werden... 
-                if db == None:
-                    print("db neu aufbauen!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!1")
-                    splits = document_loading_splitting()
-                    document_storage_chroma(splits)
-                db = document_retrieval_chroma2()
-                print("db aktiv!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
-                print(db)
-            #else:  #unnötig, da wenn Vektorstor einmal für alle user eingerichtet, wer weiter besthen bleiben kann - die unterschiedlichen Propmt werden dann später je nach rag_option erzeugt
-                #db=None
-                #splittet = False #sonst würde es für alle User wieder ausgeschaltet - Alternative: gr.State(False) dazu anlegen
-    
-            #kein Bild hochgeladen -> auf Text antworten...
-            status = "Antwort der KI ..."
-            if (file == None and file_history == None):
-                result, status = generate_text(prompt, chatbot, history, rag_option, model_option, openai_api_key, db, websuche, k=3, top_p=0.6, temperature=0.5, max_new_tokens=4048, max_context_length_tokens=2048, repetition_penalty=1.3, top_k=3)
-                history = history + [[prompt, result]]
-            else:
-                #Es wurde ein File neu angehängt -> wenn prompt dazu, das Bild analysieren
-                #das history_fiel muss neu gesetzt werden
-                if (file != None):
-                    # file_history wird neu gesetzt in der Rückgabe dieser Funktion...
-                    neu_file = file
-    
-                #herausfinden, ob Bild oder Dokument...
-                ext = analyze_file(neu_file)
-                if (ext == "png" or ext == "PNG" or ext == "jpg" or ext == "jpeg" or ext == "JPG" or ext == "JPEG"):
-                    result= generate_text_zu_bild(neu_file, prompt, k, rag_option, chatbot, history, db)
-                else:
-                    result = generate_text_zu_doc(neu_file, prompt, k, rag_option, chatbot, history, db)
-    
-                #die history erweitern - abhängig davon, ob gerade ein file hochgeladen wurde oder nicht
-                if (file != None):    
-                    history = history + [[(file,), None],[prompt, result]]
-                else:
-                    history = history + [[prompt, result]]
-                    
-            chatbot[-1][1] = ""
-            for character in result:
-                chatbot[-1][1] += character
-                time.sleep(0.03)
-                yield chatbot, history, None, neu_file, status
-                if shared_state.interrupted:
-                    shared_state.recover()
-                    try:
-                        yield chatbot, history, None, neu_file, "Stop: Success"
-                    except:
-                        pass
-        else: #noch nicht validiert, oder kein Prompt
-            return chatbot, history, None, file_history, "Erst validieren oder einen Prompt eingeben!"
-            
-##################################################
-#zu einem Text-Prompt ein Bild via Stable Diffusion generieren
-def generate_bild(prompt, chatbot, model_option_zeichnen='HuggingFace', temperature=0.5, max_new_tokens=4048,top_p=0.6, repetition_penalty=1.3, validate=False):
-    global client
-    if (validate):
-        if (model_option_zeichnen == "Stable Diffusion"):
-            print("Bild Erzeugung HF..............................")
-            #Bild nach Anweisung zeichnen und in History darstellen...
-            data = {"inputs": prompt}
-            response = requests.post(API_URL, headers=HEADERS, json=data)
-            print("fertig Bild")
-            result = response.content 
-            #Bild ausgeben
-            image = Image.open(io.BytesIO(result)) 
-            image_64 = umwandeln_fuer_anzeige(image)
-            chatbot[-1][1]= "<img src='data:image/png;base64,{0}'/>".format(base64.b64encode(image_64).decode('utf-8'))
-        else:     
-            print("Bild Erzeugung DallE..............................")
-            #als Format ginge auch 'url', n - Anz. der erzeugten Bilder
-            response = client.images.generate(model="dall-e-3",prompt=prompt,size="1024x1024",quality="standard",n=1, response_format='b64_json') 
-            #chatbot[-1][1]= "<img src='data:image/png;base64,{0}'/>".format(base64.b64encode(image_64).decode('utf-8'))
-            chatbot[-1][1] = "<img src='data:image/png;base64,{0}'/>".format(response.data[0].b64_json)
-        
-        return chatbot, "Antwort KI: Success"
-    else: #noch nicht validiert ...
-        return chatbot, "Bitte erst validieren!"
-    
-
-##################################################
-#zu einem Bild und Text-Prompt eine Analyse generieren
-def generate_text_zu_bild(file, prompt, k, rag_option, chatbot, history, db):
-    global splittet
-    print("Text mit Bild ..............................")
-    prompt_neu = generate_prompt_with_history(prompt, history)
-    if (rag_option == "An"):
-        print("Bild mit RAG..............................")
-        neu_text_mit_chunks = rag_chain2(prompt, db, k)
-        #für Chat LLM:
-        #prompt = generate_prompt_with_history_openai(neu_text_mit_chunks, history)
-        #als reiner prompt:
-        prompt_neu = generate_prompt_with_history(neu_text_mit_chunks, history)
-
-    headers, payload = process_image(file, prompt_neu, MODEL_NAME_IMAGE, OAI_API_KEY)
-    response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload)
-    #als json ausgeben
-    data = response.json()
-    # Den "content" auswählen, da dort die Antwort der Ki enthalten ist
-    result = data['choices'][0]['message']['content']
-    return result
-
-
-##################################################
-#zu einem Bild und Text-Prompt eine Analyse generieren
-def generate_text_zu_doc(file, prompt, k, rag_option, chatbot, history, db):
-    global splittet
-    print("text mit doc ..............................")
-     
-    prompt_neu = generate_prompt_with_history(prompt, history)
-    if (rag_option == "An"):
-        print("Doc mit RAG..............................")
-        neu_text_mit_chunks = rag_chain2(prompt, db, k)
-        #für Chat LLM:
-        #prompt_neu = generate_prompt_with_history_openai(neu_text_mit_chunks, history)
-        #als reiner prompt:
-        prompt_neu = generate_prompt_with_history(neu_text_mit_chunks, history) 
-        
-    result = create_assistant_file(prompt_neu, file)
-    return result    
-    
-
-####################################################
-#aus einem Text-Prompt die Antwort von KI bekommen
-#mit oder ohne RAG möglich
-def generate_text (prompt, chatbot, history, rag_option, model_option, openai_api_key, db, websuche, k=3, top_p=0.6, temperature=0.5, max_new_tokens=4048, max_context_length_tokens=2048, repetition_penalty=1.3, top_k=35):
-    #global splittet
-    #hugchat=False
-    suche_im_Netz="Antwort der KI ..."
-    print("Text pur..............................")
-    
-    if (openai_api_key == "" or openai_api_key == "sk-"):
-        #raise gr.Error("OpenAI API Key is required.")
-        #eigenen OpenAI key nutzen
-        openai_api_key= OAI_API_KEY
-    if (rag_option is None):
-        raise gr.Error("Retrieval Augmented Generation ist erforderlich.")
-    if (prompt == ""):
-        raise gr.Error("Prompt ist erforderlich.")
-
-    #history für HuggingFace Models formatieren
-    #history_text_und_prompt = generate_prompt_with_history_hf(prompt, history)
-    #history für openAi formatieren
-    #history_text_und_prompt = generate_prompt_with_history_openai(prompt, history)
-    #history für Langchain formatieren
-    #history_text_und_prompt = generate_prompt_with_history_langchain(prompt, history)
-    
-    try:
-        if (websuche=="Aus"):
-            ###########################
-            #LLM auswählen (OpenAI oder HF)
-            ###########################
-            if (model_option == "OpenAI"):
-                #Anfrage an OpenAI ----------------------------
-                print("OpenAI Anfrage.......................")
-                llm = ChatOpenAI(model_name = MODEL_NAME,  openai_api_key = openai_api_key, temperature=temperature)#, top_p = top_p) 
-                #Prompt an history anhängen und einen Text daraus machen
-                #wenn da Dokumenten Teile (RAG dazu kommen, wird das anders zusammengestellt, als ohne...)
-                if (rag_option == "An"):
-                    history_text_und_prompt = generate_prompt_with_history(prompt, history) 
-                else:
-                    history_text_und_prompt = generate_prompt_with_history_openai(prompt, history) 
-            else:
-                #oder an Hugging Face --------------------------
-                print("HF Anfrage.......................")
-                model_kwargs={"temperature": 0.5, "max_length": 512, "num_return_sequences": 1, "top_k": top_k, "top_p": top_p, "repetition_penalty": repetition_penalty}
-                llm = HuggingFaceHub(repo_id=repo_id, model_kwargs=model_kwargs) 
-                #llm = HuggingFaceChain(model=MODEL_NAME_HF, model_kwargs={"temperature": 0.5, "max_length": 128}) 
-                #llm = HuggingFaceHub(url_??? = "https://wdgsjd6zf201mufn.us-east-1.aws.endpoints.huggingface.cloud", model_kwargs={"temperature": 0.5, "max_length": 64}) 
-                #llm = HuggingFaceTextGenInference( inference_server_url="http://localhost:8010/", max_new_tokens=max_new_tokens,top_k=10,top_p=top_p,typical_p=0.95,temperature=temperature,repetition_penalty=repetition_penalty,)
-                #llm via HuggingChat
-                #llm = hugchat.ChatBot(cookies=cookies.get_dict())
-                #hugchat=True   #da dieses Model in llm_chain bzw reag_chain anderes verarbeitet wird
-                
-                print("HF")
-                #Prompt an history anhängen und einen Text daraus machen
-                history_text_und_prompt = generate_prompt_with_history(prompt, history) 
-        
-            #zusätzliche Dokumenten Splits aus DB zum Prompt hinzufügen (aus VektorDB - Chroma oder Mongo DB)
-            if (rag_option == "An"):
-                print("LLM aufrufen mit RAG: ...........")
-                print(history_text_und_prompt)
-                print("-------------------------------")
-                result = rag_chain(llm, history_text_und_prompt, db)  #für hugchat noch kein rag möglich...
-                #weitere Möglichkeit für Rag-Chain - dann auch für HF Modelle möglich, da kein llm in Langchain übergeben werden muss...
-                #result = rag_chain2(history_text_und_prompt, db, 5)
-                print("result regchain.....................")
-                print(result)
-            else:
-                #splittet = False
-                print("LLM aufrufen ohne RAG: ...........")
-                resulti = llm_chain(llm, history_text_und_prompt)
-                result = resulti.strip()
-                """
-                #Alternativ mit API_URL - aber das model braucht 93 B Space!!!
-                    data = {"inputs": prompt, "options": {"max_new_tokens": max_new_tokens},}
-                    response = requests.post(API_URL_TEXT, headers=HEADERS, json=data)
-                    result = response.json()
-                    print("responseresult.............................")
-                    print(result)
-                    chatbot_response = result[0]['generated_text']
-                    print("anzahl tokens gesamt antwort:------------------")
-                    print (len(chatbot_response.split()))
-                    chatbot_message = chatbot_response[len(prompt):].strip()
-                    print("history/chatbot_rsponse:--------------------------------")
-                    print(history)
-                    print(chatbot_message) 
-                    result = chatbot_message
-                """
-        else: #Websuche ist An
-            print("Suche im Netz: ...........")
-            suche_im_Netz="Antwort aus dem Internet ..."
-            #Prompt an history anhängen und einen Text daraus machen
-            history_text_und_prompt = generate_prompt_with_history(prompt, history) 
-            #if (hugchat):
-                #mit hugchat
-                #result = create_assistant_suche_hf(llm, history_text_und_prompt)
-            #else:
-            #mit tavily: 
-            result = create_assistant_suche(history_text_und_prompt)
-            
-                
-        """
-        #Wenn keine Antwort möglich "Ich weiß es nicht" etc., dann versuchen mit Suche im Internet.
-        if (result == None or is_response_similar(result)):
-            print("Suche im Netz: ...........")
-            suche_im_Netz="Antwort aus dem Internet ..."
-            result = create_assistant_suche(prompt)
-        """
-    except Exception as e:
-        raise gr.Error(e)
-
-    return result, suche_im_Netz
-
-
-#Funktion wird direkt aufgerufen aus der GUI - von hier muss auch die Rückmeldung kommen....
-#man kann einen Text-Prompt eingeben , dazu ein Image hochladen, und dann dazu code erzeugen lassen
-def generate_code(prompt_in, file, file_history, chatbot, history,  model_option, openai_api_key, k=3, top_p=0.6, temperature=0.5, max_new_tokens=4048, max_context_length_tokens=2048, repetition_penalty=1.3,top_k=35):
-        #prompt normalisieren bevor er an die KIs geht
-        prompt = normalise_prompt(prompt_in)
-        #falls schon ein File hochgeladen wurde, ist es in history_file gespeichert - falls ein neues File hochgeladen wurde, wird es anschließend neu gesetzt
-        neu_file = file_history
-    
-        #kein Bild hochgeladen -> auf Text antworten...
-        status = "Antwort der KI ..."
-        if (file == None and file_history == None):
-            result, status = generate_code_antwort(prompt, chatbot, history, model_option, openai_api_key, k=3, top_p=0.6, temperature=0.5, max_new_tokens=4048, max_context_length_tokens=2048, repetition_penalty=1.3, top_k=35)
-            history = history + [[prompt, result]]
-        else:
-            #Es wurde ein File neu angehängt -> wenn prompt dazu, das Bild analysieren
-            #das history_fiel muss neu gesetzt werden
-            if (file != None):
-                # file_history wird neu gesetzt in der Rückgabe dieser Funktion...
-                neu_file = file
-
-            #herausfinden, ob Bild oder Dokument...
-            ext = analyze_file(neu_file)
-            if (ext == "png" or ext == "PNG" or ext == "jpg" or ext == "jpeg" or ext == "JPG" or ext == "JPEG"):
-                result= generate_text_zu_bild(neu_file, prompt, k, rag_option, chatbot, history, db)
-            else:
-                result = generate_text_zu_doc(neu_file, prompt, k, rag_option, chatbot, history, db)
-
-            #die history erweitern - abhängig davon, ob gerade ein file hochgeladen wurde oder nicht
-            if (file != None):    
-                history = history + [[(file,), None],[prompt, result]]
-            else:
-                history = history + [[prompt, result]]
-                
-        chatbot[-1][1] = ""
-        for character in result:
-            chatbot[-1][1] += character
-            time.sleep(0.03)
-            yield chatbot, history, None, neu_file, status
-            if shared_state.interrupted:
-                shared_state.recover()
-                try:
-                    yield chatbot, history, None, neu_file, "Stop: Success"
-                except:
-                    pass
-
-
-####################################################
-#aus einem Text-Prompt die Antwort von KI bekommen
-#mit oder ohne RAG möglich
-def generate_code_antwort (prompt, chatbot, history, model_option, openai_api_key,  k=3, top_p=0.6, temperature=0.5, max_new_tokens=4048, max_context_length_tokens=2048, repetition_penalty=1.3, top_k=35):
-    suche_im_Netz="Antwort der KI ..."
-    print("Text pur..............................")
-    if (openai_api_key == "" or openai_api_key == "sk-"):
-        #raise gr.Error("OpenAI API Key is required.")
-        #eigenen OpenAI key nutzen
-        openai_api_key= OAI_API_KEY
-    if (prompt == ""):
-        raise gr.Error("Prompt ist erforderlich.")
-
-    
-    try:
-        ###########################
-        #LLM auswählen (OpenAI oder HF)
-        ###########################
-        if (model_option == "Davinci"):
-            #Anfrage an OpenAI ----------------------------
-            print("OpenAI Anfrage.......................")
-            llm = ChatOpenAI(model_name = MODEL_NAME_CODE,  openai_api_key = openai_api_key, temperature=temperature)#, top_p = top_p) 
-            #Prompt an history anhängen und einen Text daraus machen
-            history_text_und_prompt = generate_prompt_with_history_openai(prompt, history) 
-        else:
-            llm = ChatOpenAI(model_name = MODEL_NAME_IMAGE,  openai_api_key = openai_api_key, temperature=temperature)#, top_p = top_p) 
-            #Prompt an history anhängen und einen Text daraus machen
-            history_text_und_prompt = generate_prompt_with_history_openai(prompt, history)
-            
-        print("LLM aufrufen ohne RAG: ...........")
-        resulti = llm_chain(llm, history_text_und_prompt)
-        result = resulti.strip()
-    except Exception as e:
-        raise gr.Error(e)
-
-    return result, suche_im_Netz    
-      
-################################################
-#GUI
-###############################################
-#Beschreibung oben in GUI
-################################################
-
-#css = """.toast-wrap { display: none !important } """
-#examples=[['Was ist ChtGPT-4?'],['schreibe ein Python Programm, dass die GPT-4 API aufruft.']]
-
-def vote(data: gr.LikeData):
-    if data.liked: print("You upvoted this response: " + data.value)
-    else: print("You downvoted this response: " + data.value)
-
-def custom_css():
-    return """
-    body, html {
-        background-color: #303030; /* Dunkler Hintergrund */
-        color:#353535;
-    }
-    """
-    
-
-########################################
-# Bot- test gegen schädliche Bots die die Anwendung testen...
-# Funktion zur Überprüfung der Benutzereingabe
-# Funktion zur Überprüfung der Eingabe und Aktivierung der Hauptanwendung
-def validate_input(user_input_validate, validate=False):
-    user_input_hashed = hash_input(user_input_validate)
-    if user_input_hashed == hash_input(ANTI_BOT_PW):
-        return "Richtig! Weiter gehts... ", True, gr.Textbox(visible=False), gr.Button(visible=False)
-    else:
-        return "Falsche Antwort!!!!!!!!!", False, gr.Textbox(label = "", placeholder="Bitte tippen Sie das oben im Moodle Kurs angegebene Wort ein, um zu beweisen, dass Sie kein Bot sind.", visible=True, scale= 5), gr.Button("Validieren", visible = True)
-        
-
-#############################################################################################
-# Start Gui Vorabfrage
-# Validierungs-Interface - Bots weghalten...
-print ("Start GUI Vorabfrage")
-#################################################################################################    
-print ("Start GUI Hauptanwendung")
-with open("custom.css", "r", encoding="utf-8") as f:
-    customCSS = f.read()
-
-#Add Inputs für Tab 2
-additional_inputs = [
-                gr.Slider(label="Temperature", value=0.65, minimum=0.0, maximum=1.0, step=0.05, interactive=True, info="Höhere Werte erzeugen diversere Antworten", visible=True),
-                gr.Slider(label="Max new tokens", value=1024, minimum=0, maximum=4096, step=64, interactive=True, info="Maximale Anzahl neuer Tokens", visible=True),
-                gr.Slider(label="Top-p (nucleus sampling)", value=0.6, minimum=0.0, maximum=1, step=0.05, interactive=True, info="Höhere Werte verwenden auch Tokens mit niedrigerer Wahrscheinlichkeit.", visible=True),
-                gr.Slider(label="Repetition penalty", value=1.2, minimum=1.0, maximum=2.0, step=0.05, interactive=True, info="Strafe für wiederholte Tokens", visible=True)
-            ]
-with gr.Blocks(css=customCSS, theme=themeAlex) as demo:
-    #validiert speichern
-    validate = gr.State(False)
-    #Session Variablen, um Weete zu speichern, auch wenn die Felder in der GUI bereits wieder leer sind
-    # history parallel zu chatbot speichern - da in chatbot bei Bildern zum Anzeigen in der GUI die Bilder speziell formatiert werden, 
-    # für die Übergabe an die ki aber der Pfad zum Bild behalten werden muss - was in der history der Fall ist!
-    history = gr.State([])
-    uploaded_file_paths= gr.State([])
-    history3 = gr.State([])
-    uploaded_file_paths3= gr.State([])
-    #alle chats einer Session sammeln
-    chats = gr.State({})
-    #damit der Prompt auch nach dem upload in die History noch für predicts_args verfügbar ist
-    user_question = gr.State("")
-    #für die anderen Tabs auch...
-    #damit der Prompt auch nach dem upload in die History noch für predicts_args verfügbar ist
-    user_question2 = gr.State("")
-    user_question3 = gr.State("")
-    attached_file = gr.State(None)
-    attached_file_history = gr.State(None)
-    attached_file3 = gr.State(None)
-    attached_file_history3 = gr.State(None)
-    status_display = gr.State("")
-    status_display2 = gr.State("")
-    status_display3 = gr.State("")
-    ################################################
-    # Tab zum Chatbot mit Text oder Bildeingabe
-    ################################################
-    gr.Markdown(description_top)
-    with gr.Row():
-            user_input_validate =gr.Textbox(label= "Bitte das oben im Moodle Kurs angegebene Wort eingeben, um die Anwendung zu starten", visible=True, interactive=True, scale= 7)
-            validate_btn = gr.Button("Validieren", visible = True)
-            #validation_result = gr.Text(label="Validierungsergebnis")
-        
-    with gr.Tab("KKG Chatbot"):
-        with gr.Row():
-            #gr.HTML("LI Chatot")
-            status_display = gr.Markdown("Antwort der KI ...", visible = True) #, elem_id="status_display")
-        with gr.Row():
-            with gr.Column(scale=5):
-                with gr.Row():
-                    chatbot = gr.Chatbot(elem_id="li-chat",show_copy_button=True)
-                with gr.Row():
-                    with gr.Column(scale=12):
-                        user_input = gr.Textbox(
-                            show_label=False, placeholder="Gib hier deinen Prompt ein...",
-                            container=False
-                        )
-                    with gr.Column(min_width=70, scale=1):
-                        submitBtn = gr.Button("Senden")
-                    with gr.Column(min_width=70, scale=1):
-                        cancelBtn = gr.Button("Stop")
-                with gr.Row():
-                        image_display = gr.Image( visible=False)
-                        upload = gr.UploadButton("📁", file_types=["image", "pdf", "docx", "pptx", "xlsx"], scale = 10)
-                        emptyBtn = gr.ClearButton([user_input, chatbot, history, attached_file, attached_file_history, image_display], value="🧹 Neue Session", scale=10)  
-                        
-            with gr.Column():
-                with gr.Column(min_width=50, scale=1):
-                    with gr.Tab(label="Chats ..."):
-                        #Geht nicht, da für alle gleichzeitig sichtbar
-                        #chat_selector = gr.CheckboxGroup(label="", choices=update_chat_options())
-                        #download_button = gr.Button("Download ausgewählte Chats")
-                        file_download = gr.File(label="Noch keine Chatsverläufe",  visible=True, interactive = False,  file_count="multiple",) 
-
-                    with gr.Tab(label="Parameter"):
-                        #gr.Markdown("# Parameters")
-                        rag_option = gr.Radio(["Aus", "An"], label="KKG Erweiterungen (RAG)", value = "Aus")
-                        model_option = gr.Radio(["OpenAI", "HuggingFace"], label="Modellauswahl", value = "OpenAI")
-                        websuche = gr.Radio(["Aus", "An"], label="Web-Suche", value = "Aus")
-
-                        
-                        top_p = gr.Slider(
-                            minimum=-0,
-                            maximum=1.0,
-                            value=0.95,
-                            step=0.05,
-                            interactive=True,
-                            label="Top-p",
-                            visible=False,
-                        )
-                        top_k = gr.Slider(
-                            minimum=1,
-                            maximum=100,
-                            value=35,
-                            step=1,
-                            interactive=True,
-                            label="Top-k",
-                            visible=False,
-                        )
-                        temperature = gr.Slider(
-                            minimum=0.1,
-                            maximum=2.0,
-                            value=0.5,
-                            step=0.1,
-                            interactive=True,
-                            label="Temperature",
-                            visible=False
-                        )
-                        max_length_tokens = gr.Slider(
-                            minimum=0,
-                            maximum=512,
-                            value=512,
-                            step=8,
-                            interactive=True,
-                            label="Max Generation Tokens",
-                            visible=False,
-                        )
-                        max_context_length_tokens = gr.Slider(
-                            minimum=0,
-                            maximum=4096,
-                            value=2048,
-                            step=128,
-                            interactive=True,
-                            label="Max History Tokens",
-                            visible=False,
-                        )
-                        repetition_penalty=gr.Slider(label="Repetition penalty", value=1.2, minimum=1.0, maximum=2.0, step=0.05, interactive=True, info="Strafe für wiederholte Tokens", visible=False)
-                        anzahl_docs = gr.Slider(label="Anzahl Dokumente", value=3, minimum=1, maximum=10, step=1, interactive=True, info="wie viele Dokumententeile aus dem Vektorstore an den prompt gehängt werden", visible=False)
-                        openai_key = gr.Textbox(label = "OpenAI API Key", value = "sk-", lines = 1, visible = False)
-
-                        
-    ################################################
-    # Tab zum Zeichnen mit Stable Diffusion
-    ################################################
-    with gr.Tab("LI Zeichnen"):
-        with gr.Row(): 
-            gr.HTML("Lass den KI-Bot deine Ideen zeichnen...")
-            status_display2 = gr.Markdown("Success", visible = False, elem_id="status_display")
-        #gr.Markdown(description2)
-        with gr.Row():
-            with gr.Column(scale=5):
-                with gr.Row():
-                    chatbot_bild = gr.Chatbot(elem_id="li-zeichnen",show_copy_button=True, show_share_button=True)
-                with gr.Row():
-                    with gr.Column(scale=12):
-                        user_input2 = gr.Textbox(
-                            show_label=False, placeholder="Gib hier deinen Prompt ein...",
-                            container=False
-                        )
-                    with gr.Column(min_width=70, scale=1):
-                        submitBtn2 = gr.Button("Senden")
-                    #with gr.Column(min_width=70, scale=1):
-                        #cancelBtn2 = gr.Button("Stop")
-                with gr.Row():
-                    emptyBtn2 = gr.ClearButton([user_input, chatbot_bild], value="🧹 Neue Session", scale=10)  
-                    #additional_inputs_accordion = gr.Accordion(label="Weitere Eingaben...",  open=False)     
-            with gr.Column():
-                with gr.Column(min_width=50, scale=1):
-                    with gr.Tab(label="Parameter Einstellung"):
-                        #gr.Markdown("# Parameters")
-                        model_option_zeichnen = gr.Radio(["Stable Diffusion","DallE"], label="Modellauswahl", value = "Stable Diffusion")
-
-    """
-    with gr.Tab("LI Codebot"):
-        with gr.Row(): 
-            gr.HTML("Gib als textuelle Beschreibung ein, was in Programmcode übersetzt werden soll und in welcher Sprache...")
-            status_display3 = gr.Markdown("Success", visible = False, elem_id="status_display")
-        #gr.Markdown(description2)
-        with gr.Row():
-            with gr.Column(scale=5):
-                with gr.Row():
-                    chatbot_code = gr.Chatbot(elem_id="li-zeichnen",show_copy_button=True, show_share_button=True)
-                with gr.Row():
-                    with gr.Column(scale=12):
-                        user_input3 = gr.Textbox(
-                            show_label=False, placeholder="Gib hier deinen Prompt ein...",
-                            container=False
-                        )
-                    with gr.Column(min_width=70, scale=1):
-                        submitBtn3 = gr.Button("Senden")
-                    with gr.Column(min_width=70, scale=1):
-                        cancelBtn3 = gr.Button("Stop")
-                with gr.Row():
-                        #file_display = gr.File(visible=False)
-                        image_display3 = gr.Image( visible=False)
-                        upload3 = gr.UploadButton("📁", file_types=["image", "pdf", "docx", "pptx", "xlsx"], scale = 10)
-                        emptyBtn3 = gr.ClearButton([user_input3, chatbot_code, history3, attached_file3,  image_display3], value="🧹 Neue Session", scale=10) 
-            with gr.Column():
-                with gr.Column(min_width=50, scale=1):
-                    with gr.Tab(label="Parameter Einstellung"):
-                        #gr.Markdown("# Parameters")
-                        model_option_code3 = gr.Radio(["Davinci","kommt noch"], label="Modellauswahl", value = "Davinci")
-    """
-
-        
-    gr.Markdown(description)        
-    
-    ######################################
-    # Events und Übergabe Werte an Funktionen 
-    #######################################
-    ######################################
-    # Für Tab 1: Chatbot
-    #Argumente für generate Funktion als Input
-    predict_args = dict(
-        fn=generate_auswahl,
-        inputs=[
-            user_question,
-            attached_file,
-            attached_file_history,
-            chatbot,
-            history,
-            rag_option,
-            model_option,
-            openai_key,
-            anzahl_docs,
-            top_p,
-            temperature,
-            max_length_tokens,
-            max_context_length_tokens,
-            repetition_penalty,
-            top_k,
-            websuche,
-            validate
-        ],
-        outputs=[chatbot, history, attached_file, attached_file_history, status_display], 
-        show_progress=True,
-    )
-    
-    reset_args = dict(
-        fn=reset_textbox, inputs=[], outputs=[user_input, status_display]
-    )
-
-    # Chatbot
-    transfer_input_args = dict(    
-        fn=add_text, inputs=[chatbot, history, user_input, attached_file, attached_file_history], outputs=[chatbot, history, user_question, attached_file, attached_file_history, image_display , user_input], show_progress=True
-    )
-
-    ##############################################
-    # Button Events....
-    #Validation Button
-    # Event-Handler für die Validierung
-    validate_btn.click(validate_input, inputs=[user_input_validate, validate], outputs=[status_display, validate, user_input_validate, validate_btn])
-    user_input_validate.submit(validate_input, inputs=[user_input_validate, validate], outputs=[status_display, validate, user_input_validate, validate_btn])
-    
-    predict_event1 = user_input.submit(**transfer_input_args, queue=False,).then(**predict_args)
-    predict_event2 = submitBtn.click(**transfer_input_args, queue=False,).then(**predict_args)
-    predict_event3 = upload.upload(file_anzeigen, [upload], [image_display, image_display, attached_file] ) #.then(**predict_args)
-    emptyBtn.click(clear_all, [history, uploaded_file_paths, chats], [attached_file, image_display, uploaded_file_paths, history, file_download, chats])
-    #Bild Anzeige neben dem Button wieder entfernen oder austauschen..
-    image_display.select(file_loeschen, [], [attached_file, image_display])
-    #download_button.click(fn=download_chats, inputs=chat_selector, outputs=[file_download])
-
-    
-    #Berechnung oder Ausgabe anhalten (kann danach fortgesetzt werden)
-    cancelBtn.click(cancel_outputing, [], [status_display], cancels=[predict_event1,predict_event2, predict_event3]) 
-
-    ######################################
-    # Für Tab 2: Zeichnen
-    predict_args2 = dict(
-        fn=generate_bild,
-        inputs=[
-            user_question2,
-            chatbot_bild,
-            model_option_zeichnen,
-            validate
-            #additional_inputs,
-        ],
-        outputs=[chatbot_bild,  status_display2], #[chatbot, history,  status_display]
-        show_progress=True,
-    )
-    transfer_input_args2 = dict(
-        fn=add_text2, inputs=[chatbot_bild, user_input2], outputs=[chatbot_bild, user_question2, user_input2], show_progress=True
-    )
-    predict_event2_1 = user_input2.submit(**transfer_input_args2, queue=False,).then(**predict_args2)
-    predict_event2_2 = submitBtn2.click(**transfer_input_args2, queue=False,).then(**predict_args2)
-    #emptyBtn2.click(clear_all, [], [file_display, image_display])
-    
-    #cancelBtn2.click(
-        #cancels=[predict_event2_1,predict_event2_2 ]
-    #)
-
-    """
-    ######################################
-    # Für Tab 3: Codebot
-    #Argumente für generate Funktion als Input
-    predict_args3 = dict(
-        fn=generate_code,
-        inputs=[
-            user_question3,
-            attached_file3,
-            attached_file_history3,
-            chatbot_code,
-            history3,
-            model_option,
-            openai_key,
-            top_p,
-            temperature,
-            max_length_tokens,
-            max_context_length_tokens,
-            repetition_penalty,
-            top_k
-        ],
-        outputs=[chatbot_code, history3, attached_file3, status_display3], 
-        show_progress=True,
-    )
-    reset_args3 = dict(
-        fn=reset_textbox, inputs=[], outputs=[user_input3, status_display3]
-    )
-    # Chatbot
-    transfer_input_args3 = dict(    
-        fn=add_text, inputs=[chatbot_code, history3, user_input3, attached_file3, attached_file_history3], outputs=[chatbot_code, history3, user_question3, attached_file3, attached_file_history3, image_display3, user_input3], show_progress=True
-    )
-    predict_event3_1 = user_input3.submit(**transfer_input_args3, queue=False,).then(**predict_args3)
-    predict_event3_2 = submitBtn3.click(**transfer_input_args3, queue=False,).then(**predict_args3)
-    predict_event3_3 = upload3.upload(file_anzeigen, [upload3], [image_display3, image_display3, attached_file3] ) #.then(**predict_args)
-    emptyBtn3.click(clear_all3, [history3], [attached_file3, image_display3, history3])   
-    #Bild Anzeige neben dem Button wieder entfernen oder austauschen..
-    image_display3.select(file_loeschen, [], [attached_file3, image_display3])
-    #download_button.click(fn=download_chats, inputs=chat_selector, outputs=[file_download])
-    """
-    
-    
-demo.title = "KKG-ChatBot"
-demo.queue(default_concurrency_limit=15).launch(debug=True)