Ako vytvoriť multimodálny RAG systém s modelmi Granite

HW požiadavky na Multimodal RAG Systém s Modelmi Granite

Nie je to náročné na lokálny hardvér. Celý setup je navrhnutý tak, aby bežal na bežnom notebooku alebo dokonca zadarmo v cloude, pretože ťažkú prácu (generovanie embeddingov a odpovedí) robia modely Granite cez API (buď IBM watsonx.ai alebo Replicate, podľa verzie notebooku).

Žiadne lokálne spúšťanie obrovských LLM na tvojom PC – to by vyžadovalo drahé GPU.

1. Základné Požiadavky: Stačí Bežný Laptop

• CPU: Akýkoľvek moderný procesor (napr. Intel i5 alebo ekvivalent AMD z posledných 5 rokov). Notebook beží hlavne na lokálnom spracovaní PDF (extrakcia textu a obrázkov), chunkovaní a indexovaní v FAISS/Milvus – to je ľahké, trvá sekundy na malý súbor.
• RAM: Minimálne 8 GB (doporučujem 16 GB pre pohodlie). Pre väčšie PDF (desiatky strán s obrázkami) môžeš potrebovať viac, aby sa nenačítalo všetko naraz do pamäte. Ale aj s 4 GB to prejde, ak spracovávaš po častiach.
• Úložisko: Stačí pár GB voľného miesta na inštaláciu Python knižníc a dočasný index (FAISS je malý).
• GPU: Nie je potrebná! Modely Granite (embeddingy aj generácia) bežia na serveroch cez API. Žiadne lokálne inference, takže žiadne NVIDIA karty alebo VRAM.
• Internet: Stabilné pripojenie – API volania (napr. na Replicate alebo watsonx.ai) sú základ. Každé embedovanie alebo query môže trvať 1–10 sekúnd v závislosti od zaťaženia servera.

Príklad minimálneho setupu: Starší laptop s Windows/Linux/Mac, Python 3.10+ inštalovaný. Celé to spustíš v Jupyter Notebooke alebo VS Code.2.

Odporúčaný Spôsob: Google Colab (Zadarmo a Bez Bolesti)

Notebook je explicitne navrhnutý pre Google Colab – to je cloudový Jupyter, kde beží na Google serveroch (zdarma tier: ~12 GB RAM, CPU zadarmo; Pro: GPU za 10 €/mesiac, ak chceš urýchliť lokálne časti).

• Prečo Colab?
  • Žiadna inštalácia lokálne.
  • Automatická správa závislostí (pip install v bunke).
  • Prístup k API kľúčom cez secrets (bezpečne).
• Čas na spustenie: 5–10 minút na setup, potom test na sample PDF trvá minúty.
• Limity: Free Colab má obmedzený runtime (12 hodín), ale pre prototypy stačí. Ak máš veľké dáta, choď na Colab Pro.

Lokálny Setup (Ak chceš offline prácu s dátami)

Ak nechceš clud, spusti to lokálne:

• Prostredie: Vytvor virtuálne prostredie s venv alebo Conda (Python 3.10–3.12).
• Závislosti: Inštaluj cez pip (z blogu: langchain, faiss-cpu, pymupdf, pillow, ibm-generative-ai alebo replicate). Celkovo ~500 MB.
• Výkon: Na 10-stranovom PDF s 5 obrázkami:
  • Extrakcia: <1 min (CPU).
  • Embeddingy: 10–60 sekúnd (API volania, závisí od siete).
  • Retrieval + generácia: 2–5 sekúnd na query.

Ak pridáš Docling (pre lepšie PDF parsing, ako v niektorých variantoch) bude to stále ľahké, ale potrebuješ transformers (~1 GB na stiahnutie embedding modelu lokálne – ale v notebooku je to voliteľné).

Potenciálne úskalia a tipy na optimalizáciu

• Čas na API: Vision modely (pre obrázky) môžu byť pomalé (až minúty na veľký obrázok), ale to je chyba servera, nie tvojho HW. Riešenie: Batchuj menšie chunk-y alebo použi rýchlejšie API (watsonx.ai je optimalizované).
• Veľké Dáta: Pre stovky PDF potrebuješ viac RAM (32 GB+) alebo rozdeľ do batchov. FAISS index môže rásť na GB.
• Ak Chceš Lokálne Modely: Ak by si chcel Granite spustiť offline (nie cez API), pozri Granite 4.0 Tiny (z 2025) – potrebuješ ~8 GB VRAM na GPU (napr. RTX 3060) pre základné úlohy. Ale to nie je pre tento notebook – ten je API-only.
• Najskôr testuj: Stiahni notebook z GitHubu, otvor v Colab a spusti prvé bunky. Ak sa to zasekne, je to zvyčajne kvôli API kľúču (zdarma na Replicate alebo IBM).

Zhrnutie: Nemusíš kupovať nový PC – stačí tvoj aktuálny setup s internetom. Ak máš slabší stroj, choď rovno do Colab.

Predstavte si, že máte dokument plný textu, grafov, diagramov a fotografií. Ako by ste chceli, aby váš AI asistent nielen prečítal slová, ale aj "pochopil" obrázky a spojil ich do súvislého celku?

To je presne to, čo ponúka multimodálny Retrieval-Augmented Generation (RAG). Pozrieme sa na praktickú implementáciu takéhoto systému pomocou modelov Granite od IBM. Ak viete, čo je RAG (teda ako sa LLM "dopĺňajú" externými dátami na presnejšie odpovede), toto bude prirodzený krok vpred.

Rozšíriť ho o obrázky znamená, že váš systém sa stane univerzálnejším – ideálny pre technické reporty, medicínske štúdie alebo marketingové materiály, kde vizuály hovoria viac ako tisíc slov.

Poďme na to krok za krokom – ako keby sme spoločne kodovali v Colab-e.

Čo Je Multimodálny RAG a Prečo ho potrebujete?

Klasický RAG funguje tak, že vezmete otázku používateľa, nájdete relevantné úryvky z vašej databázy (pomocou embeddingov a vektorovej podobnosti), a potom ich "nastrčíte" do LLM na generovanie odpovede. Výsledok? Menej halucinácií a viac faktov. Multimodálny RAG to posúva na vyšší level. Namiesto len textu zvláda aj obrázky, videá alebo iné médiá. Kľúč je v zdieľanom vektorovom priestore: Modely ako Granite vytvárajú embeddingy (vektory), ktoré reprezentujú text aj obrázky rovnako, takže môžete hľadať "podobnosť" medzi nimi. Napríklad: "Aký je trend na grafe?" – systém nájde relevantný obrázok, popíše ho a spojí s textom.

Prečo to je cool? V reálnom svete sú 80 % dát vizuálne (podľa niektorých štúdií). Predstavte si AI, ktoré analyzuje PDF s finančnými správami, kde tabuľky a grafy sú kľúčové. Bez multimodality by ste stratili polovicu kontextu. Granite modely (otvorené a efektívne) to robia dostupným bez potreby obrovských GPU.

Úvod do Modelov Granite: IBM's tajná zbraň

Granite je rodina modelov od IBM, navrhnutá pre podnikové použitie – otvorená, bezpečná a optimalizovaná pre RAG. Tu sú kľúčové hráči v našom recepte:

• Granite 3.0 8B Multimodal Embed: Vytvára embeddingy pre text + obrázky. Rozmer okolo 768, čo je efektívne pre rýchle vyhľadávanie.
• Granite 3.0 8B Instruct: LLM na generovanie odpovedí, inštrukčne vyladený pre presnosť.

Tieto modely sú dostupné cez IBM Watsonx.ai API – zadarmo na testovanie s limitmi, alebo plne cez predplatné. Ak ste fanúšik open-source, Granite je ako Llama, ale s podnikovým šmrncom: lepšia podpora pre dlhé kontexty a menej biasu.

Krok 1: Nastavenie Prostredia – Rýchlo a Jednoducho

Predtým, než sa pustíme do kódu, potrebujete:

• Python prostredie: Použite Google Colab alebo lokálny Jupyter notebook (Python 3.10+).

API kľúče: Zaregistrujte sa na IBM Watsonx.ai, získajte API key a Project ID. Nastavte ich ako environment variables:python

import os
os.environ["API_KEY"] = "váš_api_key"
os.environ["PROJECT_ID"] = "váš_project_id"

Inštalujte knižnice – toto je z notebooku, ale pridám tipy

!pip install -q langchain langchain-community faiss-cpu pymupdf pillow ibm-generative-ai

• LangChain: Orchestrácia RAG (ak ho nepoznáte, je to ako "Lego" pre LLM pipeline).
• FAISS: Vektorový databázový engine od Facebooku – super rýchly na podobnosť.
• PyMuPDF (fitz): Na extrakciu textu a obrázkov z PDF.
• Pillow: Manipulácia s obrázkami.

Overte setup jednoduchým testom: Načítajte model a embedujte testovací text. Ak dostanete vektor, ste ready. Čas: 5 minút.

Krok 2: Príprava Dát – Z PDF do multimodálnych chunkov

Tu sa to stáva zaujímavým. Väčšina reálnych dát je v PDF, ktoré miešajú text a vizuály. Notebook používa sample PDF (stiahnite si ho alebo vytvorte vlastný s grafmi).

Logika:

• Načítajte PDF: doc = fitz.open("sample.pdf").
• Prechádzajte stránky: Extrahujte text bloky a detegujte obrázky (ako base64 alebo PIL objekty).
• Rozdeľte text: Použite RecursiveCharacterTextSplitter na chunkovanie do ~500 tokenov (pre zachovanie kontextu bez preťaženia).
• Spojte: Každý chunk = {'text': "úryvok", 'image': obrázok, 'metadata': {'strana': 2}}.

Ak máte len textové PDF, pridajte placeholder obrázky.

Výstup: 5-10 chunkov z 3-stranového PDF.
Príklad: "Načítal som 5 chunkov, 2 s obrázkami." Toto je srdce multimodality – systém "vidí" obrázok ako súčasť textu, nie ako samostatný súbor.

Krok 3: Generovanie Embeddingov – Spojenie svetov textu a obrázkov

Teraz magický moment: Použite Granite embedder na vytvorenie vektorov.

from langchain.embeddings import IBMGenerativeAIEmbeddings
embeddings = IBMGenerativeAIEmbeddings(model="ibm/granite-3.0-8b-multimodal-embed")

Pre každý chunk: vec = embeddings.embed_documents([text, image_base64]) – model spracuje pár naraz, vytvorí jeden vektor reprezentujúci celok. Prečo to funguje? Granite je trénovaný na pároch text-obrázok, takže embedding zachytáva semantiku: "Graf ukazuje rast predaja" sa spojí s čiarovým diagramom.
Výstup: Lista vektorov (napr. [0.1, -0.3, ...] pre každý chunk).
Čas: 10-30 sekúnd na malý dataset.
Tip: Pre veľké súbory batchujte embeddingy, aby ste ušetrili API volania.

Krok 4: Vytvorenie Vektorovej Databázy s FAISS

Nemôžete len tak držať vektory v pamäti – potrebujete index pre rýchle vyhľadávanie.

from langchain.vectorstores import FAISS
vectorstore = FAISS.from_embeddings((text_embeddings, documents), embedding=embeddings)
vectorstore.save_local("moj_index")

FAISS používa L2 metriku (Euklidovskú vzdialenosť) na nájdenie top-k podobných. Prečo FAISS? Je open-source, rychlý (milióny vektorov za sekundy) a integruje sa s LangChain. Uložte index lokálne – nabudúce ho načítajte bez opakovania embeddingov.
Výstup: "Index vytvorený s 5 dokumentmi."

Krok 5: Retrieval a Generácia – Srdce RAG retrieval

Na otázku embedujte query a nájdite podobné chunk-y.

query = "Čo ukazuje graf na strane 2?"
docs = vectorstore.similarity_search(query, k=3)

Vráti chunk-y s score-mi (napr. 0.85 pre relevantný graf).
Generácia: Použite LLM na syntézu:

from langchain.llms import IBMGenerativeAI
llm = IBMGenerativeAI(model="ibm/granite-3.0-8b-instruct")
# Prompt: "Na základe kontextu {docs}, odpovedz na {query}"
response = llm(f"Kontext: {docs}\nOtázka: {query}")

Výsledok: "Graf zobrazuje 20% rast predaja v Q1, ako je vidieť z čiarového diagramu."
Celý chain cez LangChain's RetrievalQA: Jedna funkcia, celý pipeline.

Notebook má super príklady – tu ich rozšírim:

1. Textová otázka: "Popíš kľúčové zistenia." – Systém nájde text + graf, vygeneruje: "Zistenia zahŕňajú 40% podiel trhu pre Produkt A, ilustrovaný koláčom."
2. Multimodálna otázka: Nahrajte obrázok (napr. iný graf) ako query. Systém ho embedne, nájde podobný v PDF a odpovie: "Tento obrázok sa podobá diagramu na strane 3, ktorý ukazuje proces s 4 krokmi."

Latencia: Retrieval ~0.2s, generácia ~1.5s na CPU. Skvelé pre prototypy!
Tip: Pre lepšiu presnosť pridajte reranking (napr. cez cross-encoder) alebo hybridné vyhľadávanie (text + obrázok score).
Záver: Vaša AI sa práve stala viditeľnejšou

Toto nie je len teória; je to skalovateľné riešenie pre appky ako chatboti pre dokumenty alebo vizuálne vyhľadávače. Skúste si to sami: Stiahnite notebook z GitHubu, upravte na vaše dáta a experimentujte. Ak chcete ísť ďalej, pozrite sa na fine-tuning embeddingov alebo integráciu s inými modalitami (audio?).

(Zdroj IBM Granite Snack Cookbook notebook: https://github.com/ibm-granite-community/granite-snack-cookbook/blob/main/recipes/RAG/Granite_Multimodal_RAG.ipynb)