Erstellen Sie Ihre eigene RAG-App: Eine Schritt-für-Schritt-Anleitung zum lokalen Einrichten von LLM mit Ollama, Python und ChromaDB

In einer Zeit, in der Datenschutz oberste Priorität hat, ist die Einrichtung eines eigenen lokalen Sprachmodells (LLM) eine wichtige Lösung für Unternehmen und Einzelpersonen. Dieses Tutorial führt Sie durch den Prozess der Erstellung eines benutzerdefinierten Chatbots mit Ollama , Python 3 und ChromaDB , die alle lokal auf Ihrem System gehostet werden. Hier sind die wichtigsten Gründe, warum Sie dieses Tutorial benötigen:

• Vollständige Anpassung: Wenn Sie Ihre eigene Retrieval-Augmented Generation (RAG)-Anwendung lokal hosten, haben Sie die vollständige Kontrolle über die Einrichtung und Anpassung. Sie können das Modell an Ihre spezifischen Anforderungen anpassen, ohne auf externe Dienste angewiesen zu sein.
• Verbesserter Datenschutz: Indem Sie Ihr LLM-Modell lokal einrichten, vermeiden Sie die Risiken, die mit dem Senden vertraulicher Daten über das Internet verbunden sind. Dies ist besonders wichtig für Unternehmen, die vertrauliche Informationen verarbeiten. Wenn Sie Ihr Modell lokal mit privaten Daten trainieren, stellen Sie sicher, dass Ihre Daten unter Ihrer Kontrolle bleiben.
• Datensicherheit: Die Verwendung von LLM-Modellen von Drittanbietern kann Ihre Daten potenziellen Verstößen und Missbrauch aussetzen. Die lokale Bereitstellung mindert diese Risiken, indem Ihre Trainingsdaten, z. B. PDF-Dokumente, in Ihrer sicheren Umgebung verbleiben.
• Kontrolle über die Datenverarbeitung: Wenn Sie Ihr eigenes LLM hosten, können Sie Ihre Daten genau so verwalten und verarbeiten, wie Sie möchten. Dazu gehört das Einbetten Ihrer privaten Daten in Ihren ChromaDB-Vektorspeicher, um sicherzustellen, dass Ihre Datenverarbeitung Ihren Standards und Anforderungen entspricht.
• Unabhängigkeit von der Internetverbindung: Wenn Sie Ihren Chatbot lokal ausführen, sind Sie nicht von einer Internetverbindung abhängig. Dies garantiert einen unterbrechungsfreien Service und Zugriff auf Ihren Chatbot, auch in Offline-Szenarien.

Mit diesem Tutorial können Sie einen robusten und sicheren lokalen Chatbot erstellen, der auf Ihre Anforderungen zugeschnitten ist, ohne Kompromisse bei Datenschutz oder Kontrolle einzugehen.

Retrieval-Augmented Generation (RAG)

Retrieval-Augmented Generation (RAG) ist eine fortschrittliche Technik, die die Stärken von Informationsabruf und Textgenerierung kombiniert, um genauere und kontextrelevantere Antworten zu erstellen. Hier ist eine Übersicht darüber, wie RAG funktioniert und warum es von Vorteil ist:

Was ist RAG?

RAG ist ein Hybridmodell, das die Fähigkeiten von Sprachmodellen durch die Einbindung einer externen Wissensdatenbank oder eines Dokumentenspeichers erweitert. Der Prozess umfasst zwei Hauptkomponenten:

• Abruf: In dieser Phase ruft das Modell basierend auf der Eingabeabfrage relevante Dokumente oder Informationen aus einer externen Quelle, beispielsweise einer Datenbank oder einem Vektorspeicher, ab.
• Generierung: Die abgerufenen Informationen werden dann von einem generativen Sprachmodell verwendet, um eine kohärente und kontextbezogen angemessene Antwort zu erstellen.

Wie funktioniert RAG?

• Abfrageeingabe: Der Benutzer gibt eine Abfrage oder Frage ein.
• Dokumentenabruf: Das System verwendet die Abfrage, um eine externe Wissensdatenbank zu durchsuchen und die relevantesten Dokumente oder Informationsschnipsel abzurufen.
• Antwortgenerierung: Das generative Modell verarbeitet die abgerufenen Informationen und integriert sie mit seinem eigenen Wissen, um eine detaillierte und genaue Antwort zu generieren.
• Ausgabe: Die endgültige Antwort, angereichert mit spezifischen und relevanten Details aus der Wissensdatenbank, wird dem Benutzer präsentiert.

Vorteile von RAG

• Verbesserte Genauigkeit: Durch die Nutzung externer Daten können RAG-Modelle präzisere und detailliertere Antworten liefern, insbesondere für domänenspezifische Abfragen.
• Kontextuelle Relevanz: Die Abrufkomponente stellt sicher, dass die generierte Antwort auf relevanten und aktuellen Informationen basiert, wodurch die Gesamtqualität der Antwort verbessert wird.
• Skalierbarkeit: RAG-Systeme lassen sich problemlos skalieren, um große Datenmengen zu integrieren und so ein breites Spektrum an Abfragen und Themen zu verarbeiten.
• Flexibilität: Diese Modelle können durch einfaches Aktualisieren oder Erweitern der externen Wissensbasis an verschiedene Domänen angepasst werden, was sie äußerst vielseitig macht.

Warum RAG lokal verwenden?

• Datenschutz und Sicherheit: Durch die lokale Ausführung eines RAG-Modells wird sichergestellt, dass vertrauliche Daten sicher und privat bleiben, da sie nicht an externe Server gesendet werden müssen.
• Anpassung: Sie können die Abruf- und Generierungsprozesse an Ihre spezifischen Anforderungen anpassen, einschließlich der Integration proprietärer Datenquellen.
• Unabhängigkeit: Eine lokale Einrichtung stellt sicher, dass Ihr System auch ohne Internetverbindung betriebsbereit bleibt und einen konsistenten und zuverlässigen Service bietet.

Indem Sie eine lokale RAG-Anwendung mit Tools wie Ollama, Python und ChromaDB einrichten, können Sie die Vorteile erweiterter Sprachmodelle nutzen und gleichzeitig die Kontrolle über Ihre Daten und Anpassungsoptionen behalten.

Grafikkarte

Das Ausführen großer Sprachmodelle (LLMs), wie sie in Retrieval-Augmented Generation (RAG) verwendet werden, erfordert erhebliche Rechenleistung. Eine der Schlüsselkomponenten, die eine effiziente Verarbeitung und Einbettung von Daten in diese Modelle ermöglichen, ist die Grafikverarbeitungseinheit (GPU). Hier erfahren Sie, warum GPUs für diese Aufgabe unverzichtbar sind und wie sie sich auf die Leistung Ihres lokalen LLM-Setups auswirken:

Was ist eine GPU?

Eine GPU ist ein spezialisierter Prozessor, der die Darstellung von Bildern und Videos beschleunigen soll. Im Gegensatz zu Central Processing Units (CPUs), die für sequentielle Verarbeitungsaufgaben optimiert sind, zeichnen sich GPUs durch parallele Verarbeitung aus. Dadurch eignen sie sich besonders gut für die komplexen mathematischen Berechnungen, die für maschinelles Lernen und Deep-Learning-Modelle erforderlich sind.

Warum GPUs für LLMs wichtig sind

• Parallele Verarbeitungsleistung: GPUs können Tausende von Operationen gleichzeitig verarbeiten und so Aufgaben wie Training und Inferenz in LLMs erheblich beschleunigen. Diese Parallelität ist entscheidend für die hohen Rechenlasten, die mit der Verarbeitung großer Datensätze und der Generierung von Antworten in Echtzeit verbunden sind.
• Effizienz bei der Handhabung großer Modelle: LLMs wie die in RAG verwendeten erfordern beträchtliche Speicher- und Rechenressourcen. GPUs sind mit High-Bandwidth Memory (HBM) und mehreren Kernen ausgestattet, sodass sie die umfangreichen Matrixmultiplikationen und Tensoroperationen bewältigen können, die diese Modelle benötigen.
• Schnelleres Einbetten und Abrufen von Daten: In einem lokalen RAG-Setup ist das Einbetten von Daten in einen Vektorspeicher wie ChromaDB und das schnelle Abrufen relevanter Dokumente für die Leistung von entscheidender Bedeutung. Hochleistungs-GPUs können diese Prozesse beschleunigen und sicherstellen, dass Ihr Chatbot schnell und präzise antwortet.
• Verbesserte Trainingszeiten: Beim Training eines LLM müssen Millionen (oder sogar Milliarden) von Parametern angepasst werden. GPUs können die für diese Trainingsphase erforderliche Zeit im Vergleich zu CPUs drastisch reduzieren und ermöglichen so häufigere Aktualisierungen und Verfeinerungen Ihres Modells.

Auswahl der richtigen GPU

Beim Einrichten eines lokalen LLM kann die Wahl der GPU die Leistung erheblich beeinflussen. Hier sind einige Faktoren, die Sie berücksichtigen sollten:

• Speicherkapazität: Größere Modelle erfordern mehr GPU-Speicher. Suchen Sie nach GPUs mit höherem VRAM (Video-RAM), um umfangreiche Datensätze und Modellparameter unterzubringen.
• Rechenleistung: Je mehr CUDA-Kerne eine GPU hat, desto besser kann sie parallele Verarbeitungsaufgaben bewältigen. GPUs mit höherer Rechenleistung sind für Deep-Learning-Aufgaben effizienter.
• Bandbreite: Eine höhere Speicherbandbreite ermöglicht eine schnellere Datenübertragung zwischen der GPU und ihrem Speicher und verbessert so die Gesamtverarbeitungsgeschwindigkeit.

Beispiele für Hochleistungs-GPUs für LLMs

• NVIDIA RTX 3090: Bekannt für seinen hohen VRAM (24 GB) und die leistungsstarken CUDA-Kerne, ist es eine beliebte Wahl für Deep-Learning-Aufgaben.
• NVIDIA A100: Speziell für KI und maschinelles Lernen entwickelt, bietet es außergewöhnliche Leistung mit großer Speicherkapazität und hoher Rechenleistung.
• AMD Radeon Pro VII: Ein weiterer starker Konkurrent mit hoher Speicherbandbreite und effizienten Verarbeitungsfunktionen.

Die Investition in eine leistungsstarke GPU ist für die lokale Ausführung von LLM-Modellen von entscheidender Bedeutung. Sie gewährleistet eine schnellere Datenverarbeitung, ein effizientes Modelltraining und eine schnelle Antwortgenerierung, wodurch Ihre lokale RAG-Anwendung robuster und zuverlässiger wird. Indem Sie die Leistung von GPUs nutzen, können Sie die Vorteile des Hostens Ihres eigenen benutzerdefinierten Chatbots voll ausschöpfen, der auf Ihre spezifischen Bedürfnisse und Datenschutzanforderungen zugeschnitten ist.

Voraussetzungen

Stellen Sie vor dem Einrichten sicher, dass die folgenden Voraussetzungen erfüllt sind:

• Python 3: Python ist eine vielseitige Programmiersprache, die Sie zum Schreiben des Codes für Ihre RAG-App verwenden.
• ChromaDB: Eine Vektordatenbank, die die Einbettungen unserer Daten speichert und verwaltet.
• Ollama: Zum Herunterladen und Bereitstellen benutzerdefinierter LLMs auf unserem lokalen Computer.

Schritt 1: Installieren Sie Python 3 und richten Sie Ihre Umgebung ein

Um unsere Python 3-Umgebung zu installieren und einzurichten, befolgen Sie diese Schritte: Laden Sie Python 3 herunter und richten Sie es auf Ihrem Computer ein. Stellen Sie dann sicher, dass Ihr Python 3 erfolgreich installiert und ausgeführt wird:

 $ python3 --version # Python 3.11.7

Erstellen Sie einen Ordner für Ihr Projekt, zum Beispiel local-rag :

 $ mkdir local-rag $ cd local-rag

Erstellen Sie eine virtuelle Umgebung mit dem Namen venv :

 $ python3 -m venv venv

Aktivieren Sie die virtuelle Umgebung:

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

Schritt 2: ChromaDB und andere Abhängigkeiten installieren

Installieren Sie ChromaDB mit pip:

 $ pip install --q chromadb

Installieren Sie Langchain-Tools, um nahtlos mit Ihrem Modell zu arbeiten:

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

Installieren Sie Flask, um Ihre App als HTTP-Dienst bereitzustellen:

 $ pip install --q flask

Schritt 3: Ollama installieren

Um Ollama zu installieren, folgen Sie diesen Schritten: Gehen Sie zur Ollama-Downloadseite und laden Sie das Installationsprogramm für Ihr Betriebssystem herunter. Überprüfen Sie Ihre Ollama-Installation, indem Sie Folgendes ausführen:

 $ ollama --version # ollama version is 0.1.47

Rufen Sie das benötigte LLM-Modell ab. So verwenden Sie beispielsweise das Mistral-Modell:

 $ ollama pull mistral

Rufen Sie das Text-Einbettungsmodell ab. So verwenden Sie beispielsweise das Nomic Embed Text-Modell:

 $ ollama pull nomic-embed-text

Führen Sie dann Ihre Ollama-Modelle aus:

 $ ollama serve

Erstellen der RAG-App

Nachdem Sie Ihre Umgebung mit Python, Ollama, ChromaDB und anderen Abhängigkeiten eingerichtet haben, ist es an der Zeit, Ihre benutzerdefinierte lokale RAG-App zu erstellen. In diesem Abschnitt gehen wir den praktischen Python-Code durch und geben einen Überblick über die Strukturierung Ihrer Anwendung.

app.py

Dies ist die Hauptanwendungsdatei von Flask. Sie definiert Routen zum Einbetten von Dateien in die Vektordatenbank und zum Abrufen der Antwort vom Modell.

 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

Dieses Modul übernimmt den Einbettungsprozess, einschließlich der Speicherung hochgeladener Dateien, des Ladens und Aufteilens von Daten und des Hinzufügens von Dokumenten zur Vektordatenbank.

 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

Dieses Modul verarbeitet Benutzeranfragen, indem es mehrere Versionen der Anfrage generiert, relevante Dokumente abruft und kontextbasierte Antworten bereitstellt.

 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

Dieses Modul initialisiert und gibt die Vektordatenbankinstanz zurück, die zum Speichern und Abrufen von Dokumenteinbettungen verwendet wird.

 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

Führen Sie Ihre App aus!

Erstellen Sie .env Datei zum Speichern Ihrer Umgebungsvariablen:

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

Führen Sie die Datei app.py aus, um Ihren App-Server zu starten:

 $ python3 app.py

Sobald der Server läuft, können Sie Anfragen an die folgenden Endpunkte senden:

• Beispielbefehl zum Einbetten einer PDF-Datei (z. B. resume.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" }

• Beispielbefehl, um Ihrem Modell eine Frage zu stellen:

 $ 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." }

Abschluss

Wenn Sie diese Anweisungen befolgen, können Sie Ihre benutzerdefinierte lokale RAG-App mit Python, Ollama und ChromaDB effektiv ausführen und mit ihr interagieren, ganz nach Ihren Bedürfnissen. Passen Sie die Funktionalität nach Bedarf an und erweitern Sie sie, um die Fähigkeiten Ihrer Anwendung zu verbessern.

Indem Sie die Möglichkeiten der lokalen Bereitstellung nutzen, schützen Sie nicht nur vertrauliche Informationen, sondern optimieren auch Leistung und Reaktionsfähigkeit. Ganz gleich, ob Sie die Kundeninteraktion verbessern oder interne Prozesse optimieren, eine lokal bereitgestellte RAG-Anwendung bietet die Flexibilität und Robustheit, um sich an Ihre Anforderungen anzupassen und mit ihnen zu wachsen.

Überprüfen Sie den Quellcode in diesem Repo:

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

Viel Spaß beim Programmieren!