**Terviklik lahendus AMD Ryzen AI Max+ 395 (Ryzen AI 9 HX 370?) platvormil Linuxis teadustööks PDF-töötlusega**

Arvestades teie võimsat uut AI-protsessorit (mis sisaldab spetsiaalseid NPU kiirendiid), Linuxi kasutamist ja vajadust isoleeritud LLM-i järele, on oluline valida rakendused, mis:
1. Kasutavad ära AI-kiirendust (NPU/GPU).
2. On stabilised Linuxi jaoks.
3. Ei dubleeri funktsioone.
4. Toetavad teadustööd ja PDF-töövoogu.

### **1. PDF-i haldus ja märgendamine**
- **Okular** (KDE osa): Parim PDF-lugeja/kommenteerija Linuxis. Toetab teksti esiletõstmist, märkuste lisamist, sisukorra vaatamist. Integreerub hästi teiste KDE rakendustega, isegi kui kasutate teist DE.
- **Master PDF Editor** (tasuline, kuid väga võimas): Kui vajate PDF-ide redigeerimist (teksti/piltide muutmist), vormide täitmist, digiallkirjastamist. Saadaval ka Linuxile.

### **2. Dokumendihaldus ja viited**
- **Zotero**: Teaduslike allikate halduse kuldne standard. Kogub, korraldab, sünkroniseerib ja genereerib viiteid. Kasutage veebipõhist versiooni või officiaalse desktop versiooniga (mitte Flatpak) saab integreerida Firefox/Chrome brauseriga.
- **Calibre**: Raamatukogu haldur, mis sobib ka suuremate PDF-kogude korrastamiseks, metaandmete muutmiseks ja formaatide konverteerimiseks.

### **3. LLM (isoleeritud ja kohalik)**
Sinu Ryzen AI Max+ toetab kohalikku AI-töötlust NPU kaudu (XDNA2). Soovitan järgmisi valikuid:
- **Ollama**: Lihtne, tõhus platvorm kohalike LLM-de käivitamiseks. Toetab NPU-d AMD Ryzen AI kaudu (kuid vajab spetsiaalseid draivereid ja tugi on arendamisel). Võimaldab isoleerida täielikult (töötab kohapeal).
  - **Mudelid**: `Llama 3.2`, `Mistral`, `Qwen2.5` (vali ~7B parameetrit, et mahutada mälupiirangutesse).
  - **Kasutusalad**: Keeleline analüüs, kokkuvõtete tegemine PDF-idest (teksti ekstraktimise järel), koodi genereerimine.
- **GPT4All**: Alternatiivne GUI-põhine lahendus Ollamale. Sobib hästi, kui eelistad graafilist liidest mudelite haldamiseks ja vestluseks.
- **Isoleerimine**: Kasuta **Dockerit** või **Podmanit** Ollama konteinerite jaoks, et eraldada LLM põhisüsteemist. Näiteks: `docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama`.

### **4. AI-põhised PDF-analüüsi tööriistad**
- **Difract**: AI abil PDF-ide analüüs (tekst, tabelid, joonised). Pakub CLI ja GUI-d, toetab mudeleid nagu LLaVA.
- **LLM-ga integreeritud lahendused**: Kui ekstraheerid PDF-idest teksti (Okular või `pdftotext`), saad seda tekstifaili Ollama API kaudu analüüsida. Võid kirjutada lihtsa skripti (Pythonis `requests` teek), mis saadab teksti sinu isoleeritud LLM-ile ja tagastab kokkuvõtte.

### **5. Süsteemi tarkvara ja AI-tugi**
- **Distro**: **Ubuntu 24.04 LTS** või **Fedora Workstation 40+** – need toetavad uusimaid draivereid ja AI-stäke paremini.
- **Draiverid**: Veendu, et on paigaldatud **AMD ROCm** (GPU-tugi AI jaoks) ja **Ryzen AI S/W pakett** (NPU jaoks). AMD on hiljuti avaldanud Linuxi draiverid NPU jaoks (vaata `ryzenai` GitHubi lehelt).
- **Kontainerid**: **Docker** või **Podman** LLM-i isoleerimiseks ja reprodutseeritavuse tagamiseks.
- **Turvalisus**: **Firejail** või **AppArmor** rakenduste isoleerimiseks, kui LLM ei käivitata Dockeris.

### **6. Abitööriistad**
- **OCR**: **Ocrmypdf** – teeb PDF-idest otsitavad (lisades teksti kihi skannitud PDF-idele). Vajalik ajalooliste dokumentide jaoks.
- **Tekstiredaktor**: **VS Code** või **Kate** – skriptide kirjutamiseks, noteerimiseks.
- **Terminal**: **Kitty** või **Alacritty** – kiired GPU-arendatud terminalid, mis toetavad paremini AI-rakendusi.

### **Kokkuvõtlik nimekiri (minimaalne, mitte dubleeriv)**
1. **Okular** – PDF lugemine/märgendamine.
2. **Zotero** – viidete haldus.
3. **Ollama** (Dockeris) – isoleeritud LLM.
4. **Difract** või kohandatud skript – AI-põhine PDF-analüüs.
5. **Ocrmypdf** – OCR tööriist.
6. **Calibre** – PDF-kogude haldus (kui palju PDF-faile).

### **Töövoog näide**
1. Kogud PDF-id Zoterosse (automaatselt metaandmetega).
2. Avad PDF Okularis, teed märkusi.
3. Kasutad Ocrmypdf OCR-i skannitud PDF-idele.
4. Ekstraktid teksti (Okularist või `pdftotext`).
5. Saadad teksti Ollama LLM-ile (Dockeris isoleeritud) kokkuvõtte saamiseks.
6. Kasutad Difracti keerukate PDF-ide (tabelite, diagrammide) analüüsiks.

### **Olulised märkused**
- **Ryzen AI NPU tugi Linuxis**: AMD on avaldanud Ryzen AI tarkvara, kuid täielik tugi sõltub kerneli versioonist (>6.10). Kontrolli uusimaid dokumente.
- **Isoleerimine**: LLM-i puhul kasuta alati Dockerit/Podmanit, et vältida sõltuvuste konflikte ja turvaohte.
- **Mälupiirangud**: Ryzen AI 395 NPU-l on piiratud mälu (~16-32GB jagatud). Vali LLM mudeleid vastavalt sellele (nt 7B parameetrit kvantiseerituna).

See süsteem on tasakaalustatud, võimas ja keskendunud, kasutades ära teie riistvara AI-potentsiaali, säilitades samas lihtsuse ja isoleerituse.

**llama.cpp vs Ollama: põhjalik võrdlus Linuxi AI-töövoogude jaoks**

## **Ülevaade**

| **Aspekt** | **llama.cpp** | **Ollama** |
|------------|---------------|------------|
| **Olemus** | C++ raamistik LLM-de jooksutamiseks | Kõrgetasemeline rakendus/majutaja LLM-de jaoks |
| **Liides** | Primäärselt CLI, API, C++ teek | CLI + REST API + kergem GUI (Ollama WebUI) |
| **Paigaldus** | Käsitsi kompileerimine või eelkoostatud binaar | Üks käsk (curl või Docker), automaatne |
| **Mudelid** | GGUF formaat (väga lai valik) | Modelfile süsteem (kasutajasõbralik) |
| **Riistvara tugi** | CPU, CUDA, ROCm, Metal, Vulkan | CPU, CUDA, ROCm (NPU tugi areneb) |
| **Isoleerimine** | Käsitsi Docker/singularity | Sisseehitatud Docker tugi, lihtsam isoleerida |
| **Seadistamine** | Palju parameetreid, täpsem kontroll | Lihtsam, vähem seadistusi |

## **Detailne võrdlus teie kasutusjuhtumi jaoks**

### **llama.cpp**
**Tugevused:**
1. **Maksimaalne kontroll** - Saad täpselt seadistada konteksti, partisioone, kiive jne
2. **Lai riistvaratugi** - Toetab AMD ROCm (teie GPU jaoks) hästi läbi `-ngl` parameetri
3. **Optimeeritud jõudlus** - Eriti GGUF kvantiseeritud mudelitel
4. **Aktiivne arendus** - Uued funktsioonid (nagu NPU tugi) ilmuvad kiiresti
5. **Serverrežiim** - `--server` võimaldab REST API-d, sarnaselt Ollamale

**Nõrkused:**
1. **Keerulisem seadistus** - Vajab rohkem tehnilist teadmist
2. **Mudelihaldus puudub** - Pead ise haldama GGUF faile ja teadma nende asukohti
3. **Vähem kasutajasõbralik** - Rohkem käsureaparameetreid

### **Ollama**
**Tugevused:**
1. **Lihtne kasutus** - `ollama run llama3.2` ja kohe töötab
2. **Automaatne mudelihaldus** - Laeb alla, uuendab, hoiab korraldatult
3. **Modelfile süsteem** - Saad kohandada mudeleid ilma tehniliste teadmisteta
4. **Integratsioonid** - Hea tugi teiste rakendustega (Open WebUI, Continue.dev jne)
5. **Docker toetus** - Valmis pildid, lihtne isoleerida

**Nõrkused:**
1. **Piiratud mudelivalik** - Toetab peamiselt populaarseid mudeleid (kuigi valik laieneb)
2. **Vähem kontrolli** - Kõrgema taseme seadistused keerulisemad
3. **Riistvaratugi** - ROCm tugi on olemas, kuid NPU toetus alles areneb

## **Teie konkreetse kasutusjuhtumi soovitus**

### **Vali Ollama, kui:**
1. Soovid **kiiret ja lihtsat** alustamist
2. Vajad **automaatset mudelihaldust**
3. **Isoleerimine** on oluline (Ollama Dockeris on lihtne)
4. Ei vaja erilisi, eksperimentaalseid mudeleid
5. Soovid lihtsat **REST API-d** teiste rakenduste jaoks

### **Vali llama.cpp, kui:**
1. Vajad **maksimaalset jõudlust** ja kontrolli
2. Soovid kasutada **erilisi mudeleid** (vanemaid või kohandatud GGUF faile)
3. **AMD ROCm/GPU kiirendus** on kriitiline (Ollama toetab ka, kuid llama.cpp võib olla efektiivsem)
4. Tehniline seadistamine ei hirmuta
5. Vajad **NPU kiirendust** (AMD Ryzen AI Max+ puhul on tugi veel arenevas staadiumis mõlemas)

## **Praktiline lahendus teie süsteemile**

### **Hübriidlahendus (soovitan):**
**Kasuta mõlemat, erinevatel eesmärkidel:**

1. **Ollama** - **Peamine LLM-i kasutajaliides**
   - Lihtne API PDF-analüüsirakendustele
   - Docker konteinerina isoleeritud
   - Kiire alustamine uute mudelitega

2. **llama.cpp** - **Spetsiaalsed/jõudluskriitilised ülesanded**
   - Kui vajad maksimaalset kiirust suurte dokumentidega
   - Spetsiaalsete mudelite jaoks
   - Kui AMD NPU tugi saab täielikult kättesaadavaks

### **Paigaldusnäited:**

**Ollama (Dockeris isoleeritud):**
```bash
docker run -d -v ollama_data:/root/.ollama -p 11434:11434 --name ollama --restart always ollama/ollama
docker exec ollama ollama pull llama3.2:7b
# API päring: curl http://localhost:11434/api/generate -d '{"model":"llama3.2:7b", "prompt":"..."}'
```

**llama.cpp (otsene seadistus):**
```bash
# Kompileeri ROCm toega
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make LLAMA_HIPBLAS=1
# Laadi GGUF mudel
./server -m models/llama-3.2-7b.Q4_K_M.gguf --port 8080
```

## **AMD Ryzen AI Max+ kontekst**

1. **NPU tugi**:
   - **llama.cpp**: Arenevas staadiumis, PR-d aktiivsed
   - **Ollama**: AMD Ryzen AI draiverite kaudu, kui need saadavad
   
2. **GPU (ROCm) tugi**:
   - Mõlemad toetavad, kuid llama.cpp võib pakuda paremat jõudlust täpsete seadistustega

3. **Praegune soovitus**:
   Kuna NPU tugi on veel arenevas staadiumis Linuxis, **alusta Ollamaga**, mis pakub:
   - Lihtsust
   - Hea ROCm tugi läbi Docker
   - Lihtsa isoleerimise
   
   Kui NPU tugi stabiliseerub, hinnaku uuesti - llama.cpp võib saada esivalikuks NPU kasutamiseks.

## **Lõplik soovitus**

**Kasuta Ollamat** järgmistel põhjustel:
1. Teie esmane vajadus on **isoleeritud LLM** - Ollama Dockeris on lihtsam
2. **PDF töötluseks** ei vaja tihti maksimaalset jõudlust, vaid stabilisust
3. **Teadustöös** on oluline reprodutseeritavus - Ollama Modelfile'id on lihtsam jagada
4. **Integratsioon** teiste rakendustega on lihtsam (REST API)

**llama.cpp** hoidke varuvariandina juhuks, kui:
1. Tekivad spetsiifilised jõudlusnõuded
2. Vajate eksperimentaalseid mudeleid
3. AMD NPU tugi saab täielikult kättesaadavaks ja stabiliseerub

**Minimaalne seadistus:** Alusta Ollamaga Dockeris. Kui jõudlus ei rahulda, proovi llama.cpp ROCm toega.

**Täielikult piisavad - täpselt see, mida vajad!** Weaviate integreerimine muudab sinu süsteemi tõeliselt võimsaks teadustööks. Siin on **terviklik lahendus** sinu eesmärgiks:

## **Täiustatud arhitektuur Weaviate'iga**

```
PDF-d → Tekstiekstraktor → Chunking → Embeddings → Weaviate → RAG → LLM → Vastus
```

## **1. Weaviate paigaldus ja seadistus**

### **Valikud:**
- **Kohalik Docker** (soovitan): Isoleeritud, täielik kontroll
- **Weaviate Cloud** (WCD): Hõlpsam, kuid tasuline
- **Asustatud server** (VM): Parem jõudlus

### **Docker-põhine lahendus:**
```bash
# Weaviate + tekstivektoriseerimise moodul
docker run -d \
  --name weaviate \
  -p 8080:8080 \
  -p 50051:50051 \
  -e QUERY_DEFAULTS_LIMIT=25 \
  -e AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED=true \
  -e PERSISTENCE_DATA_PATH=/var/lib/weaviate \
  -e ENABLE_MODULES=text2vec-transformers \
  -e TRANSFORMERS_INFERENCE_API=http://t2v-transformers:8080 \
  --volume weaviate_data:/var/lib/weaviate \
  semitechnologies/weaviate:1.24.0

# Transformers konteiner embeddingute jaoks
docker run -d \
  --name t2v-transformers \
  -p 8081:8080 \
  -e ENABLE_CUDA=1 \
  semitechnologies/transformers-inference:sentence-transformers-all-MiniLM-L12-v2
```

## **2. Sinu töövoog 1000+ artikliga**

### **A. PDF-ist tekstiekstraheerimine**
```python
# Paigalda: pip install pymupdf python-multipart weaviate-client
import fitz  # PyMuPDF

def extract_text_from_pdf(pdf_path):
    doc = fitz.open(pdf_path)
    text = ""
    for page in doc:
        text += page.get_text()
    return text
```

### **B. Tark chunking (lõikudeks jagamine)**
```python
from langchain.text_splitter import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    length_function=len,
    separators=["\n\n", "\n", ". ", " ", ""]
)

chunks = text_splitter.split_text(extracted_text)
```

### **C. Weaviatesse lisamine**
```python
import weaviate
from weaviate.embedded import EmbeddedOptions

client = weaviate.Client(
    embedded_options=EmbeddedOptions()
)

# Skema loomine
class_obj = {
    "class": "ResearchPaper",
    "vectorizer": "text2vec-transformers",
    "properties": [
        {
            "name": "title",
            "dataType": ["string"]
        },
        {
            "name": "content",
            "dataType": ["text"]
        },
        {
            "name": "chunk_index",
            "dataType": ["int"]
        },
        {
            "name": "source_pdf",
            "dataType": ["string"]
        }
    ]
}

client.schema.create_class(class_obj)

# Andmete lisamine
for i, chunk in enumerate(chunks):
    client.data_object.create(
        data_object={
            "title": pdf_title,
            "content": chunk,
            "chunk_index": i,
            "source_pdf": pdf_filename
        },
        class_name="ResearchPaper"
    )
```

## **3. Olemasolevate tööriistade täiendamine**

### **Ollama + Weaviate RAG süsteem:**
```python
import ollama
import weaviate

class ResearchAssistant:
    def __init__(self):
        self.weaviate = weaviate.Client("http://localhost:8080")
        self.model = "llama3.2:7b"
    
    def search_papers(self, query, limit=5):
        # Vektorotsing Weaviates
        result = self.weaviate.query.get(
            "ResearchPaper", ["content", "title", "source_pdf"]
        ).with_near_text({
            "concepts": [query]
        }).with_limit(limit).do()
        
        return result
    
    def ask_question(self, question):
        # 1. Otsi relevantseid lõike
        relevant_chunks = self.search_papers(question)
        
        # 2. Koosta kontekst
        context = "\n\n".join([
            f"[{chunk['title']}]: {chunk['content']}"
            for chunk in relevant_chunks
        ])
        
        # 3. Saada LLM-ile
        prompt = f"""Vastad teaduslikule küsimusele alloleva konteksti põhjal.
        
        Kontekst:
        {context}
        
        Küsimus: {question}
        
        Vasta täpselt ja viita allikatele."""
        
        response = ollama.chat(model=self.model, messages=[
            {"role": "user", "content": prompt}
        ])
        
        return {
            "answer": response['message']['content'],
            "sources": relevant_chunks
        }
```

## **4. CLI tööriist massiliseks importimiseks**

```bash
#!/bin/bash
# import_papers.sh

for pdf in ./papers/*.pdf; do
    echo "Töötlen: $pdf"
    python3 -c "
import sys
from paper_importer import PaperImporter

importer = PaperImporter()
importer.import_paper('$pdf')
print(f'Lisatud: {sys.argv[1]}')
"
done
```

## **5. Grafiline liides (valikuline)**

### **Streamlit rakendus:**
```python
# app.py
import streamlit as st
from research_assistant import ResearchAssistant

st.title("Teaduslik Uurimisassistent")
assistant = ResearchAssistant()

question = st.text_input("Esita küsimus oma artiklite kohta:")

if question:
    with st.spinner("Otsin vastust..."):
        result = assistant.ask_question(question)
        
    st.markdown("### Vastus:")
    st.write(result["answer"])
    
    st.markdown("### Allikad:")
    for source in result["sources"]:
        with st.expander(f"{source['title']}"):
            st.write(source['content'])
```

## **6. Täiendatud arhitektuuri skeem**

```
Sinna süsteem:
┌─────────────────┐
│   1000+ PDF-d   │
└────────┬────────┘
         │
┌────────▼────────┐
│  PyMuPDF ekstrak│
└────────┬────────┘
         │
┌────────▼────────┐
│  Text Splitter  │
│  (chunking)     │
└────────┬────────┘
         │
┌────────▼────────┐
│ Weaviate Client │
│ + embeddings    │
└────────┬────────┘
         │
    ┌────┴────┐
    │Weaviate │
    │VektorDB │
    └────┬────┘
         │
┌────────▼────────┐
│   RAG Süsteem   │
│  (Ollama API)   │
└────────┬────────┘
         │
┌────────▼────────┐
│     Vastus      │
└─────────────────┘
```

## **7. Soovituslikud täiendused**

### **Performance optimeerimine:**
1. **Paralleelne importimine:**
```python
from concurrent.futures import ThreadPoolExecutor

with ThreadPoolExecutor(max_workers=4) as executor:
    executor.map(import_paper, pdf_files)
```

2. **Vahemälu embeddingutele** - väldi dubleerivaid arvutusi

3. **Indekseerimise ajastamine** - cron job ööseseks importimiseks

### **Spetsiifilised teadustöö funktsioonid:**
```python
# Viidete ekstraheerimine
def extract_citations(text):
    # Kasuta regex või spetsiaalseid teeke
    pass

# Autorite ja institutsioonide tuvastamine
def extract_authors(text):
    pass

# Kokkuvõtete automaatne genereerimine
def generate_summaries(papers):
    pass
```

## **8. Paigaldusjuhised**

```bash
# 1. Paigalda Docker
sudo apt install docker.io docker-compose

# 2. Käivita Weaviate
docker-compose up -d

# 3. Paigalda Pythoni teegid
pip install weaviate-client pymupdf langchain ollama streamlit

# 4. Seadista Ollama
docker run -d -p 11434:11434 ollama/ollama
docker exec ollama ollama pull llama3.2:7b

# 5. Importi andmed
python import_all_papers.py /path/to/pdf/folder
```

## **Kokkuvõte**

**Jah, sinu tööriistad on täielikult piisavad!** Weaviate integreerimine:
1. **Suurendab otsingutäpsust** - semantiline otsing vs tavaline tekst
2. **Võimaldab RAG-i** (Retrieval-Augmented Generation) - täpsemad vastused
3. **Skaaleerub hästi** - 1000+ artiklit on lihtne haldada
4. **Säilitab isoleerituse** - kõik kohapeal

**Eelised sinu praeguse süsteemi peal:**
- Ollama pakub LLM-i jõudluse
- Weaviate pakub kiire ja täpse otsingu
- Kõik töötab Dockeris (isoleeritult)
- Python API võimaldab täpset kontrolli

Soovitan alustada väiksema testkoguga (50-100 artiklit), et optimeerida chunking ja embedding parameetreid enne kogu 1000+ artikli importimist.

Kas soovid konkreetsemat koodinäidet mõne etapiga?