first commit

Dockerfile

@@ -0,0 +1,16 @@
+# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
+# you will also find guides on how best to write your Dockerfile
+
+FROM python:3.11-slim
+
+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", "app:app", "--host", "0.0.0.0", "--port", "7860"]

core/config.py

@@ -0,0 +1,22 @@
+from pymongo import MongoClient
+from openai import OpenAI, AzureOpenAI
+
+# ======================================================
+# CONFIGURATION
+# ======================================================
+
+# MongoDB
+MONGO_DATABASE_HOST = "mongodb+srv://amine_samet:EIh1QIyku8XkPYbC@cluster0.i49qxwt.mongodb.net/"
+client_mongo = MongoClient(MONGO_DATABASE_HOST)
+db = client_mongo["douane_db"]
+collection = db["douane_code"]
+
+# Azure OpenAI
+endpoint = "https://doaune-bot-resource.openai.azure.com/"
+embedding_model = "text-embedding-ada-002"
+chat_model = "gpt-5-chat"
+api_key = "EzmggLQfoyuWspgg6vAqPIuqktHKgsgmF566qGMc2RliAgLZV7lbJQQJ99BKACfhMk5XJ3w3AAAAACOGRxGE"
+api_version = "2024-12-01-preview"
+
+client_embedding = OpenAI(base_url=f"{endpoint}openai/v1/", api_key=api_key)
+client_chat = AzureOpenAI(api_version=api_version, azure_endpoint=endpoint, api_key=api_key)

core/llm.py

@@ -0,0 +1,166 @@
+import langdetect
+from core.config import client_chat, chat_model
+from core.memory import get_messages_for_session, add_message_to_session
+
+def generate_synthesized_llm_response_with_sources(question: str, top_articles, web_results: dict, session_id: str):
+    """
+    Génère une réponse synthétique avec mémoire de conversation et articles pertinents.
+    Historique stocké sous forme de dictionnaires plats pour éviter les erreurs de schéma.
+    """
+
+    # ============================
+    # Détection de la langue
+    # ============================
+    try:
+        lang = langdetect.detect(question)
+    except:
+        lang = "fr"
+
+    if question.strip().lower() in ["hello", "hi", "hey", "good morning", "good afternoon"]:
+        lang = "en"
+
+   
+    messages_history = get_messages_for_session(session_id)  
+
+    history_text = ""
+    for msg in messages_history:
+        role = msg.get("type", "human")
+        role_str = "Utilisateur" if role in ["human", "user"] else "Assistant"
+        history_text += f"{role_str}: {msg.get('content','')}\n"
+
+    context = "\n\n".join([
+        f"{doc['article_num']} : {doc['article_text']} (Source: Code des Douanes tunisien)"
+        for doc, _ in top_articles
+    ])
+
+    web_text = ""
+    if web_results:
+        if lang == "fr":
+            web_text += "\n\nInformations complémentaires :\n"
+        else:
+            web_text += "\n\nAdditional information:\n"
+        for missing_aspect, urls in web_results.items():
+            web_text += f"- {missing_aspect} : sources -> {', '.join(urls)}\n"
+        web_text += (
+            "\n⚠️ Ces informations doivent être vérifiées auprès d'une source officielle."
+            if lang == "fr"
+            else "\n⚠️ Information must be verified with official sources."
+        )
+
+    if lang == "fr":
+       prompt_text = f"""
+Tu es un assistant juridique intelligent spécialisé en droit douanier tunisien.
+
+Ta mission principale :
+Aider l’utilisateur à comprendre et appliquer correctement le Code des Douanes tunisien ainsi que les textes d’application associés.
+
+------------------------------------------------------------
+RÈGLES DE RAISONNEMENT ET DE RÉPONSE
+------------------------------------------------------------
+1. Analyse sémantique :
+   - Comprends le sens global et l’intention réelle du message, pas seulement les mots utilisés.
+   - Si le message contient une salutation, un remerciement ou une reprise de conversation, réponds de manière naturelle, polie et contextuelle.
+
+2. Contenu juridique :
+   - Si la question est juridique ou douanière, rédige une réponse claire, structurée et précise.
+   - Appuie-toi sur le Code des Douanes tunisien et les articles pertinents.
+   - Reformule toujours les textes légaux, ne copie jamais un article intégralement.
+   - Cite les références de manière correcte (exemple : Art. 123 du Code des douanes tunisien).
+
+3. Explication pédagogique :
+   - Si la demande est une explication, illustre avec des exemples pratiques adaptés au contexte tunisien.
+   - Reste toujours professionnel, rigoureux et accessible.
+
+4. Structure de réponse attendue :
+   - Titre clair indiquant le thème principal
+   - Explication juridique détaillée avec références
+   - Exemple ou cas concret
+   - Synthèse finale (maximum 5 lignes) résumant les points essentiels
+
+------------------------------------------------------------
+CONTEXTE CONVERSATIONNEL
+------------------------------------------------------------
+Historique de la conversation :
+{history_text}
+
+Question de l'utilisateur :
+{question}
+
+Articles pertinents :
+{context}
+
+Informations issues du web :
+{web_text}
+
+------------------------------------------------------------
+TÂCHE FINALE
+------------------------------------------------------------
+Fournis une réponse complète, contextualisée et conforme au droit douanier tunisien actuel.
+"""
+    else:
+        prompt_text = f"""
+You are an intelligent legal assistant specialized in Tunisian Customs Law.
+
+Your main mission:
+Help the user understand and correctly apply the Tunisian Customs Code and its related regulations.
+
+------------------------------------------------------------
+REASONING AND RESPONSE RULES
+------------------------------------------------------------
+1. Semantic understanding:
+   - Focus on the overall meaning and intent of the user’s message, not only the keywords.
+   - If the message is a greeting, thank you, or conversation restart, reply naturally, politely, and contextually.
+
+2. Legal content:
+   - If the question is legal or customs-related, provide a clear, structured, and accurate explanation.
+   - Base your reasoning on the Tunisian Customs Code and relevant articles.
+   - Always paraphrase legal texts; never copy them verbatim.
+   - Cite references properly (example: Art. 123 of the Tunisian Customs Code).
+
+3. Pedagogical clarity:
+   - If it’s an explanatory request, provide practical examples relevant to the Tunisian context.
+   - Maintain a professional, rigorous, and accessible tone.
+
+4. Expected response structure:
+   - Clear title indicating the main topic
+   - Detailed legal explanation with references
+   - Example or concrete illustration
+   - Final summary (maximum 5 lines) highlighting key points
+
+------------------------------------------------------------
+CONVERSATION CONTEXT
+------------------------------------------------------------
+Conversation history:
+{history_text}
+
+User question:
+{question}
+
+Relevant articles:
+{context}
+
+Web context:
+{web_text}
+
+------------------------------------------------------------
+FINAL TASK
+------------------------------------------------------------
+Provide a complete, contextualized, and accurate answer based on Tunisian Customs Law.
+"""
+
+    response = client_chat.chat.completions.create(
+        model=chat_model,
+        messages=[
+            {"role": "system", "content": "You are a helpful and context-aware assistant specialized in Tunisian customs law."},
+            {"role": "user", "content": prompt_text}
+        ],
+        max_tokens=1300,
+        temperature=0.3
+    )
+
+    answer = response.choices[0].message.content
+
+    add_message_to_session(session_id, {"type": "human", "content": question})
+    add_message_to_session(session_id, {"type": "ai", "content": answer})
+
+    return answer, top_articles

core/memory.py

@@ -0,0 +1,200 @@
+from pymongo import MongoClient
+from datetime import datetime, timezone
+from core.config import MONGO_DATABASE_HOST
+import uuid
+import json
+import re
+from langchain_mongodb import MongoDBChatMessageHistory
+
+
+def normalize_message(msg):
+    """Normalise les messages pour LangChain/Streamlit."""
+    if isinstance(msg, dict):
+        if "data" in msg and "content" in msg["data"]:
+            return {"type": msg.get("type", "human"), "content": msg["data"]["content"]}
+        elif "type" in msg and "content" in msg:
+            return {"type": msg["type"], "content": msg["content"]}
+    return None
+
+
+STOP_WORDS = {
+    "je", "tu", "il", "elle", "on", "nous", "vous", "ils", "elles",
+    "le", "la", "les", "un", "une", "des", "de", "du", "et", "en", "à",
+    "pour", "comment", "quoi", "où", "qui", "que", "dans"
+}
+
+def generate_session_title(first_message: str) -> str:
+    """Génère un titre cohérent à partir du premier message."""
+    # Nettoyage du texte
+    text = re.sub(r"[^a-zA-ZÀ-ÿ0-9\s]", "", first_message.lower())
+    words = text.strip().split()
+    keywords = [w for w in words if w not in STOP_WORDS]
+
+    if not keywords:
+        return "Nouvelle session"
+
+    # Prendre les 3-5 premiers mots clés pour le titre
+    title_words = keywords[:5]
+    # Capitaliser les mots
+    title = " ".join(w.capitalize() for w in title_words)
+    
+
+    return title
+
+
+def load_all_sessions():
+    """Charge toutes les sessions depuis MongoDB existantes."""
+    client = MongoClient(MONGO_DATABASE_HOST)
+    db = client["douane_db"]
+    collection = db["chat_history"]
+
+    all_sessions = {}
+    for doc in collection.find():
+        session_id = doc.get("SessionId") or str(doc.get("_id"))
+        try:
+            raw_messages = json.loads(doc.get("History", "[]"))
+            if isinstance(raw_messages, dict):
+                raw_messages = [raw_messages]
+            messages = [normalize_message(m) for m in raw_messages if normalize_message(m)]
+        except Exception:
+            messages = []
+
+        if not messages:
+            continue
+
+        created_at = doc.get("created_at") or doc["_id"].generation_time
+        if created_at and created_at.tzinfo is None:
+            created_at = created_at.replace(tzinfo=timezone.utc)
+
+        all_sessions[session_id] = {
+            "title": doc.get("title", "Session sans titre"),
+            "history": messages,
+            "created_at": created_at
+        }
+
+    return dict(sorted(all_sessions.items(), key=lambda x: x[1]["created_at"], reverse=True))
+
+
+def start_new_session(session_state: dict) -> str:
+    """Crée un nouvel ID de session en mémoire, pas encore dans MongoDB."""
+    session_id = f"session_{uuid.uuid4()}"
+    session_state["session_id"] = session_id
+    session_state["sessions"][session_id] = {
+        "history": [],
+        "created_at": datetime.now(timezone.utc),
+        "title": "Nouvelle session"
+    }
+    return session_id
+
+
+def add_message_to_session(session_id: str, message: dict):
+    """
+    Ajoute un message dans MongoDB.
+    Si c’est le premier message de la session, crée la session et génère un titre.
+    """
+    if "data" in message and "content" in message["data"]:
+        msg = {"type": message.get("type", "human"), "content": message["data"]["content"]}
+    elif "type" in message and "content" in message:
+        msg = {"type": message["type"], "content": message["content"]}
+    else:
+        return
+
+    client = MongoClient(MONGO_DATABASE_HOST)
+    db = client["douane_db"]
+    collection = db["chat_history"]
+
+    session = collection.find_one({"SessionId": session_id})
+
+    if session:
+        try:
+            history = json.loads(session.get("History", "[]"))
+            if isinstance(history, dict):
+                history = [history]
+            elif not isinstance(history, list):
+                history = []
+        except:
+            history = []
+
+        history.append(msg)
+        collection.update_one(
+            {"SessionId": session_id},
+            {"$set": {"History": json.dumps(history)}}
+        )
+    else:
+        title = generate_session_title(msg["content"])
+        collection.insert_one({
+            "SessionId": session_id,
+            "title": title,
+            "History": json.dumps([msg]),
+            "created_at": datetime.now(timezone.utc)
+        })
+
+
+def rename_session(session_id: str, new_title: str):
+    """Renommer manuellement une session."""
+    client = MongoClient(MONGO_DATABASE_HOST)
+    db = client["douane_db"]
+    collection = db["chat_history"]
+    collection.update_one({"SessionId": session_id}, {"$set": {"title": new_title}})
+
+
+def update_session_title(session_id: str):
+    """
+    Si la session n’a pas de titre ou a un titre générique, 
+    on le met à jour avec le titre généré à partir du premier message.
+    """
+    client = MongoClient(MONGO_DATABASE_HOST)
+    db = client["douane_db"]
+    collection = db["chat_history"]
+
+    session = collection.find_one({"SessionId": session_id})
+    if not session:
+        return
+
+    title = session.get("title", "")
+    if title.strip() in ["", "Nouvelle session", "Session sans titre"]:
+        try:
+            history = json.loads(session.get("History", "[]"))
+            if isinstance(history, dict):
+                history = [history]
+        except:
+            history = []
+
+        if history:
+            first_message = history[0].get("content", "")
+            if first_message:
+                new_title = generate_session_title(first_message)
+                collection.update_one(
+                    {"SessionId": session_id},
+                    {"$set": {"title": new_title}}
+                )
+
+
+def get_messages_for_session(session_id: str):
+    """Récupère les messages depuis MongoDB, vide si session pas encore créée."""
+    client = MongoClient(MONGO_DATABASE_HOST)
+    db = client["douane_db"]
+    collection = db["chat_history"]
+
+    doc = collection.find_one({"SessionId": session_id})
+    if not doc:
+        return []
+
+    try:
+        raw_history = json.loads(doc.get("History", "[]"))
+        if isinstance(raw_history, dict):
+            raw_history = [raw_history]
+    except:
+        raw_history = []
+
+    messages = [normalize_message(m) for m in raw_history if normalize_message(m)]
+    return messages
+
+
+def get_session_history(session_id: str) -> MongoDBChatMessageHistory:
+    return MongoDBChatMessageHistory(
+        connection_string=MONGO_DATABASE_HOST,
+        session_id=session_id,
+        database_name="douane_db",
+        collection_name="chat_history"
+    )

core/retrieval.py

@@ -0,0 +1,39 @@
+import re
+from sklearn.metrics.pairwise import cosine_similarity
+from core.config import collection, client_embedding, embedding_model
+
+def get_query_embedding(query: str):
+    """Retourne l'embedding de la requête"""
+    response = client_embedding.embeddings.create(input=query, model=embedding_model)
+    return response.data[0].embedding
+
+def extract_article_number(query: str):
+    """Extrait le numéro d'article explicitement mentionné"""
+    match = re.search(r'article\s*(\w+)', query, re.IGNORECASE)
+    if match:
+        word = match.group(1).lower()
+        if word == "premier":
+            return "Article premier"
+        elif word.isdigit():
+            return f"Article {word}"
+    return None
+
+def find_relevant_articles(query: str, threshold: float = 0.8, max_articles: int = 10):
+    """Trouve les articles les plus similaires à la requête"""
+    article_num = extract_article_number(query)
+    if article_num:
+        doc = collection.find_one({"article_num": article_num})
+        if doc:
+            return [(doc, 1.0)]
+
+    query_vector = get_query_embedding(query)
+    similarities = []
+    for doc in collection.find():
+        article_vector = doc.get("embedding2")
+        if article_vector:
+            sim = cosine_similarity([query_vector], [article_vector])[0][0]
+            if sim >= threshold:
+                similarities.append((doc, sim))
+
+    similarities.sort(key=lambda x: x[1], reverse=True)
+    return similarities[:max_articles]

main.py

@@ -0,0 +1,171 @@
+# ======================================
+# main.py – FastAPI pour chatbot douanier 🇹🇳
+# ======================================
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional, List, Dict
+import uuid
+import uvicorn
+
+# Import des modules internes
+from core.retrieval import find_relevant_articles
+from core.llm import generate_synthesized_llm_response_with_sources
+from core.memory import (
+    start_new_session,
+    add_message_to_session,
+    rename_session,
+    update_session_title,
+    get_messages_for_session,
+    load_all_sessions
+)
+
+# ======================================================
+# CONFIGURATION DE L'APPLICATION
+# ======================================================
+
+app = FastAPI(title="Chatbot Douane API 🇹🇳")
+
+# CORS (pour permettre les requêtes depuis un frontend)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"]
+)
+
+# ----------------------------
+# Pydantic models
+# ----------------------------
+
+class MessageData(BaseModel):
+    type: Optional[str] = "human"
+    content: str
+
+class AddMessageRequest(BaseModel):
+    session_id: str
+    message: MessageData
+
+class RenameSessionRequest(BaseModel):
+    session_id: str
+    new_title: str
+
+class NewSessionResponse(BaseModel):
+    session_id: str
+
+class ChatRequest(BaseModel):
+    question: str
+    session_id: Optional[str] = None
+    web_results: Optional[Dict] = None
+
+class ChatResponse(BaseModel):
+    session_id: str
+    answer: str
+    articles_found: List[Dict]
+
+# ----------------------------
+# Session endpoints
+# ----------------------------
+
+@app.get("/sessions")
+def get_all_sessions():
+    """Return all sessions with their titles and creation date."""
+    sessions = load_all_sessions()
+    return sessions
+
+@app.post("/sessions/new", response_model=NewSessionResponse)
+def create_session():
+    """Create a new session and return its ID."""
+    session_state = {"sessions": {}}
+    session_id = start_new_session(session_state)
+    return {"session_id": session_id}
+
+@app.post("/sessions/add_message")
+def add_message(req: AddMessageRequest):
+    """Add a message to a session."""
+    try:
+        add_message_to_session(req.session_id, req.message.dict())
+        return {"status": "success"}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.post("/sessions/rename")
+def rename(req: RenameSessionRequest):
+    """Rename a session manually."""
+    try:
+        rename_session(req.session_id, req.new_title)
+        return {"status": "success"}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.post("/sessions/update_title/{session_id}")
+def update_title(session_id: str):
+    """Update session title automatically based on first message."""
+    try:
+        update_session_title(session_id)
+        return {"status": "success"}
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+@app.get("/sessions/{session_id}/messages")
+def get_messages(session_id: str):
+    """Get all messages for a given session."""
+    try:
+        messages = get_messages_for_session(session_id)
+        return messages
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+# ----------------------------
+# Chatbot endpoint
+# ----------------------------
+
+@app.post("/chat", response_model=ChatResponse)
+def chat_with_bot(request: ChatRequest):
+    """
+    Envoie une question au chatbot douanier.
+    - Recherche les articles pertinents
+    - Génère la réponse à l’aide du LLM
+    - Sauvegarde l’historique dans MongoDB
+    """
+    try:
+        # Si pas de session fourni, créer un nouvel ID
+        session_id = request.session_id or f"session_{uuid.uuid4()}"
+
+        # Récupérer les articles pertinents
+        top_articles = find_relevant_articles(request.question)
+
+        # Générer la réponse via LLM
+        answer, _ = generate_synthesized_llm_response_with_sources(
+            question=request.question,
+            top_articles=top_articles,
+            web_results=request.web_results or {},
+            session_id=session_id
+        )
+
+        # Format des articles
+        articles = [
+            {
+                "article_num": doc.get("article_num"),
+                "similarity": round(sim, 3)
+            }
+            for doc, sim in top_articles
+        ]
+
+        # Retour API
+        return ChatResponse(
+            session_id=session_id,
+            answer=answer,
+            articles_found=articles
+        )
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# ======================================================
+# LANCEMENT LOCAL
+# ======================================================
+
+if __name__ == "__main__":
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

requirements.txt

@@ -0,0 +1,80 @@
+altair==5.5.0
+annotated-types==0.7.0
+anyio==4.11.0
+attrs==25.4.0
+blinker==1.9.0
+cachetools==6.2.1
+certifi==2025.10.5
+charset-normalizer==3.4.4
+click==8.3.0
+colorama==0.4.6
+distro==1.9.0
+dnspython==2.8.0
+gitdb==4.0.12
+gitpython==3.1.45
+h11==0.16.0
+httpcore==1.0.9
+httpx==0.28.1
+idna==3.11
+jinja2==3.1.6
+jiter==0.11.1
+joblib==1.5.2
+jsonpatch==1.33
+jsonpointer==3.0.0
+jsonschema==4.25.1
+jsonschema-specifications==2025.9.1
+langchain==1.0.3
+langchain-core==1.0.2
+langchain-mongodb==0.7.1
+langchain-openai==1.0.1
+langchain-text-splitters==1.0.0
+langdetect==1.0.9
+langgraph==1.0.2
+langgraph-checkpoint==3.0.0
+langgraph-prebuilt==1.0.2
+langgraph-sdk==0.2.9
+langsmith==0.4.39
+lark==1.3.1
+markupsafe==3.0.3
+narwhals==2.10.1
+numpy==2.3.4
+openai==2.6.1
+orjson==3.11.4
+ormsgpack==1.11.0
+packaging==25.0
+pandas==2.3.3
+pillow==12.0.0
+protobuf==6.33.0
+pyarrow==21.0.0
+pydantic==2.12.3
+pydantic-core==2.41.4
+pydeck==0.9.1
+pymongo==4.15.3
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.1
+pytz==2025.2
+pyyaml==6.0.3
+referencing==0.37.0
+regex==2025.10.23
+requests==2.32.5
+requests-toolbelt==1.0.0
+rpds-py==0.28.0
+scikit-learn==1.7.2
+scipy==1.16.3
+six==1.17.0
+smmap==5.0.2
+sniffio==1.3.1
+streamlit==1.51.0
+tenacity==9.1.2
+threadpoolctl==3.6.0
+tiktoken==0.12.0
+toml==0.10.2
+tornado==6.5.2
+tqdm==4.67.1
+typing-extensions==4.15.0
+typing-inspection==0.4.2
+tzdata==2025.2
+urllib3==2.5.0
+watchdog==6.0.0
+xxhash==3.6.0
+zstandard==0.25.0