chat with pennsieve

Discuter avec Pennsieve

Description du projet

Il s'agit de la composante du projet de recherche développée sous la direction du Dr Zachary Ives. L'objectif initial est de développer une couche de graphe au-dessus de la base de données Pennsieve et d'activer l'apprentissage automatique grâce à une extraction efficace de données de données médicales à partir de formats de fichiers complexes et polyvalents. Ce composant permet une interaction en langage naturel avec la base de données.

Remarque : Toutes les méthodes ont été implémentées sur le graphique sous-jacent construit sur Neo4j à l'aide d'un autre référentiel qui sera lié une fois public. Ce projet est prêt à être utilisé par la boîte, cependant, sans le graphique sous-jacent rempli, vous n'obtiendrez aucun résultat.

Structure du projet

app /

• __init__.py : initialise le package d'application.
  • Objectif : marque le répertoire comme un package Python. Ajoutez des importations au niveau du package ici si nécessaire.
• config.py : gère les variables de configuration et d'environnement.
  • Objectif : charge les variables de l'environnement et définit les paramètres de configuration.
  • Améliorations : implémentez la gestion des erreurs pour les variables d'environnement manquantes si nécessaire.
• database.py : gère la connexion de la base de données NEO4J.
  • Objectif : la fonction setup_neo4j_graph() renvoie un graphique NEO4J configuré avec URL, nom d'utilisateur et mot de passe fourni dans le fichier .env .
  • Documentation : setup_neo4j_graph() renvoie le wrapper de base de données Langchain Neo4j. Méthodes importantes utilisées: query() et refresh_schema() . Documentation Langchain Neo4jgraph
• main.py : point d'entrée de l'application. Passez la requête de l'utilisateur et récupère le résultat en appelant run_query(user_query: str) de qa_chain.py . Il résume toutes les complexités et fournit une interface simple pour interagir avec le système.
• dataguide.py : extrait les chemins de données de Dataguide à partir de la base de données et les formats en chemins de cypher.
  • Méthodes :
    1. extract_dataguide_paths(graph: Neo4jGraph) : extrait les chemins de données de la racine à la feuille à l'aide d'une requête Cypher.
    2. format_paths_for_llm(results: List[Dict[str, Any]]) : formats les résultats de extract_dataguide_paths dans des chemins de cypher valides pour les requêtes de correspondance.
• test.py : teste la connexion avec le graphique Neo4j, l'extraction des chemins de données et les formatant. Sorte le temps pris pour chaque partie.
  • Améliorations : ajouter des tests unitaires ou tester d'autres méthodes manuellement.
• prompt_generator.py : Ce module est responsable de la création et de la combinaison du système Langchain et des invites humaines dans langchain.prompts.ChatPromptTemplate . Il s'agit d'une partie cruciale du projet car il définit comment les invites sont structurées et utilisées dans le cadre de Langchain.
  • Méthodes :
    • get_cypher_prompt_template() : Cette méthode renvoie l'instance ChatPromptTemplate créée dans ce fichier. Il combine le système et les invites humaines dans un seul modèle qui peut être utilisé pour générer des requêtes Cypher à partir de GraphCypherQAChain dans qa_chain.py .
  • Documentation :
    • PromptTemplate: cette classe est utilisée pour définir la structure des invites. Les principaux paramètres utilisés sont input_variables , qui spécifient les variables à inclure dans l'invite et template , qui définit le texte de l'invite.
    • SystemMessagePromptTemplate: Cette classe est utilisée pour créer des messages système dans l'invite. Le paramètre principal utilisé est prompt , qui définit le texte du message système.
    • HumanMessagePRompptTemplate: Cette classe est utilisée pour créer des messages humains dans l'invite. Le paramètre principal utilisé est prompt , qui définit le texte du message humain.
    • ChatPromptTemplate: cette classe combine le système et les messages humains en une seule invite de chat. La méthode principale utilisée est from_messages() , qui prend une liste de modèles de messages et les combine dans une invite de chat.
• qa_chain.py : définit la fonction run_query(user_query: str) , qui intègre tous les composants du projet et exécute un GraphCypherQAChain sur la requête utilisateur.
  • Documentation :
    • Graphypherqachain
    • Chatopenai
    • Remarque: Remplacez ChatOpenAI par Azurechatopenai si nécessaire.

paths_vectordb /

• __init__.py : initialise le package d'application.
  • Objectif : marque le répertoire comme un package Python. Ajoutez des importations au niveau du package ici si nécessaire.
• generate_descriptions.py : définit l'invite du système pour générer des descriptions à partir de LLMS pour les chemins de cypher.
  • Méthodes :
    • generate_path_descriptions(all_paths: List[str]) : génère des descriptions pour les chemins donnés à l'aide du LLM. Sorte une liste de descriptions.
    • generate_embedding(path_description: str) : génère des incorporations pour la description du chemin donné à l'aide de l'API Openai Embeddings.
  • Documentation : Openaiembeddings
• random_path_generator.py : fournit des méthodes pour générer des chemins aléatoires à partir de la base de données et les formater dans des chemins Cypher.
• vectorDB_setup.py : fournit des méthodes pour démarrer le conteneur Milvus, se connecter avec elle, définir le schéma de collecte, créer la collecte, insérer des données et effectuer des recherches de similitude vectorielle.
  • Documentation : Pymilvus
• main.py : fonctions wrapper qui combinent toutes les fonctionnalités de ce répertoire. Par exemple, get_similar_paths_from_milvus est utilisé dans app/qa_chain.py pour effectuer une recherche de similitude vectorielle avec les requêtes utilisateur.
• test.py : méthodes pour tester diverses fonctionnalités. Actuellement commenté.
  • Améliorations : ajoutez manuellement les tests unitaires ou le test.
• write_read_data.py : des méthodes d'écriture et de lecture simples pour stocker des chemins et descriptions cypher générés à partir d'appels API.
  • Objectif : Aide à l'analyse et à l'économie des coûts d'API. La méthode fill_collection_with_random_paths dans paths_vectorDB/main.py écrit les chemins et descriptions générés à partir des appels d'API dans data.txt .

Répertoire racine

• env.sample : faites une copie de ceci dans le répertoire racine de votre projet et renommez-le à .env . Remplissez les valeurs.
• .gitignore : spécifie les fichiers et les répertoires à ignorer par GIT.
• README.md : Documentation du projet.
• docker-compose.yml : fichier docker pour milvus db. S'il y a une nouvelle version, remplacez ce fichier. Assurez-vous qu'il est nommé docker-compose.yml et placé dans le répertoire racine.
• requirements.txt : dépendances Python et leurs versions compatibles utilisées pour le développement. Remarque: Le fichier requirements.txt a été créé via pipenv .

Commencer

Condition préalable

• Python 3.8+
• Docker
• Base de données NEO4J Bureau et Neo4J remplie de graphiques et de données (le code pour cela sera bientôt lié)

Installation

Le début de ce projet est simple. Vous pouvez suivre les étapes ci-dessous:

1. Clone le référentiel :

   git clone https://github.com/hussainzs/chat-with-pennsieve.git
   cd project_root

   Remarque: assurez-vous que vous êtes dans le répertoire des racines du projet avant de procéder avec les étapes suivantes.

2. Installez les dépendances :

   pip install -r requirements.txt

3. Configurer des variables d'environnement :

   • Copiez env.sample et renommez le fichier vers .env et remplissez les valeurs requises.

4. Configurez le bureau NEO4J :

   • Téléchargez et installez le bureau NEO4J.
   • Notez l'URL, le nom d'utilisateur et le mot de passe pour la base de données NEO4J qui contient le graphique et le dataguide.
   • Mettez à jour le fichier .env avec les détails de la connexion NEO4J (URL, nom d'utilisateur, mot de passe). Les valeurs par défaut ont été remplies.

5. Exécuter app / main.py :

   • Accédez au répertoire app et exécutez main.py Assurez-vous que la requête utilisateur souhaitée est transmise comme un argument à la fonction run_query(user_query) .
   • Assurez-vous d'avoir docker-compose.yml dans le répertoire racine. Lorsque vous exécutez App / Main.py, les conteneurs Milvus démarreront automatiquement en exécutant les commandes de terminal. Consultez paths_vectorDB/vectorDB_setup.py pour plus d'informations.
   • Remarque : Lorsque le conteneur Milvus est créé la première fois, il télécharge et crée un nouveau dossier dans le répertoire racine nommé volumes . Le dossier contient 3 sous-dossiers: milvus , minio , etcd .
   • Pour plus d'informations, consultez: exécutez Milvus à l'aide de Docker Compose

Remarque : Pour plus de clarification de la sortie attendue lorsque vous exécutez app/main.py , je suis joint 2 PDF de sortie générés à partir du système dans le dossier appelé Sorties attendues .

1. Le fichier nommé first_output.pdf affiche ce qui est attendu lorsque l'utilisateur exécute l' app/main.py pour la première fois dans une nouvelle session avec des valeurs par défaut. (Lorsque vous l'exécutez pour la première fois, cela peut prendre un certain temps pour tout télécharger)
2. Le regular_output.pdf montre ce qui est attendu lorsque l'utilisateur exécute l' app/main.py dans une session régulière avec des valeurs par défaut.

Améliorations recommandées

1. Améliorer les invites du système : l'amélioration des invites dans app et paths_vectorDB peut améliorer considérablement les performances LLM. J'ai vu que des exemples de haute qualité dans l'invite du système augmenteront la qualité de la génération de description pour les chemins. L'invite du système affecte également de manière significative la réponse finale de LLM.
2. Optimiser le contexte pour LLM : au lieu d'envoyer tous les chemins de données, envoyez les 10 meilleurs chemins connexes à partir de la DB vectorielle milvus pour réduire les coûts de l'API et potentiellement améliorer les performances. Les longs invites du système peuvent augmenter les hallucinations et confondre LLM, reportez-vous à ce document pour plus d'informations: perdu au milieu: comment les modèles de langue utilisent des contextes longs
3. Mettez à jour Milvus : installez la dernière version de Milvus et modifiez la métrique de similitude de "IP" (produit intérieur) en cosinus dans la méthode search_similar_vectors à l'intérieur de paths_vectorDB/vectorDB_setup.py pour de meilleurs résultats.
4. Créez une interface utilisateur de chat : utilisez Streamlit ou votre bibliothèque d'interface utilisateur préférée pour créer une interface utilisateur de base pour ce projet. Vous pouvez utiliser FastAPI pour créer une API simple pour envoyer des requêtes utilisateur et recevoir des réponses d' app/main.py.
5. Ajouter la capacité de conversation : permettez des interactions de suivi pour guider le LLM pour une meilleure génération de chemins, bien que cela puisse augmenter les coûts d'API. J'ai remarqué que souvent, lorsque LLM avait tort, ce n'était que par un peu dans sa génération de chemins. Quelqu'un avec une connaissance du domaine du graphique sous-jacent peut facilement le corriger avec un suivi de base.