Lokalny RAG bez chmury — RTX 5080, ColQwen i LanceDB w Dockerze

Wyobraź sobie asystenta AI, któremu rzucasz na biurko chaos — wykresy giełdowe, wielostronicowe umowy PDF, odręczne notatki na marginesach faktur. Chcesz połączyć fakty i wyciągnąć wnioski, ale nie możesz tego wrzucić do chmury, bo to dane poufne. Twoje finanse, patenty, dokumentacja medyczna. Rozwiązaniem jest lokalny agent nowej generacji — taki, który nie tylko czyta tekst, ale też widzi obrazy i myśli zanim odpowie. Wszystko na twoim sprzęcie, bez wysyłania ani bajtu do internetu.

Film: Homelab AI — lokalny RAG na RTX 5080 bez chmury

https://youtube.com/watchfE7ZV-y2lI

Poniżej pełny tutorial z wyjaśnieniem każdego komponentu architektury.

Dlaczego RTX 5080 i GDDR7 mają znaczenie dla RAG

Jeszcze 2 lata temu w lokalnym AI liczyliśmy głównie gigabajty VRAM — "czy model się zmieści?". Dziś pojemność to tylko połowa sukcesu.

Przy modelach wizualnych musisz rozróżnić dwa parametry:

• Moc obliczeniowa (TFLOPS) — ile operacji karta wykonuje na sekundę
• Przepustowość pamięci (memory bandwidth) — jak szybko dane trafiają do rdzeni

Karta z pamięcią GDDR7 ma przepustowość bliską 1 TB/s. Dlaczego to kluczowe przy RAG?

Kiedy zadajesz pytanie, system przeszukuje tysiące wektorów w ułamku sekundy. Kiedy model generuje odpowiedź, każdy token (każde słowo na ekranie) wymaga przesłania całej wagi modelu przez pamięć. Na starszych kartach rdzeń graficzny czekał na dane — to generowało opóźnienia. Z GDDR7 dane są na miejscu natychmiast.

Architektura systemu

System składa się z czterech warstw:

Dokumenty (PDF/obrazy)
    ↓
ColQwen — visual embeddings (GPU)
    ↓
LanceDB — wektorowa baza danych (lokalny plik)
    ↓
TensorRT-LLM — generowanie odpowiedzi (GPU)

Krok 1: Docker + NVIDIA Container Toolkit

Wiele osób próbuje instalować biblioteki bezpośrednio na Windowsie. To często kończy się piekłem zależności — jedna aktualizacja innej aplikacji może wysypać całe środowisko.

Zamiast tego: Docker + NVIDIA Container Toolkit.

Docker tworzy izolowany kontener z czystym Linuksem i precyzyjnie dobranymi wersjami bibliotek. NVIDIA Container Toolkit robi "przelotkę" — pozwala sterownikom z Windowsa przebić się do kontenera linuksowego. Dzięki temu masz 100% wydajności GPU w stabilnym środowisku.

Dockerfile
Kopiuj
1
2
3
FROM nvcr.io/nvidia/tensorrt:24.01-py3

RUN pip install colqwen lancedb streamlit

Uruchomienie:

Bash
Kopiuj
1
docker run --gpus all -v C:/dane:/app/input -p 8501:8501 local-rag

Flaga --gpus all to właśnie ta magia Container Toolkit — kontener widzi twój GPU jak swój własny.

Krok 2: TensorRT-LLM — dlaczego nie zwykły PyTorch?

Wyobraź sobie model AI jako genialnego, ale chaotycznego kucharza. Zwykły runner AI (PyTorch) interpretuje model w locie — kucharz za każdym razem szuka patelni.

TensorRT-LLM robi coś innego: kompiluje model. Analizuje architekturę modelu i architekturę konkretnej karty graficznej. Następnie:

• Łączy operacje matematyczne (Layer Fusion)
• Usuwa zbędne kroki
• Optymalizuje zarządzanie pamięcią

Efekt: kilkukrotnie szybsze generowanie tokenów przy niższym zużyciu VRAM.

W projekcie używamy wersji LTS (long-term support) dla stabilności.

Krok 3: Visual RAG z ColQwen — oczy systemu

To kluczowa innowacja, która odróżnia ten system od klasycznego RAG.

Tradycyjny RAG działa tak:

1. Weź PDF
2. Użyj OCR do rozpoznawania tekstu
3. Zamień na ciąg liter
4. Stwórz embeddingi z tekstu

To była katastrofa w dokumentach biznesowych. Wykres kołowy stawał się bełkotem. Tabela traciła kolumny. Odręczna notatka była pomijana.

Nasz system:

1. Weź PDF
2. Zapisz każdą stronę jako obrazek (bez OCR)
3. ColQwen tworzy wizualne embeddingi — wektory z obrazu
4. LanceDB przechowuje te wektory

Kiedy zapytasz o "czerwony słupek na wykresie", model widzi kolor czerwony i kształt słupka. Dla starego AI to było niewidzialne — dla ColQwen jest oczywiste.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# ingest.py — indeksowanie dokumentów
def process_pdf(path: str) -> list:
    items = []
    doc = fitz.open(path)
    for page in doc:
        # Każda strona → obraz (nie OCR!)
        pix = page.get_pixmap(dpi=150)
        img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
        items.append(img)
    return items

def create_embeddings(images: list) -> list:
    # ColQwen działa na GPU — żadnych zewnętrznych API
    processor = ColQwen2_5Processor.from_pretrained("vidore/colqwen2.5-v0.2")
    model = ColQwen2_5.from_pretrained("vidore/colqwen2.5-v0.2").to("cuda")

    inputs = processor.process_images(images)
    with torch.no_grad():
        embeddings = model(**inputs)
    return embeddings.tolist()

Krok 4: LanceDB — wektorowa baza danych bez serwera

Używamy LanceDB — nowoczesnej bazy wektorowej w trybie embedded.

Co to znaczy? Nie stawiasz osobnego ciężkiego serwera. LanceDB działa bezpośrednio na plikach na twoim dysku. Architektura jest lekka — możesz skopiować folder z bazą na pendrive i przenieść cały system na inny komputer w sekundę.

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import lancedb

# Połączenie — to tylko ścieżka do folderu
db = lancedb.connect("./vectordb")

# Tworzenie tabeli z wyszukiwaniem cosinusowym
table = db.create_table("documents", schema={
    "id": "string",
    "source_file": "string",
    "image_path": "string",
    "vector": "vector[128]",  # wymiar z ColQwen
    "created_at": "timestamp"
}, mode="overwrite")

# Dodanie dokumentu
table.add([{
    "id": "doc_001",
    "source_file": "raport_q4.pdf",
    "image_path": "/input/raport_q4_page_1.png",
    "vector": embedding,
    "created_at": datetime.now()
}])

Wyszukiwanie używa odległości cosinusowej — im bliżej 0, tym wyższe dopasowanie.

Krok 5: Wyszukiwanie i generowanie odpowiedzi

Python
Kopiuj
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# search.py
def search(query: str, top_k: int = 5) -> list:
    # Zakoduj zapytanie jako wektor
    query_embedding = encode_query(query)

    # Wyszukaj w LanceDB
    results = table.search(query_embedding)\
                   .limit(top_k)\
                   .to_list()

    return results

def build_prompt(query: str, results: list) -> str:
    context = ""
    for r in results:
        context += f"Dokument: {r['source_file']}\n"
        context += f"Podobieństwo: {(1 - r['_distance']) * 100:.1f}%\n\n"

    return f"""<|system|>
Jesteś asystentem analizującym dokumenty firmowe.
Odpowiadaj tylko na podstawie dostarczonego kontekstu.
Jeśli nie znasz odpowiedzi, powiedz wprost.

<|user|>
Kontekst: {context}
Pytanie: {query}

<|assistant|>"""

TensorRT-LLM generuje odpowiedź z parametrami:

Python
Kopiuj
1
2
3
4
5
sampling_params = SamplingParams(
    max_tokens=512,
    temperature=0.1,   # niska = bardziej deterministyczna
    top_p=0.95
)

Wyniki w praktyce

System zwraca wyniki z procentem dopasowania:

• "Znajdź wszystkie wykresy z czerwonymi słupkami" → 52% dopasowania dla najlepszego wyniku
• "Dokumenty powiązane ze sprzedażą" → znalazł faktury i notatki sprzedażowe

Czas wyszukiwania przy pierwszym uruchomieniu jest wolniejszy (model ładuje się do VRAM). Przy kolejnych zapytaniach — znacznie szybciej, bo wagi są już w pamięci.

Prywatność — zero danych w chmurze

To co widziałeś nie jest demo z chmury wielkiej korporacji. System działa lokalnie w kontenerze Dockera:

• Żaden bajt danych nie opuszcza twojego dysku NVMe
• ColQwen działa w całości na GPU — żadnych zewnętrznych API do embeddingów
• TensorRT-LLM generuje tekst lokalnie
• LanceDB to pliki na dysku

W świecie, gdzie dane są nową ropą, własny rurociąg to największy skarb — szczególnie przy danych finansowych, medycznych czy tajemnicach firmowych.

Czego potrzebujesz

Kod źródłowy z Dockerfile, requirements.txt i instrukcją krok po kroku znajdziesz na GitHubie Kacpra — link w filmie.

Dalej w tym klastrze

• Gemini Imagen w n8n — automatyczna edycja zdjęć produktów
• MCP w n8n — Claude Code tworzy workflowy za Ciebie

Chcesz zbudować prywatny system RAG dla swojej firmy? Porozmawiajmy →