Sidebar updated

app.py

@@ -39,6 +39,9 @@ def process_query(query, architecture: Literal["A", "B", "C"]):
     display_chat_history()
 
     config = {"metadata": {"architecture": architecture}, "tags": ["arch_" + architecture]}
+    # Récupération des paramètres dynamiques uniquement
+    k = st.session_state.get("k", 30)  # Nombre de documents
+    similarity_threshold = st.session_state.get("similarity_threshold", 0.7)  # similarité cosinus
 
     if architecture == "A":
         agent = agent_A
@@ -47,16 +50,16 @@ def process_query(query, architecture: Literal["A", "B", "C"]):
             "messages": [],
             "relevant_docs": [],
             "response": "",
+            "k": k,  
+            "alpha": alpha,
         }
 
     elif architecture in ["B", "C"]:
         agent = agent_B if architecture == "B" else agent_C
 
-        # Récupération des paramètres dynamiques uniquement pour B et C
-        k = st.session_state.get("k", 30)  # Nombre de documents
+        # Récupération du paramétre alpha uniquement pour B et C
         alpha = st.session_state.get("alpha", 0.5)  # Pondération hybride
-        similarity_threshold = st.session_state.get("similarity_threshold", 0.7)  # similarité cosinus
-
+        
         initial_state = {
             "query": query,
             "messages": [],
@@ -147,21 +150,35 @@ def display_sidebar():
         # Token metrics containers
         # st.sidebar.markdown("### Tokens")
 
-        st.markdown("### Paramètres de la recherche hybride")
+        st.markdown("### Paramètres de la recherche RAG")
 
         # Sélection du nombre de documents (k)
-        k = st.number_input("Nombre de documents à récupérer (k)", min_value=1, max_value=100, value=30, step=1)
-
-        # Sélection du score de similarité cosinus(entre la requête et les documents pertinents)
-        similarity_threshold = st.slider("Score de similarité cosinus entre la requête et les documents pertinents", 0.0, 1.0, 0.7, 0.05)
-        
-        # Sélection du coefficient de pondération alpha
-        alpha = st.slider("Équilibre entre recherche sémantique et syntaxique (pour alpha = 0.0, la recherche est purement syntaxique)", 0.0, 1.0, 0.5, 0.05)
+        st.markdown("""
+        **Nombre de documents à récupérer (k)**  
+        <small>🛈 Détermine combien de documents seront récupérés lors de la recherche.</small>
+        """, unsafe_allow_html=True)
+
+        st.number_input(" ", min_value=1, max_value=100, value=30, step=1, key="k")
+
+        # Sélection du score de similarité cosinus
+        st.markdown("""
+        **Score de similarité cosinus**  
+        <small>🛈 Ce paramètre définit le seuil minimal de similarité entre deux vecteurs. Plus il est élevé, plus seuls les éléments très similaires seront considérés comme correspondants.</small>
+        """, unsafe_allow_html=True)
+        st.slider(" ", 0.0, 1.0, value=0.7, step=0.05, key="similarity_threshold")
+
+        # Afficher alpha uniquement pour B et C
+        if st.session_state.get("architecture") in ["B", "C"]:
+            st.markdown("""
+            **Équilibre entre recherche sémantique et syntaxique**  
+            <small>🛈 Pour `alpha = 0.0`, la recherche est purement syntaxique. Pour `alpha = 1.0`, elle est purement sémantique.</small>
+            """, unsafe_allow_html=True)
+
+            st.slider(" ", 0.0, 1.0, value=0.5, step=0.05, key="alpha")  # Sauvegarde de la valeur alpha
+        else:
+            # Réinitialiser alpha si l'architecture est A
+            st.session_state['alpha'] = None  
 
-        # Sauvegarde des valeurs dans la session
-        st.session_state['k'] = k
-        st.session_state['alpha'] = alpha
-        st.session_state['similarité'] = similarity_threshold
 
         st.sidebar.markdown("### API Mistral AI")
 
@@ -204,7 +221,6 @@ def display_sidebar():
         st.sidebar.markdown("2025 : Open source en Licence MIT")
         st.sidebar.markdown("info@bziiit.com")
 
-
 def display_chat_history():
     """Affiche l'historique de chat."""
     for message in st.session_state.chat_history:
@@ -256,21 +272,22 @@ def main():
         on_change=st.session_state.chat_history.clear
     )        
 
+    # Sauvegarder l'architecture dans st.session_state
+    if architecture == "Intermédiaire":
+        st.session_state["architecture"] = "B"
+    elif architecture == "Avancée":
+        st.session_state["architecture"] = "C"
+    else:
+        st.session_state["architecture"] = "A"
+
     display_sidebar()
 
-    if(st.session_state.chat_history):
+    if st.session_state.chat_history:
         display_chat_history()
     
     query = st.chat_input("Posez votre question ici:")
     if query:
-        if architecture == "Intermédiaire":
-            architecture = "B"
-        elif architecture == "Avancée":
-            architecture = "C"
-        else:
-            architecture = "A"
-
-        process_query(query, architecture)
+        process_query(query, st.session_state["architecture"])
 
            
 def calculate_tokens_cost():
@@ -290,6 +307,12 @@ def initialize_conversation():
         'output_tokens': 0,
         'total_tokens': 0
     }
+    if "k" not in st.session_state:
+        st.session_state['k'] = 30  # Valeur par défaut pour k
+    if "similarity_threshold" not in st.session_state:
+        st.session_state['similarity_threshold'] = 0.7  # Valeur par défaut pour similarity_threshold
+    if "alpha" not in st.session_state:
+        st.session_state['alpha'] = 0.5 
     calculate_tokens_cost()
 
 

graph_agentA.py

@@ -4,6 +4,7 @@ from langgraph.graph import StateGraph, END
 from langgraph.graph.message import add_messages
 from config import llm, client, langsmith_project
 from pinecone_utilsA import *
+import streamlit as st
 
 # Graph state definition
 class GraphState(TypedDict):
@@ -11,6 +12,8 @@ class GraphState(TypedDict):
     query: str
     relevant_docs: list
     response: str
+    k: int 
+    similarity_threshold: float
 
 def generate_response(state: GraphState) -> dict:
     """Generate a response using the LLM."""
@@ -33,9 +36,11 @@ def post_process_response(state: GraphState) -> dict:
     response = state["response"].strip() if isinstance(state["response"], str) else state["response"]
     return {"response": response}
 
+k = st.session_state.get("k", 30)  # Valeur par défaut 30
+similarity_threshold = st.session_state.get('similarity_threshold', 0.7)  # Valeur par défaut 0.7
 # Build the graph
 graph_builder = StateGraph(GraphState)
-graph_builder.add_node("retrieve", lambda state: {"relevant_docs": retrieve_documents(state["query"])})
+graph_builder.add_node("retrieve", lambda state: {"relevant_docs": retrieve_documents(state["query"], k=k, similarity_threshold=similarity_threshold)})
 graph_builder.add_node("generate", generate_response)
 graph_builder.add_node("post_process", post_process_response)
 

graph_agentB.py

@@ -22,7 +22,9 @@ def retrieve_combined(state: GraphState) -> dict:
     alpha = st.session_state.get("alpha", 0.5)  # Valeur par défaut 0.5
     similarity_threshold = st.session_state.get('similarity_threshold', 0.7)  # Valeur par défaut 0.7
 
-
+    print(f"k: {k}")
+    print(f"similarity_threshold: {similarity_threshold}")
+    print(f"alpha: {alpha}")
     relevant_docs = hybrid_search(state["query"], alpha=alpha, k=k, similarity_threshold=similarity_threshold)
     return {"relevant_docs": relevant_docs}
 

pinecone_utilsA.py

@@ -71,16 +71,23 @@ def index_pdf(texts):
             indexA.upsert([(f"vec_{i}_{j}", vector.tolist(), metadata)])
             print(f"Indexation réussie pour le morceau '{small_chunk[:2000]}...'")
 
-def retrieve_documents(query):
+def retrieve_documents(query, k, similarity_threshold):
     """Récupère les documents pertinents en fonction de la requête."""
     model = SentenceTransformer('intfloat/multilingual-e5-large')
     query_vector = model.encode([query]).tolist()[0]
-    results = indexA.query(vector=query_vector, top_k=5, include_metadata=True)
+    results = indexA.query(
+        vector=query_vector,
+        top_k=k, 
+        include_metadata=True
+        )
+
     relevant_docs = []
     for match in results.get("matches", []):
         if "metadata" in match and "compressed_text" in match["metadata"]:
-            compressed_text = match["metadata"]["compressed_text"]
-            relevant_docs.append(decompress_text(compressed_text))
+            score = match.get("score", 0)  # Score de similarité
+            if score >= similarity_threshold:  # Filtrer par seuil
+                compressed_text = match["metadata"]["compressed_text"]
+                relevant_docs.append(decompress_text(compressed_text))
         else:
             print(f"Skipping match due to missing metadata or compressed_text: {match}")
     return relevant_docs