ardo/Obsidian

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:

RSS Feed Read - seadista RSS-iga (nt arXiv, DOAJ, Google Scholar RSS)
If - filtreeri võtmesõnade järgi (nt "ethnomathematics", "indigenous mathematics")
Read PDF - lae alla PDF-d (kui on)
Extract from PDF - parsib teksti PDF-ist
Extract from Web - kui pole PDF, võta veebilehe sisu
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):

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:

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

VALIK 2: Pythoni kood (paindlikum)

allikate_koguja.py

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:

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:

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)
n8n töövoog 2 - "Failide töötlus"
- Read Binary Files (kataloogist)
- Extract from PDF
- Split Text
- Execute Command (käivita Python skript embeddinguteks)

Python skript - process_sources.py

# 1. Võta töötlemata allikad DB-st
# 2. Tee embeddingud
# 3. Tükelda ja salvesta chunkid
# 4. Uuenda source tabelit

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

Loo RSS-jälgija arXiv math.HO jaoks
Filtreeri "ethnomathematics", "indigenous", "traditional mathematics"
Salvesta PostgreSQL-i source tabelisse

Samm 2 (nädal 1): PDF töötlus

Loo töövoog, mis loeb failid kaustast
Kasuta "Extract from PDF" sõlme
Salvesta tekst source_chunk tabelisse

Samm 3 (nädal 2): Python täiendused

Kirjuta skript embeddingute tegemiseks
Käivita seda n8n "Execute Command" kaudu
Logi tulemused

Samm 4 (nädal 3): Integreerimine

Ühenda kõik töövoogud
Loo notifikatsioonid (nt Slack, email)
Lisa käsitsi kontrolli sõlm

Esimese n8n töövoo sammud:

Ava n8n (localhost:5678)
Loo uus töövoog
Lisa "RSS Feed Read" sõlm
- Feed URL: https://export.arxiv.org/rss/math.HO
- Limit: 20
Lisa "If" sõlm
- Condition 1: {{ $json.title.includes("ethnomathematics") }}
- Condition 2: {{ $json.summary.includes("indigenous") }}
- Operation: OR
Lisa "PostgreSQL" sõlm
- Seadista ühendus sinu PostgreSQL-iga
- Query: (kasuta ülal olevat INSERT-i)
Lisa "Cron" sõlm algusesse
- Käivita iga päev kell 09:00
Salvesta ja käivita töövoog

Täiendavad allikad kogumiseks:

Automaatse kogumise jaoks:

arXiv (matemaatika ajalugu): math.HO
DOAJ - Directory of Open Access Journals
Google Scholar RSS (kasuta Scholar API või n8n veebiparsijat)
JSTOR API (kui sul on juurdepääs)
Crossref API (teadusartiklite metaandmed)

Käsitsi lisamiseks:

PDF-id kohalikust kaustast
Veebilehed (n8n "HTTP Request" + "Extract from HTML")
Markdown failid Obsidianist
Zotero eksport (CSV või BibTeX)

Järgmised sammud pärast kogumist:

Kui sul on 10-20 allikat, siis:

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

Kas soovid, et näitaksin:

Täpsemat n8n töövoo konfiguratsiooni?
Pythoni skripti, mis parsib Zotero ekspordi?
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.

n8n - algallikate kogumine.md 11 KB Vēsture Neapstrādāts