Alustan **n8n-iga**, kuna see on sul juba installitud ja töötab. See on kiireim viis prototüüpida allikate kogumist ja töötlemist.

Siin on **kaks konkreetset n8n töövoo näidet** ja **Pythoni alternatiiv**:

## **VALIK 1: n8n töövoog algallikate kogumiseks**

### **A. Lihtne töövoog: RSS → tekst → PostgreSQL**

See töövoog kogub uusi artikleid RSS-ist, parsib sisu ja salvestab PostgreSQL-i.

**Sõlmed:**
1. **RSS Feed Read** - seadista RSS-iga (nt arXiv, DOAJ, Google Scholar RSS)
2. **If** - filtreeri võtmesõnade järgi (nt "ethnomathematics", "indigenous mathematics")
3. **Read PDF** - lae alla PDF-d (kui on)
4. **Extract from PDF** - parsib teksti PDF-ist
5. **Extract from Web** - kui pole PDF, võta veebilehe sisu
6. **PostgreSQL** - salvesta `source` tabelisse

**Näidis konfiguratsioonist:**

**RSS Feed Read sõlm:**
```
Feed URL: https://export.arxiv.org/rss/math.HO
```

**If sõlm:**
```
Condition: {{ $json.description.includes("ethnomathematics") }}
```

**PostgreSQL sõlm (Source tabeli jaoks):**
```sql
INSERT INTO etnomath.source 
(author, year, type, citation, doi_url, reliability_assessment, notes)
VALUES 
($1, $2, $3, $4, $5, $6, $7)
```
Parameters:
```
$1: {{ $json.author }}
$2: {{ $json.pubDate.slice(0,4) }}
$3: 'article'
$4: {{ $json.title + " - " + $json.link }}
$5: {{ $json.link }}
$6: 'keskmine'
$7: {{ "RSS: " + $json.feed }}
```

### **B. Täiendatud töövoog: failide töötlus ja vektorid**

Kui tahad lisada embeddinguid pgvector-i, siis:

1. **Read Binary Files** - loe failid kaustast `/backups/docker/postgres/sources/`
2. **Extract Text** - kasuta PyMuPDF või unstructured
3. **Split Text** - tükeldamine 500 tähemärki
4. **HTTP Request** - kutsu OpenAI embed API või lokaalne embedder
5. **PostgreSQL** - salvesta `source_chunk` ja `chunk_embedding`

---

## **VALIK 2: Pythoni kood (paindlikum)**

### **allikate_koguja.py**
```python
import requests
from bs4 import BeautifulSoup
import arxiv
import json
from datetime import datetime
import psycopg2
from psycopg2.extras import execute_values
import os

class SourceCollector:
    def __init__(self):
        self.db_conn = psycopg2.connect(
            host="localhost",
            database="ethnomath",
            user="osm",
            password="osm"
        )
        self.sources_dir = "/backups/docker/postgres/sources"
        os.makedirs(self.sources_dir, exist_ok=True)
    
    def search_arxiv(self, query="ethnomathematics", max_results=10):
        """Otsi arXiv-ist"""
        client = arxiv.Client()
        search = arxiv.Search(
            query=query,
            max_results=max_results,
            sort_by=arxiv.SortCriterion.SubmittedDate
        )
        
        sources = []
        for result in client.results(search):
            source = {
                "author": ", ".join([a.name for a in result.authors]),
                "year": result.published.year,
                "type": "preprint",
                "citation": f"{result.title}. {result.authors[0].name if result.authors else 'Unknown'}",
                "doi_url": result.entry_id,
                "reliability_assessment": "keskmine",
                "notes": f"arXiv: {result.primary_category}. Abstract: {result.summary[:200]}...",
                "full_text": None,
                "pdf_url": result.pdf_url
            }
            sources.append(source)
        
        return sources
    
    def search_doaj(self, query="ethnomathematics", rows=10):
        """Otsi DOAJ-ist (Directory of Open Access Journals)"""
        url = f"https://doaj.org/api/v2/search/articles/{query}?pageSize={rows}"
        response = requests.get(url)
        
        sources = []
        if response.status_code == 200:
            data = response.json()
            for article in data.get('results', []):
                source = {
                    "author": ", ".join(article.get('bibjson', {}).get('author', [])),
                    "year": article.get('bibjson', {}).get('year'),
                    "type": "journal_article",
                    "citation": article.get('bibjson', {}).get('title', ''),
                    "doi_url": article.get('bibjson', {}).get('identifier', [{}])[0].get('id', ''),
                    "reliability_assessment": "kõrge",  # DOAJ on peer-reviewed
                    "notes": f"Journal: {article.get('bibjson', {}).get('journal', {}).get('title', '')}",
                    "full_text": None
                }
                sources.append(source)
        
        return sources
    
    def save_to_db(self, sources):
        """Salvesta andmebaasi"""
        cur = self.db_conn.cursor()
        
        query = """
        INSERT INTO etnomath.source 
        (author, year, type, citation, doi_url, reliability_assessment, notes)
        VALUES %s
        RETURNING id
        """
        
        values = []
        for s in sources:
            values.append((
                s.get('author'),
                s.get('year'),
                s.get('type'),
                s.get('citation'),
                s.get('doi_url'),
                s.get('reliability_assessment'),
                s.get('notes')
            ))
        
        if values:
            execute_values(cur, query, values)
            self.db_conn.commit()
            print(f"Salvestatud {len(values)} allikat.")
        
        cur.close()
    
    def download_pdf(self, pdf_url, source_id):
        """Lae PDF alla ja salvesta failisüsteemi"""
        try:
            response = requests.get(pdf_url)
            filename = f"{source_id}_{datetime.now().strftime('%Y%m%d')}.pdf"
            filepath = os.path.join(self.sources_dir, filename)
            
            with open(filepath, 'wb') as f:
                f.write(response.content)
            
            return filepath
        except:
            return None
    
    def run_collection(self):
        """Käivita kogumine"""
        print("Alustan allikate kogumist...")
        
        # 1. Otsi arXiv-ist
        print("1. Otsin arXiv-ist...")
        arxiv_sources = self.search_arxiv()
        
        # 2. Otsi DOAJ-ist
        print("2. Otsin DOAJ-ist...")
        doaj_sources = self.search_doaj()
        
        # 3. Ühenda kõik allikad
        all_sources = arxiv_sources + doaj_sources
        print(f"Leidsin {len(all_sources)} allikat.")
        
        # 4. Salvesta andmebaasi
        self.save_to_db(all_sources)
        
        # 5. Lae PDF-id (valikuline)
        for i, source in enumerate(all_sources[:5]):  # Esimesed 5
            if source.get('pdf_url'):
                filepath = self.download_pdf(source['pdf_url'], i+1)
                if filepath:
                    print(f"  PDF allalaaditud: {filepath}")
        
        print("Kogumine lõpetatud.")
        self.db_conn.close()

if __name__ == "__main__":
    collector = SourceCollector()
    collector.run_collection()
```

### **requirements.txt** selle jaoks:
```txt
requests>=2.31.0
beautifulsoup4>=4.12.0
arxiv>=2.0.0
psycopg2-binary>=2.9.0
PyPDF2>=3.0.0
python-dotenv>=1.0.0
```

---

## **VALIK 3: Kombineeritud lähenemine (soovitan)**

### **n8n + Python skriptid**

**Jagage töö järgmiselt:**

| **n8n teeb** | **Python teeb** |
|--------------|----------------|
| RSS jälgimine | Teksti tükeldamine |
| Failide monitor | Embeddingud |
| Põhiline parsijut | Keerulised parsijad |
| Andmebaasi salvestus | Matemaatiline analüüs |
| Teavitused | Allikate hindamine |

### **Konkreetne plaan:**

1. **n8n töövoog 1** - "Uute allikate jälgimine"
   - RSS Feed Read (arXiv, DOAJ, Google Scholar)
   - HTTP Request (kohandatud API-dele)
   - If (filtreeri olulised)
   - PostgreSQL (lisa source tabelisse)

2. **n8n töövoog 2** - "Failide töötlus"
   - Read Binary Files (kataloogist)
   - Extract from PDF
   - Split Text
   - Execute Command (käivita Python skript embeddinguteks)

3. **Python skript** - `process_sources.py`
   ```python
   # 1. Võta töötlemata allikad DB-st
   # 2. Tee embeddingud
   # 3. Tükelda ja salvesta chunkid
   # 4. Uuenda source tabelit
   ```

4. **n8n töövoog 3** - "Kvaliteedikontroll"
   - Cron (käivita iga nädal)
   - PostgreSQL (leia allikad ilma täistekstita)
   - HTTP Request (proovi leida täisteksti)
   - If (kui leiad, uuenda)

---

## **MINU SOOVITUS SULLE:**

Kuna sul on **n8n juba installitud**, alusta sellega:

### **Samm 1 (täna): n8n põhitöövoog**
1. Loo RSS-jälgija arXiv math.HO jaoks
2. Filtreeri "ethnomathematics", "indigenous", "traditional mathematics"
3. Salvesta PostgreSQL-i `source` tabelisse

### **Samm 2 (nädal 1): PDF töötlus**
1. Loo töövoog, mis loeb failid kaustast
2. Kasuta "Extract from PDF" sõlme
3. Salvesta tekst `source_chunk` tabelisse

### **Samm 3 (nädal 2): Python täiendused**
1. Kirjuta skript embeddingute tegemiseks
2. Käivita seda n8n "Execute Command" kaudu
3. Logi tulemused

### **Samm 4 (nädal 3): Integreerimine**
1. Ühenda kõik töövoogud
2. Loo notifikatsioonid (nt Slack, email)
3. Lisa käsitsi kontrolli sõlm

---

## **Esimese n8n töövoo sammud:**

1. **Ava n8n** (localhost:5678)
2. **Loo uus töövoog**
3. **Lisa "RSS Feed Read" sõlm**
   - Feed URL: `https://export.arxiv.org/rss/math.HO`
   - Limit: 20
4. **Lisa "If" sõlm**
   - Condition 1: `{{ $json.title.includes("ethnomathematics") }}`
   - Condition 2: `{{ $json.summary.includes("indigenous") }}`
   - Operation: OR
5. **Lisa "PostgreSQL" sõlm**
   - Seadista ühendus sinu PostgreSQL-iga
   - Query: (kasuta ülal olevat INSERT-i)

6. **Lisa "Cron" sõlm algusesse**
   - Käivita iga päev kell 09:00

7. **Salvesta ja käivita töövoog**

---

## **Täiendavad allikad kogumiseks:**

### **Automaatse kogumise jaoks:**
1. **arXiv** (matemaatika ajalugu): `math.HO`
2. **DOAJ** - Directory of Open Access Journals
3. **Google Scholar RSS** (kasuta Scholar API või n8n veebiparsijat)
4. **JSTOR API** (kui sul on juurdepääs)
5. **Crossref API** (teadusartiklite metaandmed)

### **Käsitsi lisamiseks:**
1. **PDF-id kohalikust kaustast**
2. **Veebilehed** (n8n "HTTP Request" + "Extract from HTML")
3. **Markdown failid** Obsidianist
4. **Zotero eksport** (CSV või BibTeX)

---

## **Järgmised sammud pärast kogumist:**

Kui sul on 10-20 allikat, siis:

1. **Proovi ühte uurimisküsimust** - kasuta LangChaini, et luua küsimusi sinu allikate põhjal
2. **Tee lihtne otsing** - otsi "sümmeetria" või "mustrid"
3. **Loo esimene käsikiri mustand** - kasuta artikkel agenti

Kas soovid, et näitaksin:
1. **Täpsemat n8n töövoo konfiguratsiooni**?
2. **Pythoni skripti, mis parsib Zotero ekspordi**?
3. **Kuidas seada üles automaatne PDF allalaadimine**?

Alusta n8n-iga - see annab sulle kohe tulemusi ilma palju programmeerimiseta. Pythoni võid lisada hiljem, kui vajad rohkem kontrolli.