first

.dockerignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.git
+.dockerignore
+Dockerfile
+*.md

.gitattributes copy

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+.env
+data/

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.12
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README copy.md

@@ -0,0 +1,10 @@
+---
+title: Ia Back
+emoji: 🐨
+colorFrom: indigo
+colorTo: purple
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

chunks_ia_signature.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:240d159d8dedc430a3b6049a60f0805fa423cf9abece82b36c4fb650c8c5d437
+size 145837

config.yaml

@@ -0,0 +1,13 @@
+nom_ouvrage: "confessions muettes"
+auteur: "Gaspard Boreal"
+resume: "Un recit futuristique qui se deroule en 2038, melangeant art et technologie, ou l'IA est omnipresente."
+severite: 5
+scenes_par_numero_de_page:
+  - 1
+  - 5
+  - 10
+derniere_page: 15
+scenes_choisies:
+  - 2
+
+

kg_ia_signature.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:55b49436038a45405798f6d05591464b1a35360409d83dbead163921707ac592
+size 7354091

main.py

@@ -0,0 +1,153 @@
+from fastapi import FastAPI, HTTPException, UploadFile, File,Request,Depends,status,BackgroundTasks
+from fastapi.security import OAuth2PasswordBearer
+from pydantic import BaseModel
+from typing import Optional, List
+from uuid import uuid4
+import os
+from dotenv import load_dotenv
+from rag import *
+from fastapi.responses import StreamingResponse
+import json
+from prompt import *
+from fastapi.middleware.cors import CORSMiddleware
+import requests
+import pandas as pd
+
+
+
+load_dotenv()
+
+## setup authorization
+api_keys = [os.environ.get("FASTAPI_API_KEY")]
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")  # use token authentication
+
+
+def api_key_auth(api_key: str = Depends(oauth2_scheme)):
+    if api_key not in api_keys:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Forbidden"
+        )
+
+dev_mode = os.environ.get("DEV")
+
+if dev_mode == "True":
+    app = FastAPI()
+else:
+    app = FastAPI(dependencies=[Depends(api_key_auth)])
+
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
+
+# Pydantic model for the form data
+class verify_response_model(BaseModel):
+    response: str = Field(description="The response from the user to the question")
+    answers: list[str] = Field(description="The possible answers to the question to test if the user read the entire book")
+    question: str = Field(description="The question asked to the user to test if they read the entire book")
+
+class UserInput(BaseModel):
+    query: str
+    stream: Optional[bool] = False
+    messages: Optional[list[dict]] = []
+
+class Artwork(BaseModel):
+    name: str
+    artist: str
+    image_url: str
+    date: str
+    description: str
+
+class WhatifInput(BaseModel):
+    question: str
+    answer: str
+
+
+# Global variable to store the data
+artworks_data = []
+
+def load_data():
+    global artworks_data
+
+    # Provide the path to your local spreadsheet
+    spreadsheet_path = "./data/data.xlsx"
+
+    # Read the spreadsheet into a DataFrame
+    df = pd.read_excel(spreadsheet_path, sheet_name='Sheet1')  # Adjust sheet_name as needed
+
+    df = df.fillna(False)
+    # Convert DataFrame to a list of dictionaries
+    df_filtered = df[df['Publication'] == True]
+
+    artworks_data = df_filtered.to_dict(orient='records')
+
+    print("Data loaded successfully")
+
+load_data()
+
+#endpoinds
+@app.get("/artworks/{artist_name}")
+async def get_artworks_by_artist(artist_name: str):
+    artist_name_lower = artist_name.lower()
+    results = []
+
+    for artwork in artworks_data:
+        if artist_name_lower in artwork['Artiste'].lower():
+            result = {
+                'name':artwork['Titre français'],
+                'artist':artwork['Artiste'],
+                'image_url':artwork['Image_URL'],
+                'date':str(artwork['Date']),  # Ensure date is a string
+                'description':artwork['Media']
+            }
+            results.append(result)
+
+    if not results:
+        raise HTTPException(status_code=404, detail="Artist not found")
+
+    return results
+
+@app.post("/generate_sphinx")
+async def generate_sphinx():
+    try:
+        sphinx : sphinx_output = generate_sphinx_response()
+        return {"question": sphinx.question, "answers": sphinx.answers}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+@app.post("/verify_sphinx")
+async def verify_sphinx(response: verify_response_model):
+    try:
+        score : bool = verify_response(response.response, response.answers, response.question)
+        return {"score": score}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+@app.post("/generate")
+async def generate(user_input: UserInput):
+    try:
+        print(user_input.stream,user_input.query)
+        if user_input.stream:
+            return StreamingResponse(generate_stream(user_input.query,user_input.messages,stream=True),media_type="application/json")
+        else:
+            return generate_stream(user_input.query,user_input.messages,stream=False)
+    except Exception as e:
+        return {"message": str(e)}
+    
+
+@app.post("/whatif")
+async def whatif(whatif_input: WhatifInput):
+    try:
+        print(whatif_input.question)
+        return generate_whatif_stream(question=whatif_input.question,response=whatif_input.answer)
+    except Exception as e:
+        return {"message": str(e)}
+    
+@app.post("/whatif_chat")
+async def generate_whatif_chat(user_input: UserInput):
+    try:
+        if user_input.stream:
+            return StreamingResponse(generate_stream_whatif_chat(user_input.query,user_input.messages,stream=True),media_type="application/json")
+        else:
+            return generate_stream_whatif_chat(user_input.query,user_input.messages,stream=False)
+    except Exception as e:
+        return {"message": str(e)}

prompt.py

@@ -0,0 +1,88 @@
+template_sphinx = '''
+Voici un résumé et un bout du récit de {book_name}. Vous êtes le Grand Sphinx, maître des énigmes et des questions.
+Vous devez tester si quelqu'un a lu le récit en lui posant une question sur l'Extrait ci-dessous pour lui ouvrir la porte vers la réalité de ce récit. 
+Votre question doit être en français, et vous devez l'associer à la ou les **bonnes** réponses possibles. Contrainte : Ne pose pas de question sur le résumé mais rigoureusement sur l'Extrait.
+
+**résumé**:
+{summary}
+
+**Extrait**:
+{excerpt}
+
+**Instructions**:
+- S'il y'a une seul  bonne reponse possible , renvoit une seul reponse possible.
+- Les autres bonne reponse possibles doivent etre correcte pour la question.
+
+**Sortie**:
+La sortie doit être une question en français, qui teste la compréhension du récit. Vous devez fournir la ou les **bonnes** réponses possibles et **correctes** à cette question.
+
+**
+'''
+
+template_verify = '''
+Vous êtes un expert en correction et comparaison de réponses. Retournez une note sur 10 sur la cohérence de la réponse de l'utilisateur avec la réponse correcte. Voici les détails :
+
+Question : {initial_question}
+
+Réponses correctes : {answers}
+
+Réponse de l'utilisateur : {response}
+
+Évaluez la réponse de l'utilisateur et attribuez une note sur 10 en fonction de sa cohérence avec la réponse correcte.
+
+'''
+
+template = '''
+Vous êtes un assistant IA très intelligent qui connaît tout sur le livre {name_book} de {writer}. 
+Vous allez répondre à la question de l'utilisateur, qui portera sur ce livre. Vos réponses seront claires et courtes.
+
+Résumé du livre : {summary}
+
+**Contexte récupéré (si pertinent pour votre réponse) :** {context}
+
+**Question de l'utilisateur :** {query}
+
+**Sortie attendue :** Votre réponse doit être bien formatée, plaisante à lire et inclure des émojis.
+'''
+
+template_whatif = '''
+Prends le temps de bien lire la question posée par IA SIGNATURE au lecteur et la réponse faite par le lecteur :
+* Question posée par IA SIGNATURE -> {question}
+* Bonne réponse du lecteur -> {response}
+
+Contexte :
+{context}
+
+**Instructions** :
+    Relis le passage correspondant dans le récit et propose cinq autres choix qu'auraient pu faire l'auteur et ayant un impact sur la suite du récit. Numérote les résultats de 1 à 5 en prenant en compte :
+        Choix 1 : Choix ayant un impact déterminant avec une suite totalement différente pour le récit
+        Choix 2 : Choix entraînant une suite du récit beaucoup plus sombre
+        Choix 3 : Choix entraînant une suite du récit beaucoup plus ouverte, gai et inspirante
+        Choix 4 : A toi de jouer
+        Choix 5 : Conserve la réponse actuelle
+
+**CONTRAINTE** :
+Présente la réponse de la façon suivante : 
+
+-> "Voici 5 suites différentes possibles à ce moment du récit :"
+-> Affiche les 5 réponses sous forme de 5 bullets points en sautant une ligne entre chaque choix pour aérer le texte
+-> Demande en fin de réponse :"QUELLE SUITE VEUX TU DONNER AU RÉCIT ? (1 ou 2 ou 3 ou 4 ou 5) ?"
+
+'''
+
+template_whatif_response = '''
+Vous êtes un assistant IA très intelligent qui connaît tout sur le livre {name_book} de {writer}. 
+Vous allez répondre à la question de l'utilisateur, qui portera sur ce livre. Vos réponses seront claires et courtes.
+
+Résumé du livre : {summary}
+
+**Historique des messages :** {messages}
+
+**l'utilisateur :** {query}
+
+**Extrait récupéré (si pertinent pour votre réponse) :** {context}
+
+**Sortie attendue :** Votre réponse doit être bien formatée, plaisante à lire et inclure des émojis.
+'''
+
+

rag.py

@@ -0,0 +1,306 @@
+from langchain_openai import OpenAIEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain_core.documents import Document
+from langchain.document_loaders import PyPDFLoader
+
+from langchain_openai import ChatOpenAI
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import PromptTemplate
+from uuid import uuid4
+from prompt import *
+import random
+from itext2kg.models import KnowledgeGraph
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+
+from langchain_experimental.text_splitter import SemanticChunker
+
+import faiss
+from langchain_community.docstore.in_memory import InMemoryDocstore
+
+from pydantic import BaseModel, Field
+from dotenv import load_dotenv
+import os
+
+from langchain_core.tools import tool
+import pickle
+
+import unicodedata
+import yaml
+
+load_dotenv()
+index_name = os.environ.get("INDEX_NAME")
+# Global initialization
+embedding_model = "text-embedding-3-small"
+
+embedding = OpenAIEmbeddings(model=embedding_model)
+# vector_store = PineconeVectorStore(index=index_name, embedding=embedding)
+
+def advanced_graph_to_json(graph:KnowledgeGraph):
+    nodes = []
+    edges = []
+    for node in graph.entities:
+        node_id = node.name.replace(" ", "_")
+        label = node.name
+        type = node.label
+        nodes.append({"id": node_id, "label": label, "type": type})
+    for relationship in graph.relationships:
+        source = relationship.startEntity
+        source_id = source.name.replace(" ", "_")
+        target = relationship.endEntity
+        target_id = target.name.replace(" ", "_")
+        label = relationship.name
+        edges.append({"source": source_id, "label": label, "cible": target_id})
+    return {"noeuds": nodes, "relations": edges}
+
+def load_document(name):
+    try:
+        loader = PyPDFLoader(f"./data/{name}.pdf")
+        pages = loader.load()
+        return pages
+    except Exception as e:
+        print(e)
+        print("Make sure the name indicated in the config.yaml file is the same as the pdf file in the data folder")
+        return False
+
+def chunk_by_scene(scenes_indexes,pages,last_page=None):
+    try:
+        scenes = []
+        
+        for i in range(len(scenes_indexes)-1):
+            print("scene sclice",scenes_indexes[i]-1,scenes_indexes[i+1]-1)
+            current_scene = "Scene "+ str(i+1)
+            print("current_scene",current_scene)
+            scene_content = "".join([page.page_content.replace("\n","").replace("  "," ").replace("\t"," ") for page in pages[scenes_indexes[i]-1:scenes_indexes[i+1]-1]])
+            scenes.append(scene_content)
+        
+        if last_page == None:
+            last_page = len(pages)
+        print("scene sclice",scenes_indexes[-1]-1,last_page)
+        current_scene = "Scene "+str(len(scenes_indexes))
+        print("current_scene",current_scene)
+        scene_content = "".join([page.page_content.replace("\n","").replace("  "," ").replace("\t"," ") for page in pages[scenes_indexes[-1]-1:]])
+        scenes.append(scene_content)
+
+        return scenes
+    except Exception as e:
+        print(e)
+        return False
+
+def chunk_semantic(pages):
+    text_filtered = "\n".join([page.page_content.replace("\n","").replace("  "," ").replace("\t"," ") for page in pages])
+    text_splitter = SemanticChunker(OpenAIEmbeddings(),breakpoint_threshold_type="standard_deviation",breakpoint_threshold_amount=2.718)
+    chunks_filtered = text_splitter.create_documents([text_filtered])
+    semantic_chunks = [chunk.page_content for chunk in chunks_filtered]
+    return semantic_chunks
+
+def handle_config(config_path='config.yaml'):
+    try:
+        with open(config_path, "r", encoding="utf-8") as f:
+            config = yaml.safe_load(f)
+        
+        name = config.get('nom_ouvrage', '')
+        scenes_indexes = config.get('scenes_par_numero_de_page', [])
+        writer = config.get('auteur', 'anonyme')
+        summary = config.get('resume', '')
+        severite = config.get('severite', 0) # 0: faible, 1: max
+        scene_specific = config.get('scenes_choisies', None) # None: tout le récit, [1,3,5]: scènes 1, 3 et 5
+        last_page = config.get('derniere_page', None )
+
+        ## log config
+        print("########### Config loaded ###########")
+        print(f"Loading document {name}")
+        print(f"Writer: {writer}")
+        print(f"Scenes: {scenes_indexes}")
+        print(f"Summary: {summary}")
+        print(f"Severite: {severite}")
+        print(f"Scene specific: {scene_specific}")
+        print(f"Last page: {last_page}")
+        print("#####################################")
+
+        config = {
+            "name_book": name,
+            "scenes_indexes": scenes_indexes,
+            "writer": writer,
+            "summary": summary,
+            "severite": severite,
+            "scene_specific": scene_specific,
+            "last_page": last_page
+        }
+        return config
+    except Exception as e:
+        print(f"Error: {e}")
+        return False
+
+config = handle_config()
+
+name_book = config.get('name_book')
+scenes_indexes = config.get('scenes_indexes')
+writer = config.get('writer')
+summary_text = config.get('summary')
+severite = config.get('severite')
+scene_specific = config.get('scene_specific')
+last_page = config.get('last_page')
+
+print("########### Loading document ###########")
+pages = load_document(name_book)
+print("########### Pages loaded ###########")
+
+print("########### Loading scenes ###########")
+scenes = chunk_by_scene(scenes_indexes,pages)
+print("########### Scenes loaded ###########")
+
+print("########### Loading chunks ###########")
+chunks = chunk_semantic(pages)
+print("########### Chunks loaded ###########")
+
+
+class sphinx_output(BaseModel):
+    question: str = Field(description="The question to ask the user to test if they read the entire book")
+    answers: list[str] = Field(description="The possible answers to the question to test if the user read the entire book")
+
+class verify_response_model(BaseModel):
+    response: str = Field(description="The response from the user to the question")
+    answers: list[str] = Field(description="The possible answers to the question to test if the user read the entire book")
+    initial_question: str = Field(description="The question asked to the user to test if they read the entire book")
+
+class verification_score(BaseModel):
+    score: float = Field(description="The score of the user's response from 0 to 10 to the question")
+
+
+llm = ChatOpenAI(model="gpt-4o", max_tokens=1000, temperature=0.5)
+
+def split_texts(text : str) -> list[str]:
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=1000,
+        chunk_overlap=200,
+        length_function=len,
+        is_separator_regex=False,
+    )
+    return splitter.split_text(text)
+
+
+#########################################################################
+### PAR ICI , CHOISIR UNE SCENE SPECIFIQUE DANS L'ARGUMENT DE LA FONCTION
+def get_random_chunk(scene_specific = scene_specific) : # scene_specific = None signifie qu'on considère tout le récit / [1,3,5] pour avoir la 1 et la 3 et la 5 / [5] pour avoir que la 5
+    if scene_specific:
+        scene_specific_content = [scenes[i-1] for i in scene_specific]
+        scene_specific_content = " ".join(scene_specific_content)
+        chunks_scene = split_texts(scene_specific_content)
+        print(f"Scene {scene_specific} has {len(chunks_scene)} chunks")
+        print([chunk[0:50] for chunk in chunks_scene])
+        print('---')
+        chunk_chosen = chunks_scene[random.randint(0, len(chunks_scene) - 1)]
+        print(f"Chosen chunk: {chunk_chosen}")
+        return chunk_chosen, scene_specific
+    
+    return chunks[random.randint(0, len(chunks) - 1)],scene_specific
+
+
+def get_vectorstore(chunks) -> FAISS:
+    index = faiss.IndexFlatL2(len(embedding.embed_query("hello world")))
+    vector_store = FAISS(
+        embedding_function=embedding,
+        index=index,
+        docstore=InMemoryDocstore(),
+        index_to_docstore_id={},
+    )
+    print("Adding documents to vector store")
+    print("Chunks",len(chunks))
+    documents = [Document(page_content=chunk) for chunk in chunks]
+    uuids = [str(uuid4()) for _ in range(len(documents))]
+    vector_store.add_documents(documents=documents, ids=uuids)
+    return vector_store
+
+vectore_store = get_vectorstore(chunks)
+scenes_vectore_store = get_vectorstore(scenes)
+
+
+def generate_sphinx_response() -> sphinx_output:
+    summary = summary_text
+    excerpt , scene_number = get_random_chunk()
+    if scene_number:
+        summary = "scene " + str(scene_number)
+    prompt = PromptTemplate.from_template(template_sphinx)
+    structured_llm = llm.with_structured_output(sphinx_output)
+    # Create an LLM chain with the prompt and the LLM
+    llm_chain = prompt | structured_llm
+
+    return llm_chain.invoke({"writer":writer,"book_name":name_book,"summary":summary,"excerpt":excerpt})
+
+#############################################################
+### PAR ICI , CHOISIR LE DEGRE DE SEVERITE DE LA VERIFICATION
+def verify_response(response:str,answers:list[str],question:str) -> bool:
+    prompt = PromptTemplate.from_template(template_verify)
+    structured_llm = llm.with_structured_output(verification_score)
+    llm_chain = prompt | structured_llm
+    score = llm_chain.invoke({"response":response,"answers":answers,"initial_question":question})
+    if score.score >= severite:
+        return True
+    
+
+def retrieve_context_from_vectorestore(query:str) -> str:
+    retriever = vectore_store.as_retriever(search_type="mmr", search_kwargs={"k": 3})
+    return retriever.invoke(query)
+
+def retrieve_context_from_scenes(query:str) -> str:
+    retriever = scenes_vectore_store.as_retriever(search_kwargs={"k": 1})
+    return retriever.invoke(query)
+
+        
+def generate_stream(query:str,messages = [], model = "gpt-4o-mini", max_tokens = 300, temperature = 1,index_name="",stream=True,vector_store=None):
+    try:
+        print("init chat")
+        print("init template")
+        prompt = PromptTemplate.from_template(template)
+        summary = summary_text
+
+        print("retreiving context")
+        context = retrieve_context_from_vectorestore(query)
+        print(f"Context: {context}")
+        llm_chain = prompt | llm | StrOutputParser()
+
+        print("streaming")
+        if stream:
+            return llm_chain.stream({"name_book":name_book,"writer":writer,"context":context,"query":query,"summary":summary})
+        else:
+            return llm_chain.invoke({"name_book":name_book,"writer":writer,"context":context,"query":query,"summary":summary})
+
+    except Exception as e:
+        print(e)
+        return False
+    
+def generate_whatif_stream(question:str,response:str, stream:bool = False) -> str:
+    try:
+        prompt = PromptTemplate.from_template(template_whatif)
+        llm_chain = prompt | llm | StrOutputParser()
+        print("Enter whatif")
+        context = retrieve_context_from_scenes(f"question: {question} . reponse : {response}")
+        print(f"Context: {context}")
+
+        if stream:
+            return llm_chain.stream({"question":question,"response":response,"context":context})
+        else:
+            return llm_chain.invoke({"question":question,"response":response,"context":context})
+    except Exception as e:
+        print(e)
+        return False
+    
+def generate_stream_whatif_chat(query:str,messages = [], model = "gpt-4o-mini", max_tokens = 500, temperature = 1,index_name="",stream=True,vector_store=None):
+    try:
+        print("init chat")
+        print("init template")
+        prompt = PromptTemplate.from_template(template_whatif_response)
+        print("retreiving context")
+        context = retrieve_context_from_vectorestore(query)
+        print(f"Context: {context}")
+        llm_chain = prompt | llm | StrOutputParser()
+
+        print("streaming")
+        if stream:
+            return llm_chain.stream({"name_book":name_book,"writer":writer,"messages":messages,"context":context,"query":query,"summary":summary_text})
+        else:
+            return llm_chain.invoke({"name_book":name_book,"writer":writer,"messages":messages,"context":context,"query":query,"summary":summary_text})
+        
+    except Exception as e:
+        print(e)
+        return False

requirements.txt

@@ -0,0 +1,20 @@
+fastapi
+uvicorn
+python-multipart 
+async-timeout
+pymupdf
+python-dotenv
+typing-extensions
+pydantic==2.9.2
+openai==1.45.0
+langchain==0.3.0
+langchain-core==0.3.0
+langchain-openai==0.2.0
+faiss-cpu
+neo4j==5.24.0
+itext2kg==0.0.7
+langchain-community
+six
+httpx==0.27.2
+
+pandas

scenes.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:17fc4636b752c5b8f1434d0c97c95ea3b12605b083689e6d79daacd060f6c110
+size 142917