Créez votre propre application RAG : un guide étape par étape pour configurer LLM localement à l'aide d'Ollama, Python et ChromaDB

À une époque où la confidentialité des données est primordiale, la mise en place de votre propre modèle de langue locale (LLM) constitue une solution cruciale pour les entreprises et les particuliers. Ce didacticiel est conçu pour vous guider tout au long du processus de création d'un chatbot personnalisé à l'aide d'Ollama , Python 3 et ChromaDB , tous hébergés localement sur votre système. Voici les principales raisons pour lesquelles vous avez besoin de ce tutoriel :

• Personnalisation complète : héberger localement votre propre application de génération augmentée de récupération (RAG) signifie que vous avez un contrôle total sur la configuration et la personnalisation. Vous pouvez affiner le modèle pour l'adapter à vos besoins spécifiques sans recourir à des services externes.
• Confidentialité améliorée : en configurant votre modèle LLM localement, vous évitez les risques associés à l'envoi de données sensibles sur Internet. Ceci est particulièrement important pour les entreprises qui traitent des informations confidentielles. Entraîner votre modèle avec des données privées localement garantit que vos données restent sous votre contrôle.
• Sécurité des données : l'utilisation de modèles LLM tiers peut exposer vos données à des violations et à des utilisations abusives potentielles. Le déploiement local atténue ces risques en conservant vos données de formation, telles que les documents PDF, dans votre environnement sécurisé.
• Contrôle du traitement des données : lorsque vous hébergez votre propre LLM, vous avez la possibilité de gérer et de traiter vos données exactement comme vous le souhaitez. Cela inclut l'intégration de vos données privées dans votre magasin de vecteurs ChromaDB, garantissant que votre traitement de données répond à vos normes et exigences.
• Indépendance vis-à-vis de la connectivité Internet : exécuter votre chatbot localement signifie que vous n'êtes pas dépendant d'une connexion Internet. Cela garantit un service et un accès ininterrompus à votre chatbot, même dans des scénarios hors ligne.

Ce tutoriel vous permettra de créer un chatbot local robuste et sécurisé, adapté à vos besoins, sans compromettre la confidentialité ou le contrôle.

Génération augmentée par récupération (RAG)

La génération augmentée par récupération (RAG) est une technique avancée qui combine les atouts de la récupération d'informations et de la génération de texte pour créer des réponses plus précises et contextuellement pertinentes. Voici un aperçu du fonctionnement de RAG et de ses avantages :

Qu’est-ce que le RAG ?

RAG est un modèle hybride qui améliore les capacités des modèles de langage en incorporant une base de connaissances externe ou un magasin de documents. Le processus implique deux éléments principaux :

• Récupération : dans cette phase, le modèle récupère des documents ou des informations pertinents à partir d'une source externe, telle qu'une base de données ou un magasin de vecteurs, en fonction de la requête d'entrée.
• Génération : les informations récupérées sont ensuite utilisées par un modèle de langage génératif pour produire une réponse cohérente et contextuellement appropriée.

Comment fonctionne RAG ?

• Saisie de requête : l'utilisateur saisit une requête ou une question.
• Récupération de documents : le système utilise la requête pour rechercher dans une base de connaissances externe, récupérant les documents ou les extraits d'informations les plus pertinents.
• Génération de réponse : le modèle génératif traite les informations récupérées, en les intégrant à ses propres connaissances pour générer une réponse détaillée et précise.
• Résultat : La réponse finale, enrichie de détails spécifiques et pertinents issus de la base de connaissances, est présentée à l'utilisateur.

Avantages du RAG

• Précision améliorée : en exploitant des données externes, les modèles RAG peuvent fournir des réponses plus précises et détaillées, en particulier pour les requêtes spécifiques à un domaine.
• Pertinence contextuelle : le composant de récupération garantit que la réponse générée est fondée sur des informations pertinentes et à jour, améliorant ainsi la qualité globale de la réponse.
• Évolutivité : les systèmes RAG peuvent être facilement mis à l'échelle pour incorporer de grandes quantités de données, leur permettant ainsi de traiter un large éventail de requêtes et de sujets.
• Flexibilité : ces modèles peuvent être adaptés à différents domaines en mettant simplement à jour ou en élargissant la base de connaissances externe, ce qui les rend très polyvalents.

Pourquoi utiliser RAG localement ?

• Confidentialité et sécurité : l'exécution d'un modèle RAG localement garantit que les données sensibles restent sécurisées et privées, car elles n'ont pas besoin d'être envoyées à des serveurs externes.
• Personnalisation : vous pouvez adapter les processus de récupération et de génération à vos besoins spécifiques, notamment en intégrant des sources de données propriétaires.
• Indépendance : une configuration locale garantit que votre système reste opérationnel même sans connexion Internet, fournissant ainsi un service cohérent et fiable.

En configurant une application RAG locale avec des outils comme Ollama, Python et ChromaDB, vous pouvez profiter des avantages des modèles de langage avancés tout en gardant le contrôle de vos données et de vos options de personnalisation.

GPU

L’exécution de grands modèles de langage (LLM) comme ceux utilisés dans la génération augmentée par récupération (RAG) nécessite une puissance de calcul importante. L'un des composants clés qui permettent un traitement et une intégration efficaces des données dans ces modèles est l'unité de traitement graphique (GPU). Voici pourquoi les GPU sont essentiels pour cette tâche et comment ils impactent les performances de votre configuration LLM locale :

Qu'est-ce qu'un GPU ?

Un GPU est un processeur spécialisé conçu pour accélérer le rendu des images et des vidéos. Contrairement aux unités centrales de traitement (CPU), optimisées pour les tâches de traitement séquentiel, les GPU excellent dans le traitement parallèle. Cela les rend particulièrement adaptés aux calculs mathématiques complexes requis par les modèles d’apprentissage automatique et d’apprentissage profond.

Pourquoi les GPU sont importants pour les LLM

• Puissance de traitement parallèle : les GPU peuvent gérer des milliers d'opérations simultanément, accélérant considérablement les tâches telles que la formation et l'inférence dans les LLM. Ce parallélisme est crucial pour les lourdes charges de calcul associées au traitement de grands ensembles de données et à la génération de réponses en temps réel.
• Efficacité dans la gestion des grands modèles : les LLM comme ceux utilisés dans RAG nécessitent une mémoire et des ressources de calcul importantes. Les GPU sont équipés d'une mémoire à large bande passante (HBM) et de plusieurs cœurs, ce qui les rend capables de gérer les multiplications matricielles et les opérations tensorielles à grande échelle nécessaires à ces modèles.
• Incorporation et récupération de données plus rapides : dans une configuration RAG locale, l'intégration de données dans un magasin de vecteurs comme ChromaDB et la récupération rapide des documents pertinents sont essentielles pour les performances. Les GPU hautes performances peuvent accélérer ces processus, garantissant que votre chatbot répond rapidement et avec précision.
• Temps de formation améliorés : former un LLM implique d'ajuster des millions (voire des milliards) de paramètres. Les GPU peuvent réduire considérablement le temps requis pour cette phase de formation par rapport aux CPU, permettant des mises à jour et des affinements plus fréquents de votre modèle.

Choisir le bon GPU

Lors de la configuration d'un LLM local, le choix du GPU peut avoir un impact significatif sur les performances. Voici quelques facteurs à considérer :

• Capacité de mémoire : les modèles plus grands nécessitent plus de mémoire GPU. Recherchez des GPU avec une VRAM (RAM vidéo) plus élevée pour prendre en charge des ensembles de données et des paramètres de modèle étendus.
• Capacité de calcul : plus un GPU possède de cœurs CUDA, mieux il peut gérer les tâches de traitement parallèle. Les GPU dotés de capacités de calcul plus élevées sont plus efficaces pour les tâches d’apprentissage en profondeur.
• Bande passante : une bande passante mémoire plus élevée permet un transfert de données plus rapide entre le GPU et sa mémoire, améliorant ainsi la vitesse de traitement globale.

Exemples de GPU hautes performances pour les LLM

• NVIDIA RTX 3090 : Connu pour sa VRAM élevée (24 Go) et ses puissants cœurs CUDA, c'est un choix populaire pour les tâches d'apprentissage en profondeur.
• NVIDIA A100 : Conçu spécifiquement pour l'IA et l'apprentissage automatique, il offre des performances exceptionnelles avec une grande capacité de mémoire et une puissance de calcul élevée.
• AMD Radeon Pro VII : Un autre concurrent sérieux, avec une bande passante mémoire élevée et des capacités de traitement efficaces.

Investir dans un GPU hautes performances est crucial pour exécuter des modèles LLM localement. Il garantit un traitement des données plus rapide, une formation efficace des modèles et une génération de réponses rapide, rendant votre application RAG locale plus robuste et fiable. En tirant parti de la puissance des GPU, vous pouvez pleinement profiter des avantages de l’hébergement de votre propre chatbot personnalisé, adapté à vos besoins spécifiques et à vos exigences en matière de confidentialité des données.

Conditions préalables

Avant de vous lancer dans la configuration, assurez-vous que les conditions préalables suivantes sont remplies :

• Python 3 : Python est un langage de programmation polyvalent que vous utiliserez pour écrire le code de votre application RAG.
• ChromaDB : Une base de données vectorielle qui stockera et gérera les intégrations de nos données.
• Ollama : Pour télécharger et diffuser des LLM personnalisés sur notre machine locale.

Étape 1 : Installez Python 3 et configurez votre environnement

Pour installer et configurer notre environnement Python 3, suivez ces étapes : Téléchargez et configurez Python 3 sur votre machine. Assurez-vous ensuite que votre Python 3 est installé et exécuté avec succès :

 $ python3 --version # Python 3.11.7

Créez un dossier pour votre projet, par exemple local-rag :

 $ mkdir local-rag $ cd local-rag

Créez un environnement virtuel nommé venv :

 $ python3 -m venv venv

Activez l'environnement virtuel :

 $ source venv/bin/activate # Windows # venv\Scripts\activate

Étape 2 : Installez ChromaDB et d'autres dépendances

Installez ChromaDB à l'aide de pip :

 $ pip install --q chromadb

Installez les outils Langchain pour travailler de manière transparente avec votre modèle :

 $ pip install --q unstructured langchain langchain-text-splitters $ pip install --q "unstructured[all-docs]"

Installez Flask pour servir votre application en tant que service HTTP :

 $ pip install --q flask

Étape 3 : Installer Ollama

Pour installer Ollama, suivez ces étapes : Accédez à la page de téléchargement d'Ollama et téléchargez le programme d'installation de votre système d'exploitation. Vérifiez votre installation Ollama en exécutant :

 $ ollama --version # ollama version is 0.1.47

Tirez le modèle LLM dont vous avez besoin. Par exemple, pour utiliser le modèle Mistral :

 $ ollama pull mistral

Extrayez le modèle d'intégration de texte. Par exemple, pour utiliser le modèle Nomic Embed Text :

 $ ollama pull nomic-embed-text

Exécutez ensuite vos modèles Ollama :

 $ ollama serve

Créez l'application RAG

Maintenant que vous avez configuré votre environnement avec Python, Ollama, ChromaDB et d'autres dépendances, il est temps de créer votre application RAG locale personnalisée. Dans cette section, nous passerons en revue le code Python pratique et donnerons un aperçu de la façon de structurer votre application.

app.py

Il s'agit du fichier principal de l'application Flask. Il définit des itinéraires pour intégrer des fichiers dans la base de données vectorielles et récupérer la réponse du modèle.

 import os from dotenv import load_dotenv load_dotenv() from flask import Flask, request, jsonify from embed import embed from query import query from get_vector_db import get_vector_db TEMP_FOLDER = os.getenv('TEMP_FOLDER', './_temp') os.makedirs(TEMP_FOLDER, exist_ok=True) app = Flask(__name__) @app.route('/embed', methods=['POST']) def route_embed(): if 'file' not in request.files: return jsonify({"error": "No file part"}), 400 file = request.files['file'] if file.filename == '': return jsonify({"error": "No selected file"}), 400 embedded = embed(file) if embedded: return jsonify({"message": "File embedded successfully"}), 200 return jsonify({"error": "File embedded unsuccessfully"}), 400 @app.route('/query', methods=['POST']) def route_query(): data = request.get_json() response = query(data.get('query')) if response: return jsonify({"message": response}), 200 return jsonify({"error": "Something went wrong"}), 400 if __name__ == '__main__': app.run(host="0.0.0.0", port=8080, debug=True)

embed.py

Ce module gère le processus d'intégration, y compris la sauvegarde des fichiers téléchargés, le chargement et le fractionnement des données, ainsi que l'ajout de documents à la base de données vectorielles.

 import os from datetime import datetime from werkzeug.utils import secure_filename from langchain_community.document_loaders import UnstructuredPDFLoader from langchain_text_splitters import RecursiveCharacterTextSplitter from get_vector_db import get_vector_db TEMP_FOLDER = os.getenv('TEMP_FOLDER', './_temp') # Function to check if the uploaded file is allowed (only PDF files) def allowed_file(filename): return '.' in filename and filename.rsplit('.', 1)[1].lower() in {'pdf'} # Function to save the uploaded file to the temporary folder def save_file(file): # Save the uploaded file with a secure filename and return the file path ct = datetime.now() ts = ct.timestamp() filename = str(ts) + "_" + secure_filename(file.filename) file_path = os.path.join(TEMP_FOLDER, filename) file.save(file_path) return file_path # Function to load and split the data from the PDF file def load_and_split_data(file_path): # Load the PDF file and split the data into chunks loader = UnstructuredPDFLoader(file_path=file_path) data = loader.load() text_splitter = RecursiveCharacterTextSplitter(chunk_size=7500, chunk_overlap=100) chunks = text_splitter.split_documents(data) return chunks # Main function to handle the embedding process def embed(file): # Check if the file is valid, save it, load and split the data, add to the database, and remove the temporary file if file.filename != '' and file and allowed_file(file.filename): file_path = save_file(file) chunks = load_and_split_data(file_path) db = get_vector_db() db.add_documents(chunks) db.persist() os.remove(file_path) return True return False

query.py

Ce module traite les requêtes des utilisateurs en générant plusieurs versions de la requête, en récupérant les documents pertinents et en fournissant des réponses basées sur le contexte.

 import os from langchain_community.chat_models import ChatOllama from langchain.prompts import ChatPromptTemplate, PromptTemplate from langchain_core.output_parsers import StrOutputParser from langchain_core.runnables import RunnablePassthrough from langchain.retrievers.multi_query import MultiQueryRetriever from get_vector_db import get_vector_db LLM_MODEL = os.getenv('LLM_MODEL', 'mistral') # Function to get the prompt templates for generating alternative questions and answering based on context def get_prompt(): QUERY_PROMPT = PromptTemplate( input_variables=["question"], template="""You are an AI language model assistant. Your task is to generate five different versions of the given user question to retrieve relevant documents from a vector database. By generating multiple perspectives on the user question, your goal is to help the user overcome some of the limitations of the distance-based similarity search. Provide these alternative questions separated by newlines. Original question: {question}""", ) template = """Answer the question based ONLY on the following context: {context} Question: {question} """ prompt = ChatPromptTemplate.from_template(template) return QUERY_PROMPT, prompt # Main function to handle the query process def query(input): if input: # Initialize the language model with the specified model name llm = ChatOllama(model=LLM_MODEL) # Get the vector database instance db = get_vector_db() # Get the prompt templates QUERY_PROMPT, prompt = get_prompt() # Set up the retriever to generate multiple queries using the language model and the query prompt retriever = MultiQueryRetriever.from_llm( db.as_retriever(), llm, prompt=QUERY_PROMPT ) # Define the processing chain to retrieve context, generate the answer, and parse the output chain = ( {"context": retriever, "question": RunnablePassthrough()} | prompt | llm | StrOutputParser() ) response = chain.invoke(input) return response return None

get_vector_db.py

Ce module initialise et renvoie l'instance de base de données vectorielle utilisée pour stocker et récupérer les intégrations de documents.

 import os from langchain_community.embeddings import OllamaEmbeddings from langchain_community.vectorstores.chroma import Chroma CHROMA_PATH = os.getenv('CHROMA_PATH', 'chroma') COLLECTION_NAME = os.getenv('COLLECTION_NAME', 'local-rag') TEXT_EMBEDDING_MODEL = os.getenv('TEXT_EMBEDDING_MODEL', 'nomic-embed-text') def get_vector_db(): embedding = OllamaEmbeddings(model=TEXT_EMBEDDING_MODEL,show_progress=True) db = Chroma( collection_name=COLLECTION_NAME, persist_directory=CHROMA_PATH, embedding_function=embedding ) return db

Exécutez votre application !

Créez un fichier .env pour stocker vos variables d'environnement :

 TEMP_FOLDER = './_temp' CHROMA_PATH = 'chroma' COLLECTION_NAME = 'local-rag' LLM_MODEL = 'mistral' TEXT_EMBEDDING_MODEL = 'nomic-embed-text'

Exécutez le fichier app.py pour démarrer votre serveur d'applications :

 $ python3 app.py

Une fois le serveur exécuté, vous pouvez commencer à envoyer des requêtes aux points de terminaison suivants :

• Exemple de commande pour intégrer un fichier PDF (par exemple, curriculum vitae.pdf) :

 $ curl --request POST \ --url http://localhost:8080/embed \ --header 'Content-Type: multipart/form-data' \ --form file=@/Users/nassermaronie/Documents/Nasser-resume.pdf # Response { "message": "File embedded successfully" }

• Exemple de commande pour poser une question à votre modèle :

 $ curl --request POST \ --url http://localhost:8080/query \ --header 'Content-Type: application/json' \ --data '{ "query": "Who is Nasser?" }' # Response { "message": "Nasser Maronie is a Full Stack Developer with experience in web and mobile app development. He has worked as a Lead Full Stack Engineer at Ulventech, a Senior Full Stack Engineer at Speedoc, a Senior Frontend Engineer at Irvins, and a Software Engineer at Tokopedia. His tech stacks include Typescript, ReactJS, VueJS, React Native, NodeJS, PHP, Golang, Python, MySQL, PostgresQL, MongoDB, Redis, AWS, Firebase, and Supabase. He has a Bachelor's degree in Information System from Universitas Amikom Yogyakarta." }

Conclusion

En suivant ces instructions, vous pouvez exécuter et interagir efficacement avec votre application RAG locale personnalisée à l'aide de Python, Ollama et ChromaDB, adaptée à vos besoins. Ajustez et développez les fonctionnalités si nécessaire pour améliorer les capacités de votre application.

En exploitant les capacités de déploiement local, vous protégez non seulement les informations sensibles, mais vous optimisez également les performances et la réactivité. Que vous souhaitiez améliorer les interactions avec les clients ou rationaliser les processus internes, une application RAG déployée localement offre flexibilité et robustesse pour s'adapter et évoluer avec vos besoins.

Vérifiez le code source dans ce dépôt :

https://github.com/firstpersoncode/local-rag

Bon codage !