Jak skatalogować i przeszukiwać wiedzę z tmaker.io przez LLM

Raport: rozwiązanie dla tibomaker.com → baza wiedzy dostępna przez AI

Spis treści

1. Co zawiera tmaker.io?
2. Dostępne punkty wejścia do danych
3. Proponowane rozwiązanie
4. Implementacja krok po kroku
5. Automatyzacja — cron + Hermes
6. Jak zadawać pytania LLM o wiedzę z tmaker.io
7. Koszty i wymagania
8. Źródła

Co zawiera tmaker.io?

Tibo Maker (Thibault Louis-Lucas) to francuski przedsiębiorca SaaS, który zbudował i sprzedał Tweet Hunter oraz Taplio do Lempire za $8M ARR (2022). Jego strona to centrum wiedzy o:

Skala contentu

• 95 artykułów w RSS (stan na lipiec 2026)
• ~1 artykuł tygodniowo — regularne publikacje
• Blog hostowany na feather.so (Notion → blog)
• RSS dostępny pod /_feather/blog/rss.xml

Przykładowe tytuły artykułów

• "You don't need 10,000 followers to win" (9 lip 2026)
• "SEO is NOT dead" (2 lip 2026)
• "How to copy your way to $1M" (25 cze 2026)
• "How to find a $1M SaaS idea" (18 cze 2026)
• "I'll never raise VC money again" (11 cze 2026)
• "I made $10m+ from software. Ask me Anything" (4 cze 2026)

Dostępne punkty wejścia do danych

RSS — klucz do automatyzacji

<!-- RSS feed zawiera 95+ wpisów -->
<item>
  <title>You don't need 10,000 followers to win</title>
  <link>https://www.tmaker.io/blog/you-don-t-need-10-000-followers-to-win</link>
  <pubDate>Wed, 09 Jul 2026 00:00:00 GMT</pubDate>
  <description>...</description>
</item>

RSS nie zawiera pełnej treści — tylko tytuł, datę i skrócony opis. Pełną treść trzeba pobrać z linku.

Rozwiązanie

Architektura

┌──────────────────────────────────────┐
│           CRON (co tydzień)           │
│                                      │
│  1. Pobiera RSS z tmaker.io          │
│  2. Wykrywa nowe artykuły            │
│  3. Pobiera pełną treść przez Jina   │
│  4. Zapisuje jako .md w /vault/      │
│  5. Aktualizuje indeks Chroma        │
└──────────────┬───────────────────────┘
               │
               ▼
┌──────────────────────────────────────┐
│         /root/tmaker-vault/          │
│                                      │
│  ├── articles/                       │
│  │   ├── 2026-07-09-you-dont-need.md │
│  │   ├── 2026-07-02-seo-not-dead.md  │
│  │   └── ... (95 plików)             │
│  ├── index.json                      │
│  └── chroma/       (baza wektorowa)  │
└──────────────┬───────────────────────┘
               │
               ▼
┌──────────────────────────────────────┐
│         HERMES AGENT                 │
│                                      │
│  skill: tmaker-search                │
│  - "co Tibo mówi o SEO?"            │
│  - "jakie ma rady o growth?"        │
│  - "podsumuj ostatnie 5 artykułów"  │
└──────────────────────────────────────┘

Dlaczego ten stack?

Nawiązując do raportu o bazach wiedzy, dla tmaker.io rekomenduję Hermes Native + Chroma RAG:

Implementacja krok po kroku

Krok 1: Instalacja Chroma

pip install chromadb

Krok 2: Skrypt pobierający — fetch-tmaker.py

Zapisz jako /root/tmaker-vault/fetch-tmaker.py:

#!/usr/bin/env python3
"""Pobiera wszystkie artykuły z tmaker.io przez RSS + Jina Reader"""
import xml.etree.ElementTree as ET
import subprocess
import json
import os
import time
from datetime import datetime

VAULT = "/root/tmaker-vault/articles"
INDEX = "/root/tmaker-vault/index.json"
RSS_URL = "https://www.tmaker.io/_feather/blog/rss.xml"

os.makedirs(VAULT, exist_ok=True)

# 1. Pobierz RSS
print("Pobieram RSS...")
rss_raw = subprocess.check_output(["curl", "-sL", RSS_URL, "--max-time", "30"]).decode()
root = ET.fromstring(rss_raw)

# 2. Parsuj artykuły
articles = []
for item in root.findall(".//item"):
    title = item.find("title").text if item.find("title") is not None else ""
    link = item.find("link").text if item.find("link") is not None else ""
    pub_date = item.find("pubDate").text if item.find("pubDate") is not None else ""
    
    # Generuj nazwę pliku
    slug = link.rstrip("/").split("/")[-1]
    date_str = datetime.strptime(pub_date[:11], "%d %b %Y").strftime("%Y-%m-%d")
    filename = f"{date_str}-{slug}.md"
    
    articles.append({
        "title": title,
        "link": link,
        "date": date_str,
        "file": filename,
    })

print(f"Znaleziono {len(articles)} artykułów w RSS")

# 3. Pobierz tylko nowe artykuły (pomiń już istniejące)
existing = set(os.listdir(VAULT))
new_count = 0

for art in articles:
    if art["file"] in existing:
        continue
    
    print(f"  Pobieram: {art['title'][:60]}...")
    try:
        # Jina Reader: konwertuje HTML → Markdown
        result = subprocess.check_output(
            ["curl", "-s", "-H", "Accept: text/plain",
             f"https://r.jina.ai/{art['link']}", "--max-time", "30"]
        ).decode()
        
        # Zapisz jako markdown
        filepath = os.path.join(VAULT, art["file"])
        with open(filepath, "w") as f:
            f.write(f"# {art['title']}\n\n")
            f.write(f"**Data:** {art['date']}  \n")
            f.write(f"**Źródło:** {art['link']}\n\n---\n\n")
            f.write(result)
        
        new_count += 1
        time.sleep(1)  # Szanuj rate limit Jina
    except Exception as e:
        print(f"  ❌ Błąd: {e}")

print(f"Pobrano {new_count} nowych artykułów")

# 4. Zapisz indeks
with open(INDEX, "w") as f:
    json.dump(articles, f, indent=2)
print(f"Indeks zapisany: {INDEX}")

Krok 3: Skrypt indeksujący Chroma — index-chroma.py

#!/usr/bin/env python3
"""Indeksuje artykuły z tmaker.io w Chroma DB"""
import chromadb
import os
import json

VAULT = "/root/tmaker-vault/articles"
CHROMA_PATH = "/root/tmaker-vault/chroma"

client = chromadb.PersistentClient(path=CHROMA_PATH)

# Usuń starą kolekcję i stwórz nową (lub użyj get_or_create)
try:
    client.delete_collection("tmaker-articles")
except:
    pass

collection = client.create_collection("tmaker-articles")

# Indeksuj wszystkie artykuły
articles = [f for f in os.listdir(VAULT) if f.endswith('.md')]
print(f"Indeksuję {len(articles)} artykułów...")

for i, filename in enumerate(articles):
    filepath = os.path.join(VAULT, filename)
    with open(filepath) as f:
        content = f.read()
    
    collection.add(
        documents=[content],
        metadatas=[{"filename": filename}],
        ids=[filename.replace(".md", "")]
    )
    
    if (i + 1) % 20 == 0:
        print(f"  {i + 1}/{len(articles)}...")

print(f"Zindeksowano {len(articles)} artykułów w Chroma DB")

Krok 4: Skrypt zapytań — query.py

#!/usr/bin/env python3
"""Zadaje pytanie do bazy wiedzy tmaker.io"""
import chromadb
import sys

CHROMA_PATH = "/root/tmaker-vault/chroma"
client = chromadb.PersistentClient(path=CHROMA_PATH)
collection = client.get_collection("tmaker-articles")

query = " ".join(sys.argv[1:]) if len(sys.argv) > 1 else "SaaS growth strategies"

results = collection.query(
    query_texts=[query],
    n_results=3
)

print(f"=== Zapytanie: {query} ===\n")
for i, (doc, meta, dist) in enumerate(zip(
    results["documents"][0],
    results["metadatas"][0],
    results["distances"][0]
)):
    print(f"--- Wynik {i+1} (trafność: {1-dist:.2f}) ---")
    print(f"Plik: {meta['filename']}")
    print(doc[:500])
    print("...\n")

Krok 5: Uruchom pierwsze pobranie

cd /root/tmaker-vault
python3 fetch-tmaker.py   # Pobiera wszystkie 95 artykułów (~5-10 minut)
python3 index-chroma.py    # Indeksuje w Chroma (~2 minuty)
python3 query.py "how to grow SaaS without VC funding"

Automatyzacja — cron + Hermes

Po pierwszym pełnym pobraniu, skonfiguruj automatyczne aktualizacje przez Hermes cronjob:

# cronjob: co tydzień (niedziela 9:00) sprawdza nowe artykuły i reindeksuje
hermes cronjob create \
  --schedule "0 9 * * 0" \
  --prompt "Uruchom kolejno:
    1. python3 /root/tmaker-vault/fetch-tmaker.py
    2. python3 /root/tmaker-vault/index-chroma.py
    3. Jeśli są nowe artykuły, wypisz ich tytuły i daty" \
  --name "tmaker-weekly-sync" \
  --deliver telegram

Skill Hermes do zadawania pytań

Utwórz skill tmaker-search w ~/.hermes/skills/tmaker-search.md:

---
name: tmaker-search
description: "Przeszukuje bazę wiedzy z bloga Tibo Maker (tmaker.io)"
---

# Wyszukiwarka wiedzy Tibo Maker

## Jak używać

Gdy użytkownik pyta o wiedzę z bloga Tibo Maker:
1. Uruchom: `python3 /root/tmaker-vault/query.py "zapytanie użytkownika"`
2. Przeczytaj wyniki
3. Odpowiedz użytkownikowi na podstawie znalezionych fragmentów
4. Zawsze cytuj tytuł artykułu i datę

Jak zadawać pytania LLM o wiedzę z tmaker.io

Po wdrożeniu:

Tryb 1: Bezpośrednie zapytanie przez Hermes

Użytkownik: "co Tibo mówi o SEO w 2026?"
Hermes: [uruchamia python3 query.py "SEO 2026 strategy"]
        → znajduje artykuł "SEO is NOT dead" z 2 lip 2026
        → zwraca podsumowanie z cytatem

Tryb 2: RAG z pełnym kontekstem

Użytkownik: "jak zdobyć pierwszych 1000 użytkowników?"

Hermes:
1. python3 query.py "first 1000 users acquisition strategy"
2. Chroma zwraca 3 najbardziej trafne artykuły
3. Hermes łączy je z promptem użytkownika
4. Generuje odpowiedź na podstawie źródeł Tibo

Tryb 3: Podsumowanie okresowe

Użytkownik: "podsumuj artykuły Tibo z ostatniego miesiąca"

Hermes:
1. Odczytuje /root/tmaker-vault/index.json
2. Filtruje artykuły z ostatnich 30 dni
3. Dla każdego pobiera pierwsze 200 słów
4. Generuje podsumowanie w punktach

Przykładowe pytania, na które system odpowie

Koszty i wymagania

Całkowity koszt: $0. Wszystkie narzędzia są darmowe i open-source.

Źródła

Źródła (pliki)

• /root/convertere/reports/tm-jak.md — niniejszy raport
• /tmp/tm-rss2.xml — RSS feed tmaker.io (95 artykułów)
• /tmp/tm-article.md — przykładowy artykuł pobrany przez Jina Reader
• /tmp/tm-blog.md — strona bloga przez Jina Reader

Źródła (Linki URL)

• tmaker.io — strona główna Tibo Maker
• tmaker.io/blog — blog (95+ artykułów)
• tmaker.io/_feather/blog/rss.xml — RSS feed
• Jina Reader API — darmowy konwerter HTML→Markdown
• Chroma DB — open-source baza wektorowa
• Raport: Baza wiedzy z Hermes Agent — raport źródłowy o metodach budowy baz wiedzy

Raport opracowany na podstawie analizy struktury tmaker.io i rekomendacji z raportu o bazach wiedzy — lipiec 2026