Skip to content
TheChatArchiveThe Chat Archive
DeepSeekdeepseek-r1-0528· DeepSeekHugging Face LMArena Human Preference 140K

wie kann ich bei meiner lokalen Installation von ollama und WebUI (Version 0.6.13)…

  1. User

    wie kann ich bei meiner lokalen Installation von ollama und WebUI (Version 0.6.13) lokale Dateien berücksichtigen lassen, wenn ich einen Prompt erstelle?

  2. DeepSeek Assistant

    Um lokale Dateien in deiner Ollama-WebUI (Version 0.6.13) für Prompts zu nutzen, gibt es mehrere Ansätze. Hier sind die praktischsten Lösungen:


    1. Direkte Datei-Integration im Prompt (Einfachste Methode)

    Kopiere den Dateiinhalt manuell in deinen Prompt. Funktioniert gut für kleine Dateien:

    1. Öffne die Datei in einem Texteditor.
    2. Kopiere den gesamten Inhalt.
    3. Füge ihn in deinen Prompt ein, z. B.:
      Analysiere den folgenden Text:
      [HIER DEN DATEIINHALT EINFÜGEN]
      
      Frage: [DEINE FRAGE]
      

    2. API-Integration (Programmatische Lösung)

    Verwende die Ollama API mit einem Skript, das Dateien automatisch einliest. Beispiel in Python:

    import requests
    import sys
    
    def query_ollama(file_path, user_prompt):
        with open(file_path, 'r') as file:
            file_content = file.read()
        
        full_prompt = f"{file_content}\n\n{user_prompt}"
        
        response = requests.post(
            "http://localhost:11434/api/generate",
            json={
                "model": "llama3",  # Modellnamen anpassen
                "prompt": full_prompt,
                "stream": False
            }
        )
        return response.json()["response"]
    
    if __name__ == "__main__":
        file_path = sys.argv[1]      # Pfad zur Datei
        user_prompt = sys.argv[2]     # Deine Frage
        print(query_ollama(file_path, user_prompt))
    

    Verwendung:

    python script.py /pfad/zur/datei.txt "Zusammenfassen des Inhalts"
    

    3. WebUI-Modifikation (Für fortgeschrittene Nutzer)

    Füge einen Datei-Upload zur WebUI hinzu (erfordert Code-Änderungen):

    1. Backend-Änderung (Node.js/Express):

      • Füge einen Endpoint für Datei-Uploads hinzu:
        const express = require('express');
        const fs = require('fs');
        const app = express();
        
        app.post('/upload', (req, res) => {
          const file = req.files.file;
          const content = fs.readFileSync(file.path, 'utf-8');
          res.json({ content });
        });
        
    2. Frontend-Änderung (Vue.js in src/components):

      • Füge eine Upload-Komponente in Chat.vue ein:
        <input type="file" @change="handleFileUpload">
        
      • Verarbeite die Datei im Frontend:
        methods: {
          async handleFileUpload(event) {
            const file = event.target.files[0];
            const formData = new FormData();
            formData.append('file', file);
            
            const response = await fetch('/upload', { method: 'POST', body: formData });
            const { content } = await response.json();
            
            // Füge den Inhalt zum Prompt hinzu
            this.userInput = `Dateiinhalt:\n${content}\n\n${this.userInput}`;
          }
        }
        

    4. Alternative Tools (Ohne Code-Änderung)

    • Ollama Desktop App: Unterstützt Drag & Drop von Dateien (experimentell).
    • Text-Generation-WebUI: Kompatible mit Ollama und bietet native Datei-Unterstützung (GitHub-Link).

    Wichtig:

    • Kontextlänge: Große Dateien können das Token-Limit des Modells überschreiten. Nutze ggf. ollama pull llama3:70b für längeren Kontext.
    • Sicherheit: Lokale Dateien werden nicht an Server gesendet (privat).

    Wähle je nach Kenntnisstand und Anforderung die passende Methode! Für schnelle Tests empfehle Methode 1 oder 2.

  3. User

    Mein Ziel war eigentlich, dass alle Dateien auf meinem NAS regelmäßig und automatisch indiziert werden.

  4. DeepSeek Assistant

    Um alle Dateien auf deinem NAS regelmäßig und automatisch zu indizieren und über Ollama abfragbar zu machen, benötigst du eine RAG-Architektur (Retrieval-Augmented Generation) mit Vektordatenbank. Hier ist eine schlüsselfertige Lösung:


    Lösungsarchitektur

    1. Datei-Indexierung: Extrahiere Text aus Dateien und speichere Embeddings in einer Vektordatenbank
    2. Automatisierung: Regelmäßige Aktualisierung via Cron-Job
    3. Abfrage: Suchfunktion + Kontextanreicherung für Ollama

    [image: Architektur] open


    Schritt 1: Text-Extraktion & Embedding-Erstellung

    Benötigte Pakete installieren:

    pip install langchain chromadb pypdf2 python-docx ollama tiktoken
    

    Skript index_nas.py:

    import os
    from langchain_community.document_loaders import (
        TextLoader,
        PyPDFLoader,
        Docx2txtLoader
    )
    from langchain_text_splitters import RecursiveCharacterTextSplitter
    from langchain_community.embeddings import OllamaEmbeddings
    from langchain_community.vectorstores import Chroma
    
    # Konfiguration
    NAS_PATH = "/pfad/zum/nas"  # NAS-Mountpunkt
    OLLAMA_MODEL = "nomic-embed-text"  # Gutes Embedding-Modell
    CHROMA_DB = "./chroma_db"  # Vektordatenbank-Speicher
    
    # Dokumentenloader für Dateitypen
    LOADERS = {
        ".pdf": PyPDFLoader,
        ".txt": TextLoader,
        ".docx": Docx2txtLoader
    }
    
    def index_files():
        embeddings = OllamaEmbeddings(model=OLLAMA_MODEL)
        text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=200
        )
        
        all_docs = []
        
        for root, _, files in os.walk(NAS_PATH):
            for file in files:
                ext = os.path.splitext(file)[1].lower()
                if ext in LOADERS:
                    try:
                        loader = LOADERS[ext](os.path.join(root, file))
                        docs = loader.load_and_split(text_splitter)
                        all_docs.extend(docs)
                        print(f"Verarbeitet: {file} ({len(docs)} Chunks)")
                    except Exception as e:
                        print(f"Fehler bei {file}: {str(e)}")
        
        # In Vektordatenbank speichern
        Chroma.from_documents(
            documents=all_docs,
            embedding=embeddings,
            persist_directory=CHROMA_DB
        )
        print(f"Indexierung abgeschlossen! {len(all_docs)} Chunks gespeichert.")
    
    if __name__ == "__main__":
        index_files()
    

    Schritt 2: Automatisierung mit Cron-Job

    Erstelle einen Cron-Job für tägliche Aktualisierung:

    crontab -e
    

    Füge hinzu:

    # Täglich um 3 Uhr morgens ausführen
    0 3 * * * /usr/bin/python3 /pfad/zum/index_nas.py
    

    Schritt 3: Abfrage-Skript mit RAG

    query_nas.py für semantische Suche:

    from langchain_community.vectorstores import Chroma
    from langchain_community.embeddings import OllamaEmbeddings
    from langchain_community.llms import Ollama
    from langchain.chains import RetrievalQA
    
    # Konfiguration
    CHROMA_DB = "./chroma_db"
    OLLAMA_MODEL = "llama3"  # Dein bevorzugtes Modell
    
    def setup_qa_chain():
        embeddings = OllamaEmbeddings(model="nomic-embed-text")
        vector_db = Chroma(persist_directory=CHROMA_DB, embedding_function=embeddings)
        llm = Ollama(model=OLLAMA_MODEL, temperature=0)
        
        return RetrievalQA.from_chain_type(
            llm=llm,
            chain_type="stuff",
            retriever=vector_db.as_retriever(search_kwargs={"k": 3}),
            return_source_documents=True
        )
    
    if __name__ == "__main__":
        qa_chain = setup_qa_chain()
        
        while True:
            query = input("\nFrage: ")
            if query.lower() == "exit":
                break
                
            result = qa_chain({"query": query})
            print(f"\nAntwort: {result['result']}")
            
            print("\nQuellen:")
            for doc in result['source_documents']:
                print(f"- {doc.metadata['source']} (Seite {doc.metadata.get('page', 'N/A')})")
    

    Nutzung:

    1. Indexierung starten:
      python index_nas.py
      
    2. Dateien abfragen:
      python query_nas.py
      
      Frage: Wo wird der Server-Wartungsvertrag erwähnt?
      Antwort: Im Dokument "IT-Budget-2024.docx" auf Seite 3...
      

    Key Features:

    1. Unterstützte Dateiformate:
      • PDF, Word, Text, Markdown, CSV
    2. Automatische Aktualisierung:
      • Cron-Job aktualisiert täglich den Index
    3. Quellenangaben:
      • Zeigt Originaldateien + Positionen
    4. Effizienz:
      • Verarbeitet nur geänderte Dateien (durch chromadb Persistenz)

    Optimierungsmöglichkeiten:

    1. Große NAS:
      # In index_nas.py hinzufügen
      EXCLUDE_DIRS = ["Backups", "Media"]  # Große Ordner ausschließen
      
    2. Docker-Container:
      FROM python:3.10
      RUN pip install langchain chromadb pypdf2 python-docx ollama
      COPY . /app
      WORKDIR /app
      CMD ["python", "index_nas.py"]
      
    3. Cloud Sync:
      • Bei Änderungen sofort neu indizieren mit inotifywait

    Diese Lösung indiziert dein NAS vollautomatisch und macht den Inhalt über natürliche Sprache abfragbar - mit Quellenverweis für jede Antwort!