test

chunks_ia_signature.pkl

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

main.py

@@ -21,29 +21,6 @@ from email.mime.text import MIMEText
 
 load_dotenv()
 
-## setup pinecone index
-pinecone_api_key = os.environ.get("PINECONE_API_KEY")
-
-pc = Pinecone(api_key=pinecone_api_key)
-
-index_name = os.environ.get("INDEX_NAME") # change if desired
-
-existing_indexes = [index_info["name"] for index_info in pc.list_indexes()]
-
-if index_name not in existing_indexes:
-    pc.create_index(
-        name=index_name,
-        dimension=1536,
-        metric="cosine",
-        spec=ServerlessSpec(cloud="aws", region="us-east-1"),
-    )
-    while not pc.describe_index(index_name).status["ready"]:
-        time.sleep(1)
-
-index = pc.Index(index_name)
-
-vector_store = PineconeVectorStore(index=index, embedding=embedding)
-
 ## setup authorization
 api_keys = [os.environ.get("FASTAPI_API_KEY")]
 
@@ -67,104 +44,41 @@ else:
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
 
 # Pydantic model for the form data
-class ContactForm(BaseModel):
-    name: str
-    email: EmailStr
-    message: str
-
-def send_simple_message(to,subject,text):
-    api_key = os.getenv("MAILGUN_API_KEY")
-
-    return requests.post(
-        "https://api.mailgun.net/v3/sandboxafc6970ffdab40ee9566a4e180b117fd.mailgun.org/messages",
-        auth=("api", api_key),
-        data={"from": "Excited User <mailgun@sandboxafc6970ffdab40ee9566a4e180b117fd.mailgun.org>",
-            "to": [to],
-            "subject": subject,
-            "text": text})
-
-# Function to send email
-def send_email(form_data: ContactForm):
-    # sender_email = os.getenv("SENDER_EMAIL")
-    # sender_password = os.getenv("SENDER_PASSWORD")
-
-    receiver_email = os.getenv("RECEIVER_EMAIL")  # Your email
-
-    # Setup the message content
-    text = f"Name: {form_data.name}\nEmail: {form_data.email}\nMessage: {form_data.message}"
-    title = "New message from your website!"
-
-    # Send the email
-    try:
-        send_simple_message(receiver_email,title,text)
-    except Exception as e:
-        print(e)
-        return {"message": "Failed to send email."}
-
-# Endpoint to handle form submission
-@app.post("/send_email")
-async def send_contact_form(form_data: ContactForm, background_tasks: BackgroundTasks):
-    background_tasks.add_task(send_email, form_data)
-    return {"message": "Email sent successfully!"}
+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 ChunkToDB(BaseModel):
-    message: str
-    title: str
+#endpoinds
 
-
-@app.post("/add_chunk_to_db")
-async def add_chunk_to_db(chunk: ChunkToDB):
+@app.post("/generate_sphinx")
+async def generate_sphinx():
     try:
-        title = chunk.title
-        message = chunk.message
-        return get_vectorstore(text_chunk=message,index=index,title=title)
+        sphinx : sphinx_output = generate_sphinx_response()
+        return {"question": sphinx.question, "answers": sphinx.answers}
     except Exception as e:
-        return {"message": str(e)}
+        raise HTTPException(status_code=500, detail=str(e))
     
-
-@app.get("/list_vectors")
-async def list_vectors():
+@app.post("/verify_sphinx")
+async def verify_sphinx(response: verify_response_model):
     try:
-        return index.list()
+        score : bool = verify_response(response.response, response.answers, response.question)
+        return {"score": score}
     except Exception as e:
-        return {"message": str(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,index_name=index,stream=True,vector_store=vector_store),media_type="application/json")
+            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,index_name=index,stream=False,vector_store=vector_store)
-    except Exception as e:
-        return {"message": str(e)}
-    
-@app.post("/retreive_context")
-async def retreive_context_response(query: str):
-    try:
-        return retreive_context(index=index,query=query)
+            return generate_stream(user_input.query,user_input.messages,stream=False)
     except Exception as e:
-        return {"message": str(e)}
-    
-
-@app.delete("/delete_vector")
-async def delete_vector(filename_id: str):
-    try:
-        return index.delete(ids=[filename_id])
-    except Exception as e:
-        return {"message": str(e)}
-    
-@app.get("/check_server")
-async def check_server():
-    return {"message":"Server is running"}
-
-@app.get("/")
-async def read_root():
-    return {"message":"Welcome to the AI API"}
+        return {"message": str(e)}

prompt.py

@@ -1,5 +1,5 @@
 template_sphinx = '''
-Voici un résumé et un bout du récit de {writer}, l'auteur de {book_name}. Vous êtes le Grand Sphinx, maître des énigmes et des questions.
+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 qui lui ouvrira la porte vers la réalité de ce récit. 
 Votre question doit être en français, et vous devez l'associer aux réponses possibles.
 
@@ -14,13 +14,32 @@ La sortie doit être une question en français, qui teste la compréhension du r
 
 '''
 
+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 = '''
-You are an AI assistant for Ilyas Khiat, a future engineer with a major in AI, and software engineering. Your job is to respond to visistors in the most human way . Always provide links if necessary (e.g., LinkedIn: https://www.linkedin.com/in/ilyas-khiat-148a73254/ ) Ensure your tone is pleaseant, and respond precisely to the user's query. if the context is not pertinent or you don't have enough information, **DON'T HALLUCINATE**.
-The context retreived from the user is:
-{context}
-{history}
-The user's query is:
-{query}
-
-Please respond to the user's query in a consis way and well formatted markdown with paragraphs and emojis. If the question is about my values , highlights Ilyas' technical expertise **without exageration**, projects and their **links**, and how he adds value to potential employers, plus soft skills. Add life to your answer and emphasize keywords with bold, MAKE IT **SHORT** in no more than **150 WORDS** or 200 tokens. Ensure your tone is pleasant, engaging, and matches the language of the user's query and your response is not bluffing and exaggerating but honest and convincing.
+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. Vous répondrez rigoureusement dans le style d'écriture de la nouvelle.
+
+**Graphe de connaissances du livre :** {kg}
+
+**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.
+'''
+
+summary_text = '''
+Ce récit d'anticipation, se déroulant principalement en 2038, explore les tensions entre l'art, la technologie et les limites planétaires à travers une exposition visionnaire des œuvres de René Magritte. Anne-Hélène, nouvelle directrice des Musées Royaux des Beaux-Arts de Belgique, organise cette exposition avec plusieurs personnages clés comme Tristan, un guide discret mais observateur, Karla Madrigale, PDG de la start-up IA SIGNATURE, et Jad Wahid, un artiste engagé. L'exposition vise à confronter les œuvres de Magritte aux limites planétaires pour inspirer de nouvelles façons de penser la place du vivant et de l'art dans un futur dominé par l'IA. Cependant, un incident dramatique se produit lorsque Karla, en interaction avec une installation immersive, tombe dans le coma à la suite d'une réaction toxique des plantes. Les événements soulèvent des questions sur l'éthique, la responsabilité et les limites de l'IA et des technologies immersives. Le récit invite à réfléchir sur le potentiel et les risques de l'IA dans l'art et la société.
 '''

rag.py

@@ -8,12 +8,19 @@ 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
+
+
+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
 
@@ -25,38 +32,115 @@ 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}
+
+with open("kg_ia_signature.pkl", "rb") as file:
+    loaded_graph = pickle.load(file)
+    graph = advanced_graph_to_json(loaded_graph)
+    print("Graph loaded")
+
+with open("chunks_ia_signature.pkl", "rb") as file:
+    chunks = pickle.load(file)
+    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")
 
-llm = ChatOpenAI(model="gpt-4o-mini", max_tokens=300, temperature=0.5)
+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=300, temperature=0.5)
 
 
-def get_random_chunk(chunks: list[str]) -> str:
-    return chunks[tool.random_int(0, len(chunks) - 1)]
+def get_random_chunk() -> str:
+    return chunks[random.randint(0, len(chunks) - 1)]
 
-def get_vectorstore(chunks: list[str]) -> FAISS:
-    vector_store = FAISS(index=index_name, embedding=embedding)
-    for chunk in chunks:
-        document = Document(text=chunk, id=str(uuid4()))
-        vector_store.index(document)
+
+def get_vectorstore() -> FAISS:
+    index = faiss.IndexFlatL2(len(embedding.embed_query("hello world")))
+    vector_store = FAISS(
+        embedding_function=embedding,
+        index=index,
+        docstore=InMemoryDocstore(),
+        index_to_docstore_id={},
+    )
+    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()
+
+
+def generate_sphinx_response() -> sphinx_output:
+    writer = "Laurent Tripied"
+    book_name =  "Limites de l'imaginaire ou limites planétaires"
+    summary = summary_text
+    excerpt = get_random_chunk()
+    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":book_name,"summary":summary,"excerpt":excerpt})
+
+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 >= 0:
+        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 generate_stream(query:str,messages = [], model = "gpt-4o-mini", max_tokens = 300, temperature = 0.5,index_name="",stream=True,vector_store=None):
     try:
         print("init chat")
         print("init template")
         prompt = PromptTemplate.from_template(template)
+
+        writer = "Laurent Tripied"
+        name_book = "Limites de l'imaginaire ou limites planétaires"
+        name_icon = "Magritte"
+        kg = loaded_graph
         print("retreiving context")
-        context = retreive_context(query=query,index=index_name,vector_store=vector_store)
+        context = retrieve_context_from_vectorestore(query)
         print(f"Context: {context}")
         llm_chain = prompt | llm | StrOutputParser()
 
         print("streaming")
         if stream:
-            return llm_chain.stream({"context":context,"history":messages,"query":query})
+            return llm_chain.stream({"name_book":name_book,"writer":writer,"name_icon":name_icon,"kg":graph,"context":context,"query":query})
         else:
-            return llm.invoke(query)
+            return llm_chain.invoke({"name_book":name_book,"writer":writer,"name_icon":name_icon,"kg":graph,"context":context,"query":query})
 
     except Exception as e:
         print(e)