Upload 7 files

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.12
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,11 +1,12 @@
 ---
-title: Chatbot Nsi 8b
+title: Chatbot Nsi V2
 emoji: 🌖
-colorFrom: gray
-colorTo: red
+colorFrom: indigo
+colorTo: blue
 sdk: docker
 pinned: false
-license: apache-2.0
+license: cc
+short_description: chatbot for education
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

documents/programme_NSI_premiere.md

@@ -0,0 +1,184 @@
+## NSI programme de la classe de première
+
+### Rubrique transversale de l’histoire de l’informatique
+
+- **Événements clés de l’histoire de l’informatique**
+  - Situer dans le temps les principaux événements de l’histoire de l’informatique et leurs protagonistes.
+    > Ces repères historiques seront construits au fur et à mesure de la présentation des concepts et techniques. [commentaire]
+
+### Représentation des données : types et valeurs de base
+
+- **Écriture d’un entier positif dans une base b⩾2**
+  - Passer de la représentation d’une base dans une autre.
+    > Les bases 2, 10 et 16 sont privilégiées. [commentaire]
+- **Représentation binaire d’un entier relatif**
+  - Évaluer le nombre de bits nécessaires à l’écriture en base 2 d’un entier, de la somme ou du produit de deux nombres entiers.
+    > Il s’agit de décrire les tailles courantes des entiers (8, 16, 32 ou 64 bits). [commentaire]
+    >
+    > Il est possible d’évoquer la représentation des entiers de taille arbitraire de Python. [commentaire]
+  - Utiliser le complément à 2.
+- **Représentation approximative des nombres réels : notion de nombre flottant**
+  - Calculer sur quelques exemples la représentation de nombres réels : `0.1`, `0.25` ou $1/3$.
+    > `0.2 + 0.1` n’est pas égal à `0.3`. [commentaire]
+    >
+    > Il faut éviter de tester l’égalité de deux flottants. [commentaire]
+    >
+    > Aucune connaissance précise de la norme IEEE-754 n’est exigible. [commentaire]
+- **Valeurs booléennes : `0`, `1`.**
+- **Opérateurs booléens : `and`, `or`, `not`.**
+  > Le ou exclusif (`xor`) est évoqué. [commentaire]
+  >
+  > Quelques applications directes comme l’addition binaire sont présentées. [commentaire]
+  >
+  > L’attention des élèves est attirée sur le caractère séquentiel de certains opérateurs booléens. [commentaire]
+- **Expressions booléennes**
+  - Dresser la table d’une expression booléenne.
+- **Représentation d’un texte en machine.**
+- **Exemples des encodages ASCII, ISO-8859-1, Unicode**
+  - Identifier l’intérêt des différents systèmes d’encodage.
+    > Aucune connaissance précise des normes d’encodage n’est exigible. [commentaire]
+  - Convertir un fichier texte dans différents formats d’encodage.
+
+### Représentation des données : types construits
+
+- **p-uplets.**
+  - Écrire une fonction renvoyant un p-uplet de valeurs.
+- **p-uplets nommés**
+  - Écrire une fonction renvoyant un p-uplet de valeurs.
+- **Tableau indexé, tableau donné en compréhension**
+  > Seuls les tableaux dont les éléments sont du même type sont présentés. [commentaire]
+  >
+  > L’aspect dynamique des tableaux de Python n’est pas évoqué. [commentaire]
+  >
+  > Python identifie listes et tableaux. [commentaire]
+  >
+  > Il n’est pas fait référence aux tableaux de la bibliothèque NumPy. [commentaire]
+  - Lire et modifier les éléments d’un tableau grâce à leurs index.
+    > Aucune connaissance des tranches (slices) n’est exigible. [commentaire]
+  - Construire un tableau par compréhension.
+  - Utiliser des tableaux de compréhension tableaux pour représenter des matrices : notation `a[i][j]`.
+  - Itérer sur les éléments d’un tableau.
+- **Dictionnaires par clés et valeurs**
+  - Construire une entrée de dictionnaire.
+    > En Python, les p-uplets nommés sont implémentés par des dictionnaires. [commentaire]
+  - Itérer sur les éléments d’un dictionnaire.
+    > Il est possible de présenter les données EXIF d’une image sous la forme d’un enregistrement. [commentaire]
+    >
+    > Utiliser les méthodes `keys()`, `values()` et `items()`. [commentaire]
+
+### Traitement de données en tables
+
+- **Indexation de tables**
+  - Importer une table depuis un fichier texte tabulé ou un fichier CSV.
+    > Est utilisé un tableau doublement indexé ou un tableau de p-uplets qui partagent les mêmes descripteurs. [commentaire]
+- **Recherche dans une table**
+  - Rechercher les lignes d’une table vérifiant des critères exprimés en logique propositionnelle.
+    > La recherche de doublons, les tests de cohérence d’une table sont présentés. [commentaire]
+- **Tri d’une table**
+  - Trier une table suivant une colonne.
+    > Une fonction de tri intégrée au système ou à une bibliothèque peut être utilisée. [commentaire]
+- **Fusion de tables**
+  - Construire une nouvelle table en combinant les données de deux tables.
+    > La notion de domaine de valeurs est mise en évidence. [commentaire]
+
+### Interactions entre l’homme et la machine sur le Web
+
+- **Modalités de l’interaction entre l’homme et la machine**
+  - Identifier les différents composants graphiques permettant d’interagir avec une application Web.
+    > Il s’agit d’examiner le code HTML d’une page comprenant des composants graphiques et de distinguer ce qui relève de la description des composants graphiques en HTML de leur comportement (réaction aux événements) programmé par exemple en JavaScript. [commentaire]
+- **Événements**
+  - Identifier les événements que les fonctions associées aux différents composants graphiques sont capables de traiter.
+- **Interaction avec l’utilisateur dans une page Web**
+  - Analyser et modifier les méthodes exécutées lors d’un clic sur un bouton d’une page Web.
+- **Interaction client-serveur.**
+  - Distinguer ce qui est exécuté sur le client ou sur le serveur et dans quel ordre.
+- **Requêtes HTTP, réponses du serveur**
+  > Il s’agit de faire le lien avec ce qui a été vu en classe de seconde et d’expliquer comment on peut passer des paramètres à un site grâce au protocole HTTP. [commentaire]
+  - Distinguer ce qui est mémorisé dans le client et retransmis au serveur.
+  - Reconnaître quand et pourquoi la transmission est chiffrée.
+- **Formulaire d’une page Web**
+  - Analyser le fonctionnement d’un formulaire simple.
+  - Distinguer les transmissions de paramètres par les requêtes POST ou GET.
+    > Discuter les deux types de requêtes selon le type des valeurs à transmettre et/ou leur confidentialité. [commentaire]
+
+### Architectures matérielles et systèmes d’exploitation
+
+- **Modèle d’architecture séquentielle (von Neumann)**
+  > La présentation se limite aux concepts généraux. [commentaire]
+  - Distinguer les rôles et les caractéristiques des différents constituants d’une machine.
+    > On distingue les architectures monoprocesseur et les architectures multiprocesseur. [commentaire]
+    >
+    > Des activités débranchées sont proposées. [commentaire]
+  - Dérouler l’exécution d’une séquence d’instructions simples du type langage machine.
+    > Les circuits combinatoires réalisent des fonctions booléennes. [commentaire]
+- **Transmission de données dans un réseau**
+  - Mettre en évidence l’intérêt du découpage des données en paquets et de leur encapsulation.
+- **Protocoles de communication**
+  - Dérouler le fonctionnement d’un protocole simple de récupération de perte de paquets (bit alterné).
+    > Le protocole peut être expliqué et simulé en mode débranché. [commentaire]
+    >
+    > Le lien est fait avec ce qui a été vu en classe de seconde sur le protocole TCP/IP. [commentaire]
+- **Architecture d’un réseau**
+  - Simuler ou mettre en œuvre un réseau.
+    > Le rôle des différents constituants du réseau local de l’établissement est présenté. [commentaire]
+- **Systèmes d’exploitation**
+  - Identifier les fonctions d’un système d’exploitation.
+    > Les différences entre systèmes d’exploitation libres et propriétaires sont évoquées. [commentaire]
+    >
+    > Il ne s’agit pas d’une étude théorique des systèmes d’exploitation. [commentaire]
+  - Utiliser les commandes de base en ligne de commande.
+    > Les élèves utilisent un système d’exploitation libre. [commentaire]
+  - Gérer les droits et permissions d’accès aux fichiers.
+- **Interface Homme-Machine (IHM) et périphériques d’entrée et de sortie [reformulé, ndr]**
+  - Identifier le rôle des capteurs et actionneurs.
+  - Réaliser par programmation une IHM répondant à un cahier des charges donné.
+    > Les activités peuvent être développées sur des objets connectés, des systèmes embarqués ou robots. [commentaire]
+
+### Langages et programmation
+
+- **Constructions élémentaires**
+  - Mettre en évidence un corpus de constructions élémentaires.
+    > Séquences, affectation, conditionnelles, boucles bornées, boucles non bornées, appels de fonction. [commentaire]
+- **Diversité et unité des langages de programmation**
+  - Repérer, dans un nouveau langage de programmation, les traits communs et les traits particuliers à ce langage.
+    > Les manières dont un même programme simple s’écrit dans différents langages sont comparées. [commentaire]
+- **Spécification**
+  - Prototyper une fonction.
+  - Décrire les préconditions sur les arguments.
+  - Décrire des postconditions sur les résultats.
+  > Des assertions peuvent être utilisées pour garantir des préconditions ou des postconditions. [commentaire]
+- **Mise au point de programmes**
+  - Utiliser des jeux de tests.
+    > L’importance de la qualité et du nombre des tests est mise en évidence. [commentaire]
+    >
+    > Le succès d’un jeu de tests ne garantit pas la correction d’un programme. [commentaire]
+- **Utilisation de bibliothèques**
+  - Utiliser la documentation d’une bibliothèque.
+    > Aucune connaissance exhaustive d’une bibliothèque particulière n’est exigible. [commentaire]
+
+### Algorithmique
+
+- **Parcours séquentiel d’un tableau**
+  > On montre que le coût est linéaire. [commentaire]
+  - Écrire un algorithme de recherche d’une occurrence sur des valeurs de type quelconque.
+  - Écrire un algorithme de recherche d’un extremum, de calcul d’une moyenne.
+- **Tris par insertion, par sélection**
+  > La terminaison de ces algorithmes est à justifier. [commentaire]
+  >
+  > On montre que leur coût est quadratique dans le pire cas. [commentaire]
+  - Écrire un algorithme de tri.
+  - Décrire un invariant de boucle qui prouve la correction des tris par insertion, par sélection.
+- **Algorithme des k plus proches voisins**
+  - Écrire un algorithme qui prédit la classe d’un élément en fonction de la classe majoritaire de ses k plus proches voisins.
+    > Il s’agit d’un exemple d’algorithme d’apprentissage. [commentaire]
+- **Recherche dichotomique dans un tableau trié**
+  - Montrer la terminaison de la recherche dichotomique à l’aide d’un variant de boucle.
+    > Des assertions peuvent être utilisées. [commentaire]
+    >
+    > La preuve de la correction peut être présentée par le professeur. [commentaire]
+- **Algorithmes gloutons**
+  - Résoudre un problème grâce à un algorithme glouton.
+    > Exemples : problèmes du sac à dos ou du rendu de monnaie. [commentaire]
+    >
+    > Les algorithmes gloutons constituent une méthode algorithmique parmi d’autres qui seront vues en terminale. [commentaire]
+

documents/programme_NSI_terminale.md

@@ -0,0 +1,140 @@
+## NSI programme de la classe de terminale
+
+### Rubrique transversale de l’histoire de l’informatique
+
+- **Événements clés de l’histoire de l’informatique.**
+  > Ces repères viennent compléter ceux qui ont été introduits en première. [commentaire]
+  >
+  > Ces repères historiques sont construits au fur et à mesure de la présentation des concepts et techniques. [commentaire]
+  - Situer dans le temps les principaux événements de l’histoire de l’informatique et leurs protagonistes.
+  - Identifier l’évolution des rôles relatifs des logiciels et des matériels.
+
+### Structures de données
+
+- **Structures de données, interface et implémentation.**
+  > L’abstraction des structures de données est introduite après plusieurs implémentations d’une structure simple comme la file (avec un tableau ou avec deux piles). [commentaire]
+  - Spécifier une structure de données par son interface.
+  - Distinguer interface et implémentation.
+  - Écrire plusieurs implémentations d’une même structure de données.
+- **Vocabulaire de la programmation objet : classes, attributs, méthodes, objets.**
+  > On n’aborde pas ici tous les aspects de la programmation objet comme le polymorphisme et l’héritage. [commentaire]
+  - Écrire la définition d’une classe.
+  - Accéder aux attributs et méthodes d’une classe.
+- **Listes, piles, files : structures linéaires.**
+  > On distingue les modes FIFO (*first in first out*) et LIFO (*last in first out*) des piles et des files. [commentaire]
+  - Distinguer des structures par le jeu des méthodes qui les caractérisent.
+  - Choisir une structure de données adaptée à la situation à modéliser.
+  - Distinguer la recherche d’une valeur dans une liste et dans un dictionnaire.
+- **Dictionnaires, index et clé.**
+  - Distinguer des structures par le jeu des méthodes qui les caractérisent.
+  - Choisir une structure de données adaptée à la situation à modéliser.
+  - Distinguer la recherche d’une valeur dans une liste et dans un dictionnaire.
+- **Arbres : structures hiérarchiques.**
+  > On fait le lien avec la rubrique « algorithmique ». [commentaire]
+  - Identifier des situations nécessitant une structure de données arborescente.
+- **Arbres binaires : nœuds, racines, feuilles, sous-arbres gauches, sous-arbres droits.**
+  - Évaluer quelques mesures des arbres binaires (taille, encadrement de la hauteur, etc.).
+- **Graphes : structures relationnelles.**
+  - Modéliser des situations sous forme de graphes.
+    > On s’appuie sur des exemples comme le réseau routier, le réseau électrique, Internet, les réseaux sociaux. [commentaire]
+- **Sommets, arcs, arêtes, graphes orientés ou non orientés.**
+  - Écrire les implémentations correspondantes d’un graphe : matrice d’adjacence, liste de successeurs/de prédécesseurs. Passer d’une représentation à une autre.
+    > Le choix de la représentation dépend du traitement qu’on veut mettre en place : on fait le lien avec la rubrique « algorithmique ». [commentaire]
+
+### Bases de données
+
+- **Modèle relationnel : relation, attribut, domaine, clef primaire, clef étrangère, schéma relationnel.**
+  - Identifier les concepts définissant le modèle relationnel.
+    > Ces concepts permettent d’exprimer les contraintes d’intégrité (domaine, relation et référence). [commentaire]
+- **Base de données relationnelle.**
+  > On privilégie la manipulation de données nombreuses et réalistes. [commentaire]
+  - Savoir distinguer la structure d’une base de données de son contenu.
+    > La structure est un ensemble de schémas relationnels qui respecte les contraintes du modèle relationnel. [commentaire]
+  - Repérer des anomalies dans le schéma d’une base de données.
+    > Les anomalies peuvent être des redondances de données ou des anomalies d’insertion, de suppression, de mise à jour. [commentaire]
+- **Système de gestion de bases de données relationnelles.**
+  - Identifier les services rendus par un système de gestion de bases de données relationnelles : persistance des données, gestion des accès concurrents, efficacité de traitement des requêtes, sécurisation des accès.
+    > Il s’agit de comprendre le rôle et les enjeux des différents services sans en détailler le fonctionnement. [commentaire]
+- **Langage SQL : requêtes d’interrogation et de mise à jour d’une base de données.**
+  - Identifier les composants d’une requête.
+  - Construire des requêtes d’interrogation à l’aide des clauses du langage SQL : `SELECT`, `FROM`, `WHERE`, `JOIN`.
+    > On peut utiliser `DISTINCT`, `ORDER BY` ou les fonctions d’agrégation sans utiliser les clauses `GROUP BY` et `HAVING`. [commentaire]
+  - Construire des requêtes d’insertion et de mise à jour à l’aide de : `UPDATE`, `INSERT`, `DELETE`.
+
+### Architectures matérielles, systèmes d’exploitation et réseaux
+
+- **Composants intégrés d’un système sur puce.**
+  - Identifier les principaux composants sur un schéma de circuit et les avantages de leur intégration en termes de vitesse et de consommation.
+    > Le circuit d’un téléphone peut être pris comme un exemple : microprocesseurs, mémoires locales, interfaces radio et filaires, gestion d’énergie, contrôleurs vidéo, accélérateur graphique, réseaux sur puce, etc. [commentaire]
+- **Gestion des processus et des ressources par un système d’exploitation.**
+  - Décrire la création d’un processus, l’ordonnancement de plusieurs processus par le système.
+    > À l’aide d’outils standard, il s’agit d’observer les processus actifs ou en attente sur une machine. [commentaire]
+  - Mettre en évidence le risque de l’interblocage (*deadlock*).
+    > Une présentation débranchée de l’interblocage peut être proposée. [commentaire]
+- **Protocoles de routage.**
+  - Identifier, suivant le protocole de routage utilisé, la route empruntée par un paquet.
+    > En mode débranché, les tables de routage étant données, on se réfère au nombre de sauts (protocole RIP) ou au coût des routes (protocole OSPF). [commentaire]
+    >
+    > Le lien avec les algorithmes de recherche de chemin sur un graphe est mis en évidence. [commentaire]
+- **Sécurisation des communications.**
+  - Décrire les principes de chiffrement symétrique (clef partagée) et asymétrique (avec clef privée/clef publique).
+    > Les protocoles symétriques et asymétriques peuvent être illustrés en mode débranché, éventuellement avec description d’un chiffrement particulier. [commentaire]
+  - Décrire l’échange d’une clef symétrique en utilisant un protocole asymétrique pour sécuriser une communication HTTPS.
+    > La négociation de la méthode chiffrement du protocole SSL (*Secure Sockets Layer*) n’est pas abordée. [commentaire]
+
+### Langages et programmation
+
+- **Notion de programme en tant que donnée.**
+  - Comprendre que tout programme est aussi une donnée.
+    > L’utilisation d’un interpréteur ou d’un compilateur, le téléchargement de logiciel, le fonctionnement des systèmes d’exploitation permettent de comprendre un programme comme donnée d’un autre programme. [commentaire]
+- **Calculabilité, décidabilité.**
+  - Comprendre que la calculabilité ne dépend pas du langage de programmation utilisé.
+  - Montrer, sans formalisme théorique, que le problème de l’arrêt est indécidable.
+- **Récursivité.**
+  - Écrire un programme récursif.
+  - Analyser le fonctionnement d’un programme récursif.
+    > Des exemples relevant de domaines variés sont à privilégier. [commentaire]
+- **Modularité.**
+  - Utiliser des API (Application Programming Interface) ou des bibliothèques [fusionné, ndr] [et] exploiter leur documentation.
+  - Créer des modules simples et les documenter.
+- **Paradigmes de programmation.**
+  - Distinguer sur des exemples les paradigmes impératif, fonctionnel et objet.
+  - Choisir le paradigme de programmation selon le champ d’application d’un programme.
+    > Avec un même langage de programmation, on peut utiliser des paradigmes différents. Dans un même programme, on peut utiliser des paradigmes différents. [commentaire]
+- **Mise au point des programmes.**
+  > On prolonge le travail entrepris en classe de première sur l’utilisation de la spécification, des assertions, de la documentation des programmes et de la construction de jeux de tests. [commentaire]
+- **Gestion des bugs.**
+  - Dans la pratique de la programmation, savoir répondre aux causes typiques de bugs : problèmes liés au typage, effets de bord non désirés, débordements dans les tableaux, instruction conditionnelle non exhaustive, choix des inégalités, comparaisons et calculs entre flottants, mauvais nommage des variables, etc.
+    > Les élèves apprennent progressivement à anticiper leurs erreurs. [commentaire]
+
+### Algorithmique
+
+- **Algorithmes sur les arbres binaires et sur les arbres binaires de recherche.**
+  > Une structure de données récursive adaptée est utilisée. [commentaire]
+  >
+  > L’exemple des arbres permet d’illustrer la programmation par classe. [commentaire]
+  - Calculer la taille et la hauteur d’un arbre.
+  - Parcourir un arbre de différentes façons (ordres infixe, préfixe ou suffixe ; ordre en largeur d’abord).
+  - Rechercher une clé dans un arbre de recherche, insérer une clé.
+    > La recherche dans un arbre de recherche équilibré est de coût logarithmique. [commentaire]
+- **Algorithmes sur les graphes.**
+  > L’exemple des graphes permet d’illustrer l’utilisation des classes en programmation. [commentaire]
+  - Parcourir un graphe en profondeur d’abord, en largeur d’abord.
+  - Repérer la présence d’un cycle dans un graphe.
+  - Chercher un chemin dans un graphe.
+    > Le parcours d’un labyrinthe et le routage dans Internet sont des exemples d’algorithme sur les graphes. [commentaire]
+- **Méthode « diviser pour régner ».**
+  - Écrire un algorithme utilisant la méthode « diviser pour régner ».
+    > La rotation d’une image bitmap d’un quart de tour avec un coût en mémoire constant est un bon exemple. [commentaire]
+    >
+    > L’exemple du tri fusion permet également d’exploiter la récursivité et d’exhiber un algorithme de coût en $n \log n$ dans les pires des cas. [commentaire]
+- **Programmation dynamique.**
+  - Utiliser la programmation dynamique pour écrire un algorithme.
+    > Les exemples de l’alignement de séquences ou du rendu de monnaie peuvent être présentés. [commentaire]
+    >
+    > La discussion sur le coût en mémoire peut être développée. [commentaire]
+- **Recherche textuelle.**
+  - Étudier l’algorithme de Boyer-Moore pour la recherche d’un motif dans un texte.
+    > L’intérêt du prétraitement du motif est mis en avant. [commentaire]
+    >
+    > L’étude du coût, difficile, ne peut être exigée. [commentaire]

main.py

@@ -0,0 +1,120 @@
+import os
+from dotenv import load_dotenv
+from langchain_core.output_parsers import StrOutputParser
+from langchain_groq import ChatGroq
+from langchain_core.prompts import ChatPromptTemplate
+from typing import List
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_chroma import Chroma
+from typing_extensions import TypedDict
+from typing import Annotated
+from langgraph.graph.message import AnyMessage, add_messages
+from langchain_core.messages import HumanMessage, AIMessage
+from langchain_community.document_loaders import DirectoryLoader
+from langchain_text_splitters import CharacterTextSplitter
+from langgraph.graph import END, StateGraph, START
+from langgraph.checkpoint.memory import MemorySaver
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class Request(BaseModel):
+    query : str
+    id : str
+
+load_dotenv()
+os.environ["GROQ_API_KEY"] = os.getenv('GROQ_API_KEY')
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+persist_directory = 'db'
+embedding = HuggingFaceEmbeddings(model_name="OrdalieTech/Solon-embeddings-large-0.1")
+llm = ChatGroq(model="llama-3.1-8b-instant", temperature=0.5)
+memory = MemorySaver()
+
+if  os.path.exists(persist_directory) :
+    vectordb = Chroma(persist_directory=persist_directory, embedding_function=embedding)
+else :
+    glob_pattern="./*.md"
+    directory_path = "./documents"
+    loader = DirectoryLoader(directory_path, glob=glob_pattern)
+    documents = loader.load()
+    text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+    texts = text_splitter.split_documents(documents)
+    vectordb = Chroma.from_documents(documents=texts, embedding=embedding, persist_directory=persist_directory)
+
+retriever = vectordb.as_retriever()
+
+system = """
+Tu es un assistant spécialisé dans l'enseignement de la spécialité Numérique et sciences informatiques en classe de première et de terminal
+Tu as un bon niveau en langage Python
+Ton interlocuteur est un élève qui suit la spécialité nsi en première et en terminale
+Tu dois uniquement répondre aux questions qui concernent la spécialité numérique et sciences informatiques
+Tu ne dois pas faire d'erreur, répond à la question uniquement si tu es sûr de ta réponse
+si tu ne trouves pas la réponse à une question, tu réponds que tu ne connais pas la réponse et que l'élève doit s'adresser à son professeur pour obtenir cette réponse
+Tu dois uniquement aborder des notions qui sont aux programmes de la spécialité numérique et sciences informatiques (première et terminale), tu ne dois jamais aborder une notion qui n'est pas au programme
+si l'élève n'arrive pas à trouver la réponse à un exercice, tu ne dois pas lui donner tout de suite la réponse, mais seulement lui donner des indications pour lui permettre de trouver la réponse par lui même
+Quand tu donnes un exercice Python, dans les indications que tu donnes aux élèves, tu ne dois pas dire aux élèves d'utiliser les fonctions Python : min, max, sum... pour résoudre l'exercice
+Pour des exercices sur les requêtes SQL, tu ne doir pas utiliser LIKE, GROUP BY, INNER LEFT et INNER RIGHT car ces notions ne sont pas au programme de NSI
+Tu peux lui donner la réponse à un exercice uniquement si l'élève te demande explicitement cette réponse
+Tu dois uniquement répondre en langue française
+Tu trouveras ci-dessous les programmes de la spécialité NSI en première et terminale, tu devras veiller à ce que tes réponses ne sortent pas du cadre de ces programmes
+Si la question posée ne rentre pas dans le cadre du programme de NSI tu peux tout de même répondre en précisant bien que cette notion est hors programme
+si tu proposes un exercice, tu dois bien vérifier que toutes les notions nécessaires à la résolution de l'exercice sont explicitement au programme de NSI
+"""
+
+prompt = ChatPromptTemplate.from_messages(
+    [
+        ("system", system),
+        ("human", "Extraits des programmes de NSI : \n {document} \n\n Historique conversation entre l'assistant et l'élève : \n {historical} \n\n Intervention de l'élève : {question}"),
+    ]
+)
+
+chain = prompt | llm | StrOutputParser()
+
+def format_docs(docs):
+    return "\n".join(doc.page_content for doc in docs)
+
+def format_historical(hist):
+    historical = []
+    for i in range(0,len(hist)-2,2):
+        historical.append("Elève : "+hist[i].content)
+        historical.append("Assistant : "+hist[i+1].content)
+    return "\n".join(historical[-10:])
+
+
+class GraphState(TypedDict):
+    messages: Annotated[list[AnyMessage], add_messages]
+    documents : str
+
+def retrieve(state : GraphState):
+    documents = format_docs(retriever.invoke(state['messages'][-1].content))
+    return {'documents' : documents}
+
+def chatbot(state : GraphState):
+    response = chain.invoke({'document': state['documents'], 'historical': format_historical(state['messages']), 'question' : state['messages'][-1].content})
+    return {"messages": [AIMessage(content=response)]}
+
+workflow = StateGraph(GraphState)
+workflow.add_node('retrieve', retrieve)
+workflow.add_node('chatbot', chatbot)
+
+workflow.add_edge(START, 'retrieve')
+workflow.add_edge('retrieve','chatbot')
+workflow.add_edge('chatbot', END)
+
+app_chatbot = workflow.compile(checkpointer=memory)
+
+@app.post('/request')
+def request(req: Request):
+    config = {"configurable": {"thread_id": req.id}}
+    rep = app_chatbot.invoke({"messages": [HumanMessage(content=req.query)]},config, stream_mode="values")
+    return {"response":rep['messages'][-1].content}

requirements.txt

@@ -0,0 +1,9 @@
+langchain
+langchain-core
+langchain-groq
+langchain-huggingface
+langchain-chroma
+langchain_community 
+langgraph                    
+python-dotenv
+fastapi[all]