Upload 17 files

src/agent.py

@@ -0,0 +1,339 @@
+# src/agent.py
+from llama_cpp import Llama
+from src.memory import MemoryManager
+import os
+import logging
+from src.utils import extract_and_summarize  # Import extract_and_summarize
+from src.prompts import Prompts  # Import system prompts
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+class Agent:
+    def __init__(self, llm: Llama, db_path: str, system_prompt: str = "", max_tokens: int = 512, temperature: float = 0.7, top_p: float = 0.95):
+        self.llm = llm
+        self.memory = MemoryManager(db_path)
+        self.prompts = {
+            "general": Prompts.GENERAL_SYSTEM_PROMPT,
+            "whole_document": Prompts.WHOLE_DOCUMENT_SYSTEM_PROMPT,
+            "query_response": Prompts.QUERY_RESPONSE_SYSTEM_PROMPT,
+            "enhancement": Prompts.ENHANCEMENT_SYSTEM_PROMPT
+        }
+        self.max_tokens = max_tokens  # Default value
+        self.temperature = temperature  # Default value
+        self.top_p = top_p  # Default value
+
+    def process_query(self, user_id: str, query: str) -> str:
+        # Normalize the query to lowercase
+        query = query.lower()
+
+        # Check if the query is specific (e.g., "chronique #441")
+        if "chronique #" in query:
+            section_number = query.split("chronique #")[1].split()[0]
+            section_description = self.get_section_description(f"chronique #{section_number}")
+            if section_description:
+                response = self.generate_specific_response(query, section_description)
+                self.memory.add_user_interaction(user_id, query, response)
+                return response
+
+        if "flash info fl-" in query:
+            section_number = query.split("flash info fl-")[1].split()[0]
+            section_description = self.get_section_description(f"flash info fl-{section_number}")
+            if section_description:
+                response = self.generate_specific_response(query, section_description)
+                self.memory.add_user_interaction(user_id, query, response)
+                return response
+
+        if "chronique-faq #" in query:
+            section_number = query.split("chronique-faq #")[1].split()[0]
+            section_description = self.get_section_description(f"chronique-faq #{section_number}")
+            if section_description:
+                response = self.generate_specific_response(query, section_description)
+                self.memory.add_user_interaction(user_id, query, response)
+                return response
+
+        # For general queries, use the existing multi-layer processing
+        initial_response = extract_and_summarize(query, self.memory, self.llm, self.dynamic_query_response_prompt(query), max_tokens=self.max_tokens, temperature=self.temperature, top_p=self.top_p)
+
+        # Evaluate the initial response
+        if not self.evaluate_response(initial_response, query):
+            # Retrieve additional data
+            additional_data = self.retrieve_additional_data(query, initial_response)
+            # Combine initial and additional data
+            combined_context = f"{initial_response}\n{additional_data}"
+            # Truncate the combined context to fit within the model's context window
+            max_context_length = 30000  # Adjust this based on your LLM's token limit
+            if len(combined_context) > max_context_length:
+                combined_context = combined_context[:max_context_length]
+                logging.info(f"Truncated combined context to {max_context_length} characters.")
+
+            # Generate final response
+            initial_response = self.llm.create_chat_completion(
+                messages=[{"role": "user", "content": f"Context: {combined_context}\nQuestion: {query}"}],
+                max_tokens=self.max_tokens,
+                temperature=self.temperature,
+                top_p=self.top_p
+            )['choices'][0]['message']['content']
+
+        refined_response = self.multi_layer_processing(query, initial_response)
+        self.memory.add_user_interaction(user_id, query, refined_response)
+        return refined_response
+
+    def generate_specific_response(self, query: str, section_description: str) -> str:
+        # Log the section description
+        logging.info(f"Found section: {query}")
+        logging.info(f"Section description for {query}: {section_description}")
+
+        # Format the context with a placeholder pre-set
+        context = f"Section description for {query}: {section_description}"
+
+        # Generate a response using the specific section description
+        response = self.llm.create_chat_completion(
+            messages=[{"role": "user", "content": f"Context: {context}\nQuestion: {query}"}],
+            max_tokens=self.max_tokens,
+            temperature=self.temperature,
+            top_p=self.top_p
+        )['choices'][0]['message']['content']
+
+        # Log the generated response
+        logging.info(f"Generated specific response: {response}")
+
+        return response
+
+    def multi_layer_processing(self, query: str, initial_response: str) -> str:
+        # First layer: High-level summary of the entire document
+        high_level_summary = self.generate_high_level_summary(query)
+
+        # Second layer: Refine the response using the high-level summary
+        refined_response = self.refine_response(query, initial_response, high_level_summary)
+
+        return refined_response
+
+    def generate_high_level_summary(self, query: str) -> str:
+        # Retrieve all memories from the database
+        all_memories = self.memory._get_all_memories()
+
+        # Count the number of each type of section
+        chronique_count = self.count_chroniques()
+        flash_info_count = self.count_flash_infos()
+        chronique_faq_count = self.count_chronique_faqs()
+
+        # Combine all descriptions into a single context
+        full_context = " ".join([memory['description'] for memory, _, _ in all_memories])
+
+        # Truncate the context if it exceeds the token limit
+        max_context_length = 30000  # Adjust this based on your LLM's token limit
+        if len(full_context) > max_context_length:
+            full_context = full_context[:max_context_length]
+            logging.info(f"Truncated full context to {max_context_length} characters.")
+
+        # Generate a high-level summary using the LLM
+        high_level_summary = self.llm.create_chat_completion(
+            messages=[{"role": "user", "content": f"Context: {full_context}\nQuestion: {query}"}],
+            max_tokens=self.max_tokens,
+            temperature=self.temperature,
+            top_p=self.top_p
+        )['choices'][0]['message']['content']
+
+        # Explicitly include the number of sections in the summary
+        high_level_summary += f"\nD'après les données disponibles, Michel Thomas a publié {chronique_count} chroniques, {flash_info_count} flash infos, et {chronique_faq_count} chronique-faqs."
+
+        logging.info(f"Generated high-level summary: {high_level_summary}")
+
+        return high_level_summary
+
+    def refine_response(self, query: str, initial_response: str, high_level_summary: str) -> str:
+        # Combine the initial response and the high-level summary
+        combined_context = f"Initial Response: {initial_response}\nHigh-Level Summary: {high_level_summary}"
+
+        # Truncate the combined context to fit within the model's context window
+        max_context_length = 30000  # Adjust this based on your LLM's token limit
+        if len(combined_context) > max_context_length:
+            combined_context = combined_context[:max_context_length]
+            logging.info(f"Truncated combined context to {max_context_length} characters.")
+
+        # Generate a refined response using the LLM
+        refined_response = self.llm.create_chat_completion(
+            messages=[{"role": "user", "content": f"Context: {combined_context}\nQuestion: {query}"}],
+            max_tokens=self.max_tokens,
+            temperature=self.temperature,
+            top_p=self.top_p
+        )['choices'][0]['message']['content']
+
+        # Enhance the response to include more details about the specific section
+        refined_response = self.enhance_response_with_details(query, refined_response)
+
+        logging.info(f"Generated refined response: {refined_response}")
+
+        return refined_response
+
+    def enhance_response_with_details(self, query: str, refined_response: str) -> str:
+        if "chronique #" in query:
+            section_number = query.split("chronique #")[1].split()[0]
+            section_description = self.get_section_description(f"chronique #{section_number}")
+        elif "flash info fl-" in query:
+            section_number = query.split("flash info fl-")[1].split()[0]
+            section_description = self.get_section_description(f"flash info fl-{section_number}")
+        elif "chronique-faq #" in query:
+            section_number = query.split("chronique-faq #")[1].split()[0]
+            section_description = self.get_section_description(f"chronique-faq #{section_number}")
+        else:
+            section_description = ""
+
+        if section_description:
+            refined_response += f"\n\nVoici plus de détails sur la section demandée:\n{section_description}"
+
+        return refined_response
+
+    def get_section_description(self, section_name: str) -> str:
+        # Normalize the section name to lowercase
+        section_name = section_name.lower()
+
+        # Retrieve the specific section from the database
+        self.memory.cursor.execute("SELECT description FROM semantic_memory WHERE concept LIKE ?", (f"{section_name}%",))
+        result = self.memory.cursor.fetchone()
+        if result:
+            logging.info(f"Found section: {section_name}")
+            return result[0]
+        else:
+            logging.warning(f"Section not found: {section_name}")
+            return ""
+
+    def enhance_response(self, query: str, initial_response: str) -> str:
+        # Ask the LLM to enhance the response
+        try:
+            enhanced_query = f"{initial_response} Comment pourriez-vous améliorer cette réponse pour qu'elle soit entièrement conforme à la requête de l'utilisateur ? {query}. Notez que vous êtes l'assistant IA de Michel Thomas, le consultant qui a écrit tout ce contenu sur son site web, y compris toutes les Chroniques, Flash Infos et Chronique-FAQ sur https://mtc-qc.ca. Votre tâche est de formuler une réponse claire et concise pour les utilisateurs du site web. - Utilisez uniquement le contenu de la base de données. Ne jamais utiliser des connaissances externes ou des suppositions. Si le contenu de la base de données ne fournit pas suffisamment d'informations, indiquez clairement que vous ne disposez pas de suffisamment d'informations pour répondre à la question. - Ne jamais ecrire des charactere semblable a  (c)  car cela reprensente le charactere  é . "
+            enhanced_response = self.llm.create_chat_completion(
+                messages=[{"role": "user", "content": enhanced_query}],
+                max_tokens=self.max_tokens,
+                temperature=self.temperature,
+                top_p=self.top_p
+            )['choices'][0]['message']['content']
+            logging.info(f"Enhanced response: {enhanced_response}")
+        except Exception as e:
+            enhanced_response = f"Erreur lors de l'amélioration de la réponse: {e}"
+            logging.error(f"Erreur lors de l'amélioration de la réponse: {e}")
+
+        return enhanced_response
+
+    def evaluate_response(self, response: str, query: str) -> bool:
+        # Evaluate the response to determine if it is sufficient
+        # Example: Check if the response contains all key terms from the query
+        key_terms = set(query.split())
+        response_terms = set(response.split())
+        return key_terms.issubset(response_terms)
+
+    def retrieve_additional_data(self, query: str, initial_response: str) -> str:
+        # Retrieve additional relevant data from the database
+        key_terms = set(query.split()) | set(initial_response.split())
+        relevant_memories = self.memory.retrieve_relevant_memories(" ".join(key_terms), limit=10)
+        additional_data = " ".join([memory['description'] for memory in relevant_memories])
+        return additional_data
+
+    def dynamic_query_response_prompt(self, query: str) -> str:
+        return f"""
+        Vous êtes l'assistant intelligent de Michel Thomas. Votre tâche est de répondre à la requête de l'utilisateur en utilisant uniquement le contexte fourni dans la base de données. La requête de l'utilisateur est: "{query}". Assurez-vous que vos réponses sont claires, précises et directement liées à la requête de l'utilisateur. Si possible, incluez des exemples concrets pour illustrer vos points.
+
+        - Utilisez uniquement le contenu de la base de données pour générer la réponse.
+        - Ne jamais utiliser des connaissances externes ou des suppositions.
+        - Résumez le contenu de manière concise et claire.
+        - Expliquez les concepts de manière détaillée et accessible, en utilisant des exemples concrets et des analogies.
+        - Analysez le contenu en profondeur, identifiez les thèmes principaux et les arguments clés.
+        - Critiquez le contenu de manière constructive, en identifiant les points forts et les points faibles.
+        - Générez des questions pertinentes pour encourager une réflexion plus approfondie.
+        - Fournissez des exemples concrets pour illustrer les concepts.
+        - Formulez des hypothèses basées sur les informations disponibles.
+        - Tirez des conclusions bien fondées et soutenues par des preuves.
+        - Formulez des recommandations pratiques et applicables.
+        - Générez des éléments d'action spécifiques, mesurables, réalisables, pertinents et temporellement définis (SMART).
+        - Créez un plan détaillé pour organiser les idées principales et les sous-thèmes.
+        - Rédigez une introduction engageante pour captiver l'attention du lecteur.
+        - Rédigez une conclusion forte pour résumer les points clés et laisser une impression durable.
+        - Paraphrasez le contenu de manière claire et concise, en préservant le sens original.
+        - Simplifiez le contenu pour le rendre plus accessible à un public plus large.
+        - Développez le contenu en ajoutant plus de détails et d'informations.
+        - Comparez deux concepts ou sujets en identifiant les similitudes et les différences.
+        - Contrastez deux concepts ou sujets en mettant en évidence les différences significatives.
+        - Créez des analogies pertinentes pour clarifier les concepts.
+        - Créez des métaphores pertinentes pour illustrer les concepts de manière créative.
+        - Si le contenu de la base de données ne fournit pas suffisamment d'informations, indiquez clairement que vous ne disposez pas de suffisamment d'informations pour répondre à la question.
+        """
+
+    def dynamic_whole_document_prompt(self, query: str, chronique_count: int, flash_info_count: int, chronique_faq_count: int) -> str:
+        return f"""
+        Vous êtes l'assistant intelligent de Michel Thomas, consultant qui a écrit tout ce contenu sur son site web, y compris toutes les Chroniques, Flash Infos et Chronique-FAQ sur https://mtc-qc.ca. Votre tâche est de comprendre l'ensemble du document et de générer un résumé de haut niveau ou un contexte qui peut être utilisé pour répondre à la requête de l'utilisateur. La requête de l'utilisateur est: "{query}". Concentrez-vous sur les points les plus pertinents et importants. Incluez le nombre total de Chroniques ({chronique_count}), Flash Infos ({flash_info_count}), et Chronique-FAQ ({chronique_faq_count}) publiées par Michel Thomas.
+
+        - Utilisez uniquement le contenu de la base de données pour générer le résumé.
+        - Ne jamais utiliser des connaissances externes ou des suppositions.
+        - Résumez le contenu de manière concise et claire.
+        - Expliquez les concepts de manière détaillée et accessible, en utilisant des exemples concrets et des analogies.
+        - Analysez le contenu en profondeur, identifiez les thèmes principaux et les arguments clés.
+        - Critiquez le contenu de manière constructive, en identifiant les points forts et les points faibles.
+        - Générez des questions pertinentes pour encourager une réflexion plus approfondie.
+        - Fournissez des exemples concrets pour illustrer les concepts.
+        - Formulez des hypothèses basées sur les informations disponibles.
+        - Tirez des conclusions bien fondées et soutenues par des preuves.
+        - Formulez des recommandations pratiques et applicables.
+        - Générez des éléments d'action spécifiques, mesurables, réalisables, pertinents et temporellement définis (SMART).
+        - Créez un plan détaillé pour organiser les idées principales et les sous-thèmes.
+        - Rédigez une introduction engageante pour captiver l'attention du lecteur.
+        - Rédigez une conclusion forte pour résumer les points clés et laisser une impression durable.
+        - Paraphrasez le contenu de manière claire et concise, en préservant le sens original.
+        - Simplifiez le contenu pour le rendre plus accessible à un public plus large.
+        - Développez le contenu en ajoutant plus de détails et d'informations.
+        - Comparez deux concepts ou sujets en identifiant les similitudes et les différences.
+        - Contrastez deux concepts ou sujets en mettant en évidence les différences significatives.
+        - Créez des analogies pertinentes pour clarifier les concepts.
+        - Créez des métaphores pertinentes pour illustrer les concepts de manière créative.
+        - Si le contenu de la base de données ne fournit pas suffisamment d'informations, indiquez clairement que vous ne disposez pas de suffisamment d'informations pour répondre à la question.
+        """
+
+    def dynamic_enhancement_prompt(self, query: str) -> str:
+        return f"""
+        Vous êtes l'assistant intelligent de Michel Thomas. Votre tâche est d'améliorer la réponse initiale en la rendant plus complète et plus conforme à la requête de l'utilisateur. La requête de l'utilisateur est: "{query}". Prenez en compte tous les détails pertinents et formulez votre réponse de manière concise et claire. Ajoutez des détails supplémentaires si nécessaire pour rendre la réponse plus informative.
+
+        - Utilisez uniquement le contenu de la base de données pour améliorer la réponse.
+        - Ne jamais utiliser des connaissances externes ou des suppositions.
+        - Résumez le contenu de manière concise et claire en maximum 8 phrases de maximum 88 mots chacun.
+        - Expliquez les concepts de manière détaillée et accessible, en utilisant des exemples concrets et des analogies.
+        - Analysez le contenu en profondeur, identifiez les thèmes principaux et les arguments clés.
+        - Critiquez le contenu de manière constructive, en identifiant les points forts et les points faibles.
+        - Générez des questions pertinentes pour encourager une réflexion plus approfondie.
+        - Fournissez des exemples concrets pour illustrer les concepts.
+        - Formulez des hypothèses basées sur les informations disponibles.
+        - Tirez des conclusions bien fondées et soutenues par des preuves.
+        - Formulez des recommandations pratiques et applicables.
+        - Générez des éléments d'action spécifiques, mesurables, réalisables, pertinents et temporellement définis (SMART).
+        - Créez un plan détaillé pour organiser les idées principales et les sous-thèmes.
+        - Rédigez une introduction engageante pour captiver l'attention du lecteur.
+        - Rédigez une conclusion forte pour résumer les points clés et laisser une impression durable.
+        - Paraphrasez le contenu de manière claire et concise, en préservant le sens original.
+        - Simplifiez le contenu pour le rendre plus accessible �� un public plus large.
+        - Développez le contenu en ajoutant plus de détails et d'informations.
+        - Comparez deux concepts ou sujets en identifiant les similitudes et les différences.
+        - Contrastez deux concepts ou sujets en mettant en évidence les différences significatives.
+        - Créez des analogies pertinentes pour clarifier les concepts.
+        - Créez des métaphores pertinentes pour illustrer les concepts de manière créative.
+        - Si le contenu de la base de données ne fournit pas suffisamment d'informations, indiquez clairement que vous ne disposez pas de suffisamment d'informations pour répondre à la question.
+        """
+
+    def count_chroniques(self) -> int:
+        # Count the number of chroniques in the database
+        self.memory.cursor.execute("SELECT COUNT(*) FROM semantic_memory WHERE concept LIKE 'chronique #%'")
+        count = self.memory.cursor.fetchone()[0]
+        logging.info(f"Number of chroniques: {count}")
+        return count
+
+    def count_flash_infos(self) -> int:
+        # Count the number of flash infos in the database
+        self.memory.cursor.execute("SELECT COUNT(*) FROM semantic_memory WHERE concept LIKE 'flash info fl-%'")
+        count = self.memory.cursor.fetchone()[0]
+        logging.info(f"Number of flash infos: {count}")
+        return count
+
+    def count_chronique_faqs(self) -> int:
+        # Count the number of chronique-faqs in the database
+        self.memory.cursor.execute("SELECT COUNT(*) FROM semantic_memory WHERE concept LIKE 'chronique-faq #%'")
+        count = self.memory.cursor.fetchone()[0]
+        logging.info(f"Number of chronique-faqs: {count}")
+        return count

src/create_database.py

@@ -0,0 +1,88 @@
+# src/create_database.py
+import os
+import json
+from src.memory import MemoryManager  # Corrected import path
+import logging
+from typing import List, Dict
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+def parse_data_update(file_path: str, keyword_dir: str) -> List[Dict[str, str]]:
+    if not os.path.exists(file_path):
+        logging.error(f"File not found: {file_path}")
+        return []
+
+    with open(file_path, 'r') as file_obj:
+        content = file_obj.read()
+
+    content = content.lower()  # Normalize to lowercase
+
+    sections = []
+    lines = content.split('\n')
+    current_section = None
+    current_content = []
+
+    for line in lines:
+        if line.strip().startswith("chronique #") or line.strip().startswith("flash info fl-") or line.strip().startswith("chronique-faq #"):
+            if current_section:
+                sections.append({
+                    "concept": current_section,
+                    "description": "\n".join(current_content)
+                })
+                logging.info(f"Parsed section: {current_section}")
+            current_section = line.strip()
+            current_content = []
+        else:
+            current_content.append(line)
+
+    if current_section:
+        sections.append({
+            "concept": current_section,
+            "description": "\n".join(current_content)
+        })
+        logging.info(f"Parsed section: {current_section}")
+
+    return sections
+
+def get_keywords(number: str, keyword_dir: str) -> List[str]:
+    keyword_file = os.path.join(keyword_dir, f"FL-{number}-KEYWORD.txt")
+    if not os.path.exists(keyword_file):
+        keyword_file = os.path.join(keyword_dir, f"INFO-{number}-KEYWORD.txt")
+    if not os.path.exists(keyword_file):
+        keyword_file = os.path.join(keyword_dir, f"CHRONIQUE{number}-KEYWORD.txt")
+    if not os.path.exists(keyword_file):
+        logging.warning(f"Keyword file not found: {keyword_file}")
+        return []
+
+    with open(keyword_file, 'r') as file_obj:
+        content = file_obj.read()
+        if 'KEYWORD = ' in content:
+            content = content.split('KEYWORD = ')[1]
+        tags = content.split(', ')
+        tags = [tag.strip() for tag in tags if tag.strip()]  # Remove empty tags
+        logging.info(f"Keywords for {number}: {tags}")
+        return tags
+
+def load_and_process_dataset(data_update_path: str, keyword_dir: str, db_path: str):
+    memory_manager = MemoryManager(db_path)
+
+    sections = parse_data_update(data_update_path, keyword_dir)
+    for section in sections:
+        concept = section['concept']
+        description = section['description']
+        number = concept.split('#')[1].split()[0]  # Extract the number from the concept
+        tags = get_keywords(number, keyword_dir)
+
+        # Check if the section already exists in the database
+        if not memory_manager.section_exists(concept):
+            memory_manager.add_semantic_memory(concept, description, tags=tags)
+            logging.info(f"Added section: {concept}")
+        else:
+            logging.info(f"Section already exists: {concept}")
+
+if __name__ == "__main__":
+    data_update_path = "data-update.txt"
+    keyword_dir = "keyword"  # Updated keyword directory
+    db_path = "agent.db"
+    load_and_process_dataset(data_update_path, keyword_dir, db_path)

src/gradio_app.py

@@ -0,0 +1,58 @@
+# src/gradio_app.py
+import gradio as gr
+from agent import Agent
+from create_database import load_and_process_dataset  # Import from create_database.py
+import os
+import uuid
+import urllib.request
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+def download_model():
+    model_url = "https://path/to/your/model.bin"
+    model_path = "model.bin"
+
+    if not os.path.exists(model_path):
+        print("Downloading model...")
+        urllib.request.urlretrieve(model_url, model_path)
+        print("Model downloaded successfully.")
+
+def respond(
+    message,
+    history: list[tuple[str, str]],
+    system_message,
+):
+    model_path = "model.bin"  # Path to the downloaded model
+    db_path = "agent.db"
+    system_prompt = system_message
+
+    # Check if the model is downloaded
+    if not os.path.exists(model_path):
+        download_model()
+
+    # Check if the database exists, if not, initialize it
+    if not os.path.exists(db_path):
+        data_update_path = "data-update.txt"
+        keyword_dir = "keyword"  # Updated keyword directory
+        load_and_process_dataset(data_update_path, keyword_dir, db_path)
+
+    agent = Agent(model_path, db_path, system_prompt)
+    user_id = str(uuid.uuid4())  # Generate a unique user ID for each session
+
+    response = agent.process_query(user_id, message)
+    return response
+
+"""
+For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
+"""
+demo = gr.ChatInterface(
+    respond,
+    additional_inputs=[
+        gr.Textbox(value="Vous êtes l'assistant intelligent de Les Chronique MTC. Votre rôle est d'aider les visiteurs en expliquant le contenu des Chroniques, Flash Infos et Chronique-FAQ de Michel Thomas. Utilisez le contexte fourni pour améliorer vos réponses et veillez à ce qu'elles soient précises et pertinentes.", label="System message"),
+    ],
+)
+
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0", server_port=7860)

src/llm_interface.py

@@ -0,0 +1,19 @@
+# src/llm_interface.py
+import llama_cpp
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+class LLMInterface:
+    def __init__(self, model_path: str, default_system_prompt: str = ""):
+        self.model = llama_cpp.Llama(model_path=model_path)
+        self.default_system_prompt = default_system_prompt
+
+    def send_message(self, message: str, system_prompt: str = None, max_tokens: int = 512, temperature: float = 0.7, top_p: float = 0.95) -> str:
+        if system_prompt is None:
+            system_prompt = self.default_system_prompt
+
+        prompt = f"{system_prompt}\nUser: {message}\nAssistant: "
+        response = self.model(prompt, max_tokens=max_tokens, temperature=temperature, top_p=top_p)
+        return response['choices'][0]['text'].strip()

src/main.py

@@ -0,0 +1,78 @@
+# src/main.py
+from src.agent import Agent
+from src.create_database import load_and_process_dataset  # Import from create_database.py
+import os
+import uuid
+import requests
+import logging
+from llama_cpp import Llama
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Create the directory if it doesn't exist
+local_dir = "models"
+os.makedirs(local_dir, exist_ok=True)
+
+# Specify the filename for the model
+filename = "unsloth.Q4_K_M.gguf"
+model_path = os.path.join(local_dir, filename)
+
+# Function to download the model file
+def download_model(repo_id, filename, save_path):
+    # Construct the URL for the model file
+    url = f"https://huggingface.co/{repo_id}/resolve/main/{filename}"
+
+    # Download the model file
+    response = requests.get(url)
+    if response.status_code == 200:
+        with open(save_path, 'wb') as f:
+            f.write(response.content)
+        print(f"Model downloaded to {save_path}")
+    else:
+        print(f"Failed to download model: {response.status_code}")
+
+# Download the model if it doesn't exist
+if not os.path.exists(model_path):
+    download_model("PurpleAILAB/Llama3.2-3B-uncensored-SQLi-Q4_K_M-GGUF", filename, model_path)
+
+def main():
+    model_path = "models/unsloth.Q4_K_M.gguf"  # Path to the downloaded model
+    db_path = "agent.db"
+    system_prompt = "Vous êtes l'assistant intelligent de Les Chronique MTC. Votre rôle est d'aider les visiteurs en expliquant le contenu des Chroniques, Flash Infos et Chronique-FAQ de Michel Thomas. Utilisez le contexte fourni pour améliorer vos réponses et veillez à ce qu'elles soient précises et pertinentes."
+    max_tokens = 512
+    temperature = 0.7
+    top_p = 0.95
+
+    # Check if the database exists, if not, initialize it
+    if not os.path.exists(db_path):
+        data_update_path = "data-update.txt"
+        keyword_dir = "keyword"  # Updated keyword directory
+        load_and_process_dataset(data_update_path, keyword_dir, db_path)
+
+    # Load the model
+    llm = Llama(
+        model_path=model_path,
+        n_ctx=5072,  # Set the maximum context length
+        max_tokens=max_tokens  # Control the maximum number of tokens generated in the response
+    )
+
+    agent = Agent(llm, db_path, system_prompt, max_tokens, temperature, top_p)
+
+    while True:
+        user_id = str(uuid.uuid4())  # Generate a unique user ID for each session
+        user_query = input("Entrez votre requête: ")
+        if user_query.lower() == 'exit':
+            break
+
+        try:
+            response = agent.process_query(user_id, user_query)
+            print("Réponse:", response)
+        except Exception as e:
+            print(f"Erreur lors du traitement de la requête: {e}")
+
+        # Clean up expired interactions
+        agent.memory.cleanup_expired_interactions()
+
+if __name__ == "__main__":
+    main()

src/memory.py

@@ -0,0 +1,158 @@
+# src/memory.py
+import sqlite3
+from datetime import datetime, timedelta
+import json
+from typing import List, Dict, Any, Tuple
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+class MemoryManager:
+    def __init__(self, db_path: str):
+        self.conn = sqlite3.connect(db_path)
+        self.cursor = self.conn.cursor()
+        self.create_tables()
+        self.vectorizer = TfidfVectorizer(stop_words='english')
+        logging.info("MemoryManager initialized and tables created.")
+
+    def create_tables(self):
+        # Create tables if they don't exist
+        self.cursor.execute('''CREATE TABLE IF NOT EXISTS semantic_memory
+                           (id INTEGER PRIMARY KEY, concept TEXT, description TEXT, last_accessed DATETIME, tags TEXT, importance REAL DEFAULT 0.5)''')
+
+        # Add tags and importance columns if they don't exist
+        self.cursor.execute("PRAGMA table_info(semantic_memory)")
+        columns = [column[1] for column in self.cursor.fetchall()]
+        if 'tags' not in columns:
+            self.cursor.execute("ALTER TABLE semantic_memory ADD COLUMN tags TEXT")
+        if 'importance' not in columns:
+            self.cursor.execute("ALTER TABLE semantic_memory ADD COLUMN importance REAL DEFAULT 0.5")
+
+        self.cursor.execute('''CREATE INDEX IF NOT EXISTS idx_semantic_concept ON semantic_memory (concept)''')
+        self.cursor.execute('''CREATE INDEX IF NOT EXISTS idx_semantic_last_accessed ON semantic_memory (last_accessed)''')
+        self.cursor.execute('''CREATE INDEX IF NOT EXISTS idx_semantic_tags ON semantic_memory (tags)''')
+
+        # Create table for user interactions
+        self.cursor.execute('''CREATE TABLE IF NOT EXISTS user_interactions
+                           (user_id TEXT, query TEXT, response TEXT, timestamp DATETIME)''')
+
+        self.cursor.execute('''CREATE INDEX IF NOT EXISTS idx_user_interactions_timestamp ON user_interactions (timestamp)''')
+        self.conn.commit()
+        logging.info("Tables and indexes created successfully.")
+
+    def add_semantic_memory(self, concept: str, description: str, tags: List[str] = None):
+        if tags is None:
+            tags = []
+        tags_str = json.dumps(tags)
+        self.cursor.execute("INSERT INTO semantic_memory (concept, description, last_accessed, tags) VALUES (?, ?, ?, ?)",
+                            (concept, description, datetime.now().isoformat(), tags_str))
+        self.conn.commit()
+        logging.info("Semantic memory added.")
+
+    def retrieve_relevant_memories(self, query: str, limit: int = 30) -> List[Dict[str, Any]]:
+        all_memories = self._get_all_memories()
+
+        # Handle empty or stop-word-only query
+        if not query.strip() or self.vectorizer.stop_words and all(word in self.vectorizer.stop_words for word in query.split()):
+            return []
+
+        scored_memories = self._score_memories(query, all_memories)
+        return [memory for memory, score in sorted(scored_memories, key=lambda x: x[1], reverse=True)[:limit]]
+
+    def _get_all_memories(self) -> List[Tuple[Dict[str, Any], datetime]]:
+        self.cursor.execute("SELECT concept, description, importance, last_accessed, tags FROM semantic_memory ORDER BY importance DESC, last_accessed DESC")
+        semantic_memories = self.cursor.fetchall()
+
+        all_memories = [({"concept": concept, "description": description, "importance": importance},
+                         datetime.fromisoformat(last_accessed), json.loads(tags) if tags else None) for concept, description, importance, last_accessed, tags in semantic_memories]
+
+        return all_memories
+
+    def _score_memories(self, query: str, memories: List[Tuple[Dict[str, Any], datetime, List[str]]]) -> List[Tuple[Dict[str, Any], float]]:
+        query_vector = self.vectorizer.fit_transform([query])
+
+        scored_memories = []
+        for memory, timestamp, tags in memories:
+            text = f"{memory['concept']} {memory['description']}"
+            importance = memory.get('importance', 0.5)
+
+            memory_vector = self.vectorizer.transform([text])
+            similarity = cosine_similarity(query_vector, memory_vector)[0][0]
+
+            if timestamp:
+                recency = 1 / (1 + (datetime.now() - timestamp).total_seconds() / 60)  # Favor recent memories
+            else:
+                recency = 0.5  # Neutral recency for semantic memories
+
+            score = (similarity + importance + recency) / 3
+            scored_memories.append((memory, score))
+
+        return scored_memories
+
+    def section_exists(self, concept: str) -> bool:
+        # Normalize the concept to lowercase
+        concept = concept.lower()
+        self.cursor.execute("SELECT COUNT(*) FROM semantic_memory WHERE concept LIKE ?", (f"{concept}%",))
+        count = self.cursor.fetchone()[0]
+        return count > 0
+
+    def add_user_interaction(self, user_id: str, query: str, response: str):
+        self.cursor.execute("INSERT INTO user_interactions (user_id, query, response, timestamp) VALUES (?, ?, ?, ?)",
+                            (user_id, query, response, datetime.now().isoformat()))
+        self.conn.commit()
+        logging.info(f"User interaction added: User ID: {user_id}, Query: {query}, Response: {response}")
+
+    def get_user_interactions(self, user_id: str) -> List[Dict[str, Any]]:
+        self.cursor.execute("SELECT query, response, timestamp FROM user_interactions WHERE user_id = ?", (user_id,))
+        interactions = self.cursor.fetchall()
+        return [{"query": query, "response": response, "timestamp": timestamp} for query, response, timestamp in interactions]
+
+    def cleanup_expired_interactions(self):
+        cutoff_time = datetime.now() - timedelta(minutes=5)
+        self.cursor.execute("DELETE FROM user_interactions WHERE timestamp < ?", (cutoff_time.isoformat(),))
+        self.conn.commit()
+        logging.info(f"Expired user interactions cleaned up. Cutoff time: {cutoff_time}")
+
+    def get_section_description(self, section_name: str) -> str:
+        # Normalize the section name to lowercase
+        section_name = section_name.lower()
+
+        # Retrieve the specific section from the database
+        self.cursor.execute("SELECT description FROM semantic_memory WHERE concept LIKE ?", (f"{section_name}%",))
+        result = self.cursor.fetchone()
+        if result:
+            logging.info(f"Found section: {section_name}")
+            return result[0]
+        else:
+            logging.warning(f"Section not found: {section_name}")
+            return ""
+
+    def count_chroniques(self) -> int:
+        # Count the number of chroniques in the database
+        self.cursor.execute("SELECT COUNT(*) FROM semantic_memory WHERE concept LIKE 'chronique #%'")
+        count = self.cursor.fetchone()[0]
+        logging.info(f"Number of chroniques: {count}")
+        return count
+
+    def count_flash_infos(self) -> int:
+        # Count the number of flash infos in the database
+        self.cursor.execute("SELECT COUNT(*) FROM semantic_memory WHERE concept LIKE 'flash info fl-%'")
+        count = self.cursor.fetchone()[0]
+        logging.info(f"Number of flash infos: {count}")
+        return count
+
+    def count_chronique_faqs(self) -> int:
+        # Count the number of chronique-faqs in the database
+        self.cursor.execute("SELECT COUNT(*) FROM semantic_memory WHERE concept LIKE 'chronique-faq #%'")
+        count = self.cursor.fetchone()[0]
+        logging.info(f"Number of chronique-faqs: {count}")
+        return count
+
+if __name__ == "__main__":
+    db_path = "agent.db"
+    memory_manager = MemoryManager(db_path)
+    memory_manager.cleanup_expired_interactions()

src/prompts.py

@@ -0,0 +1,114 @@
+# src/prompts.py
+
+class Prompts:
+    GENERAL_SYSTEM_PROMPT = """
+    Vous êtes l'assistant intelligent de Les Chronique MTC. Votre rôle est d'aider les visiteurs en expliquant le contenu des Chroniques, Flash Infos et Chronique-FAQ de Michel Thomas. Utilisez uniquement le contexte fourni dans la base de données pour améliorer vos réponses et veillez à ce qu'elles soient précises, pertinentes et bien structurées.
+
+    - Utilisez uniquement le contenu de la base de données pour générer la réponse.
+    - Ne jamais utiliser des connaissances externes ou des suppositions.
+    - Résumez le contenu de manière concise et claire.
+    - Expliquez les concepts de manière détaillée et accessible, en utilisant des exemples concrets et des analogies.
+    - Analysez le contenu en profondeur, identifiez les thèmes principaux et les arguments clés.
+    - Critiquez le contenu de manière constructive, en identifiant les points forts et les points faibles.
+    - Générez des questions pertinentes pour encourager une réflexion plus approfondie.
+    - Fournissez des exemples concrets pour illustrer les concepts.
+    - Formulez des hypothèses basées sur les informations disponibles.
+    - Tirez des conclusions bien fondées et soutenues par des preuves.
+    - Formulez des recommandations pratiques et applicables.
+    - Générez des éléments d'action spécifiques, mesurables, réalisables, pertinents et temporellement définis (SMART).
+    - Créez un plan détaillé pour organiser les idées principales et les sous-thèmes.
+    - Rédigez une introduction engageante pour captiver l'attention du lecteur.
+    - Rédigez une conclusion forte pour résumer les points clés et laisser une impression durable.
+    - Paraphrasez le contenu de manière claire et concise, en préservant le sens original.
+    - Simplifiez le contenu pour le rendre plus accessible à un public plus large.
+    - Développez le contenu en ajoutant plus de détails et d'informations.
+    - Comparez deux concepts ou sujets en identifiant les similitudes et les différences.
+    - Contrastez deux concepts ou sujets en mettant en évidence les différences significatives.
+    - Créez des analogies pertinentes pour clarifier les concepts.
+    - Créez des métaphores pertinentes pour illustrer les concepts de manière créative.
+    - Si le contenu de la base de données ne fournit pas suffisamment d'informations, indiquez clairement que vous ne disposez pas de suffisamment d'informations pour répondre à la question.
+    """
+
+    WHOLE_DOCUMENT_SYSTEM_PROMPT = """
+    Vous êtes l'assistant intelligent de Michel Thomas, consultant qui a écrit tout ce contenu sur son site web, y compris toutes les Chroniques, Flash Infos et Chronique-FAQ sur https://mtc-qc.ca. Votre tâche est de comprendre l'ensemble du document et de générer un résumé de haut niveau ou un contexte qui peut être utilisé pour répondre à la requête de l'utilisateur. La requête de l'utilisateur est: "{query}". Concentrez-vous sur les points les plus pertinents et importants. Incluez le nombre total de Chroniques, Flash Infos, et Chronique-FAQ publiées par Michel Thomas.
+
+    - Utilisez uniquement le contenu de la base de données pour générer le résumé.
+    - Ne jamais utiliser des connaissances externes ou des suppositions.
+    - Résumez le contenu de manière concise et claire.
+    - Expliquez les concepts de manière détaillée et accessible, en utilisant des exemples concrets et des analogies.
+    - Analysez le contenu en profondeur, identifiez les thèmes principaux et les arguments clés.
+    - Critiquez le contenu de manière constructive, en identifiant les points forts et les points faibles.
+    - Générez des questions pertinentes pour encourager une réflexion plus approfondie.
+    - Fournissez des exemples concrets pour illustrer les concepts.
+    - Formulez des hypothèses basées sur les informations disponibles.
+    - Tirez des conclusions bien fondées et soutenues par des preuves.
+    - Formulez des recommandations pratiques et applicables.
+    - Générez des éléments d'action spécifiques, mesurables, réalisables, pertinents et temporellement définis (SMART).
+    - Créez un plan détaillé pour organiser les idées principales et les sous-thèmes.
+    - Rédigez une introduction engageante pour captiver l'attention du lecteur.
+    - Rédigez une conclusion forte pour résumer les points clés et laisser une impression durable.
+    - Paraphrasez le contenu de manière claire et concise, en préservant le sens original.
+    - Simplifiez le contenu pour le rendre plus accessible à un public plus large.
+    - Développez le contenu en ajoutant plus de détails et d'informations.
+    - Comparez deux concepts ou sujets en identifiant les similitudes et les différences.
+    - Contrastez deux concepts ou sujets en mettant en évidence les différences significatives.
+    - Créez des analogies pertinentes pour clarifier les concepts.
+    - Créez des métaphores pertinentes pour illustrer les concepts de manière créative.
+    - Si le contenu de la base de données ne fournit pas suffisamment d'informations, indiquez clairement que vous ne disposez pas de suffisamment d'informations pour répondre à la question.
+    """
+
+    QUERY_RESPONSE_SYSTEM_PROMPT = """
+    Vous êtes l'assistant intelligent de Michel Thomas. Votre tâche est de répondre à la requête de l'utilisateur en utilisant uniquement le contexte fourni dans la base de données. La requête de l'utilisateur est: "{query}". Assurez-vous que vos réponses sont claires, précises et directement liées à la requête de l'utilisateur. Si possible, incluez des exemples concrets pour illustrer vos points.
+
+    - Utilisez uniquement le contenu de la base de données pour générer la réponse.
+    - Ne jamais utiliser des connaissances externes ou des suppositions.
+    - Résumez le contenu de manière concise et claire.
+    - Expliquez les concepts de manière détaillée et accessible, en utilisant des exemples concrets et des analogies.
+    - Analysez le contenu en profondeur, identifiez les thèmes principaux et les arguments clés.
+    - Critiquez le contenu de manière constructive, en identifiant les points forts et les points faibles.
+    - Générez des questions pertinentes pour encourager une réflexion plus approfondie.
+    - Fournissez des exemples concrets pour illustrer les concepts.
+    - Formulez des hypothèses basées sur les informations disponibles.
+    - Tirez des conclusions bien fondées et soutenues par des preuves.
+    - Formulez des recommandations pratiques et applicables.
+    - Générez des éléments d'action spécifiques, mesurables, réalisables, pertinents et temporellement définis (SMART).
+    - Créez un plan détaillé pour organiser les idées principales et les sous-thèmes.
+    - Rédigez une introduction engageante pour captiver l'attention du lecteur.
+    - Rédigez une conclusion forte pour résumer les points clés et laisser une impression durable.
+    - Paraphrasez le contenu de manière claire et concise, en préservant le sens original.
+    - Simplifiez le contenu pour le rendre plus accessible à un public plus large.
+    - Développez le contenu en ajoutant plus de détails et d'informations.
+    - Comparez deux concepts ou sujets en identifiant les similitudes et les différences.
+    - Contrastez deux concepts ou sujets en mettant en évidence les différences significatives.
+    - Créez des analogies pertinentes pour clarifier les concepts.
+    - Créez des métaphores pertinentes pour illustrer les concepts de manière créative.
+    - Si le contenu de la base de données ne fournit pas suffisamment d'informations, indiquez clairement que vous ne disposez pas de suffisamment d'informations pour répondre à la question.
+    """
+
+    ENHANCEMENT_SYSTEM_PROMPT = """
+    Vous êtes l'assistant intelligent de Michel Thomas. Votre tâche est d'améliorer la réponse initiale en la rendant plus complète et plus conforme à la requête de l'utilisateur. La requête de l'utilisateur est: "{query}". Prenez en compte tous les détails pertinents et formulez votre réponse de manière concise et claire. Ajoutez des détails supplémentaires si nécessaire pour rendre la réponse plus informative.
+
+    - Utilisez uniquement le contenu de la base de données pour améliorer la réponse.
+    - Ne jamais utiliser des connaissances externes ou des suppositions.
+    - Résumez le contenu de manière concise et claire en maximum 8 phrases de maximum 88 mots chacun.
+    - Expliquez les concepts de manière détaillée et accessible, en utilisant des exemples concrets et des analogies.
+    - Analysez le contenu en profondeur, identifiez les thèmes principaux et les arguments clés.
+    - Critiquez le contenu de manière constructive, en identifiant les points forts et les points faibles.
+    - Générez des questions pertinentes pour encourager une réflexion plus approfondie.
+    - Fournissez des exemples concrets pour illustrer les concepts.
+    - Formulez des hypothèses basées sur les informations disponibles.
+    - Tirez des conclusions bien fondées et soutenues par des preuves.
+    - Formulez des recommandations pratiques et applicables.
+    - Générez des éléments d'action spécifiques, mesurables, réalisables, pertinents et temporellement définis (SMART).
+    - Créez un plan détaillé pour organiser les idées principales et les sous-thèmes.
+    - Rédigez une introduction engageante pour captiver l'attention du lecteur.
+    - Rédigez une conclusion forte pour résumer les points clés et laisser une impression durable.
+    - Paraphrasez le contenu de manière claire et concise, en préservant le sens original.
+    - Simplifiez le contenu pour le rendre plus accessible à un public plus large.
+    - Développez le contenu en ajoutant plus de détails et d'informations.
+    - Comparez deux concepts ou sujets en identifiant les similitudes et les différences.
+    - Contrastez deux concepts ou sujets en mettant en évidence les diff��rences significatives.
+    - Créez des analogies pertinentes pour clarifier les concepts.
+    - Créez des métaphores pertinentes pour illustrer les concepts de manière créative.
+    - Si le contenu de la base de données ne fournit pas suffisamment d'informations, indiquez clairement que vous ne disposez pas de suffisamment d'informations pour répondre à la question.
+    """

src/utils.py

@@ -0,0 +1,69 @@
+# src/utils.py
+import os
+import json
+from src.memory import MemoryManager  # Corrected import path
+from src.llm_interface import LLMInterface  # Import LLMInterface
+import logging
+import spacy
+from sklearn.cluster import KMeans
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+def chunk_text(text, chunk_size=1000, overlap=100):
+    chunks = []
+    start = 0
+    while start < len(text):
+        end = start + chunk_size
+        chunks.append(text[start:end])
+        start = end - overlap
+    return chunks
+
+def extract_and_summarize(query: str, memory_manager: MemoryManager, llm_interface: LLMInterface, system_prompt: str = "", max_tokens: int = 512, temperature: float = 0.7, top_p: float = 0.95) -> str:
+    # Retrieve relevant memories from the database
+    relevant_memories = memory_manager.retrieve_relevant_memories(query, limit=30)
+    logging.info(f"Retrieved {len(relevant_memories)} relevant memories for query: {query}")
+
+    # Combine relevant memories into a single context
+    context = " ".join([memory['description'] for memory in relevant_memories])
+    logging.info(f"Built context: {context}")
+
+    # Truncate the context if it exceeds the token limit
+    max_context_length = 30000  # Adjust this based on your LLM's token limit
+    if len(context) > max_context_length:
+        context = context[:max_context_length]
+        logging.info(f"Truncated context to {max_context_length} characters.")
+
+    # Use spaCy to generate sentence embeddings
+    nlp = spacy.load('en_core_web_lg')
+    sentences = context.split('.')
+    sentence_embeddings = [nlp(sent).vector for sent in sentences]
+
+    # Cluster sentences
+    num_clusters = min(len(sentences), 10)  # Adjust the number of clusters
+    kmeans = KMeans(n_clusters=num_clusters)
+    kmeans.fit(sentence_embeddings)
+    labels = kmeans.labels_
+
+    # Select representative sentences from each cluster
+    representative_sentences = []
+    for i in range(num_clusters):
+        cluster_sentences = [sentences[j] for j in range(len(sentences)) if labels[j] == i]
+        if cluster_sentences:
+            representative_sentences.append(max(cluster_sentences, key=len))  # Select the longest sentence as representative
+
+    # Combine representative sentences to form a summary
+    summary = " ".join(representative_sentences)
+    logging.info(f"Generated summary: {summary}")
+
+    # Use LLM to refine the summary
+    try:
+        refined_summary = llm_interface.send_message(f"Context: {summary}\nQuestion: {query}", system_prompt=system_prompt, max_tokens=max_tokens, temperature=temperature, top_p=top_p)
+        logging.info(f"Refined summary: {refined_summary}")
+    except Exception as e:
+        refined_summary = f"Error refining summary: {e}"
+        logging.error(f"Error refining summary: {e}")
+
+    return refined_summary