Jak zbudowalem AI Content Hub: z 4-6h recznej pracy do 15 minut z n8n, RAG i Claude Code

Tworzenie contentu na 7 platform naraz to koszmar logistyczny. Przez miesiace robilem to recznie --- research, pisanie, formatowanie, publikacja. Kazdy temat pochlanial 4-6 godzin. Dzisiaj caly proces zajmuje 15-25 minut i generuje spojny, oparty na danych content na YouTube, TikTok, blog, Medium, LinkedIn, Instagram i Twitter. W tym artykule pokazuje dokladnie jak to zbudowalem.

Problem: 7 platform, 4-6 godzin, zero spojnosci

Moj workflow wygladal tak: otwieram przegladarke, szukam artykulow na temat, czytam 10-15 z nich, robie notatki, a potem pisze osobno na kazda platforme. Scenariusz YouTube to co innego niz post na LinkedIn, a artykul blogowy to co innego niz thread na Twitterze.

Konkretne problemy:

• Research reczny --- wyszukiwanie i czytanie artykulow bez systemu. Czesto pominialem wazne zrodla, a sam research zajmowal 1-2 godziny.
• Pisanie od zera na kazda platforme --- 7 oddzielnych plikow, kazdy w innym formacie i jezyku (PL: YouTube, TikTok, blog, Instagram; EN: Medium, LinkedIn, Twitter).
• Brak bazy wiedzy --- content oparty na tym co pamietam, nie na danych. Probowalem kiedys uzyc ChatGPT do pisania, ale bez kontekstu z prawdziwych artykulow, wynik byl generyczny i pelen hallucynacji.
• Reczna publikacja --- kopiuj-wklej na kazda platforme, formatowanie w edytorach, ustawianie SEO. To kolejne 30-60 minut.
• Zero spojnosci --- content na roznych platformach mowil troche co innego, bo pisalem w roznych momentach i zapominalem co juz napisalem.

Postanowilem to zautomatyzowac od A do Z.

Rozwiazanie: AI Content Automation Hub

Zbudowalem centralny system laczacy cztery warstwy:

Architektura

/temat [nazwa]          # Skill: pobierz 30+ artykulow
       |
       v
upload_to_pinecone.py   # Chunking 500 tok + embeddingi -> Pinecone RAG
       |
       v
/content [temat]        # 3 agenty rownolegle, RAG-grounded -> 7 plikow
       |
       v
publish_content.py      # Email approval -> auto-publish na blogu

Tech stack:

• n8n (self-hosted na Hostinger VPS) --- 10 workflow, automatyczny scheduling, webhooki
• Claude Code z 22 skillami --- komendy /temat, /content, /blog-post, /publikuj, /pipeline
• 16 skryptow Python --- fetch_content.py, upload_to_pinecone.py, rag_query.py, publish_content.py i inne
• Pinecone RAG --- index rag, 3072 wymiarow, model text-embedding-3-large, 1000+ wektorow
• Blog Next.js 15 na aiagents.biz.pl --- Docker, auto-publish przez REST API

Kluczowe decyzje projektowe

Self-hosted n8n zamiast cloud. Wersja cloudowa n8n ma limity executions. Na wlasnym VPS za $10/miesiac mam pelna kontrole i zero limitow. 10 workflow, automatyczne triggery 3x w tygodniu, webhooki --- wszystko dziala 24/7.

RAG-first zamiast generowania z powietrza. Kazdy content zaczyna sie od query do Pinecone. Zamiast prosic LLM o napisanie artykulu o "automatyzacji AI", daje mu 8 fragmentow prawdziwych artykulow jako kontekst. Roznica w jakosci jest kolosalna.

3 agenty rownolegle zamiast sekwencyjnych. Jeden agent generuje content PL (YouTube, TikTok, Instagram), drugi pisze artykul blogowy, trzeci tworzy content EN (Medium, LinkedIn, Twitter). Dzieki temu 7 plikow powstaje w 3-7 minut zamiast 15-20.

Detale techniczne

Chunking i indeksowanie w Pinecone

Serce systemu to skrypt upload_to_pinecone.py. Kazdy artykul MD jest dzielony na chunki po ~500 tokenow z nakladka 50 tokenow, embedowany modelem text-embedding-3-large i wgrywany do Pinecone w batchach po 100.

# upload_to_pinecone.py - konfiguracja chunkingu

PINECONE_INDEX = "rag"
EMBEDDING_MODEL = "text-embedding-3-large"
EMBEDDING_DIM = 3072
CHUNK_SIZE = 500       # tokenow
CHUNK_OVERLAP = 50     # tokenow nakladki
UPSERT_BATCH = 100     # wektorow na batch

enc = tiktoken.encoding_for_model("gpt-4o")

def chunk_text(text, chunk_size=CHUNK_SIZE, overlap=CHUNK_OVERLAP):
    """Dzieli tekst na chunki po ~chunk_size tokenow z nakladka."""
    tokens = enc.encode(text, disallowed_special=())
    chunks = []
    start = 0

    while start < len(tokens):
        end = start + chunk_size
        chunk_tokens = tokens[start:end]
        chunk_text = enc.decode(chunk_tokens)
        chunks.append(chunk_text)

        if end >= len(tokens):
            break
        start = end - overlap

    return chunks

Dlaczego 500 tokenow? Testowalem rozne wartosci. Przy 200 tokenach kontekst byl za krotki i fragmenty tracily sens. Przy 1000 tokenow embedding byl zbyt rozmyty i wyniki wyszukiwania mniej trafne. 500 z overlap 50 to balans miedzy precyzja a kontekstem.

Odpytywanie RAG przed generowaniem contentu

Zanim jakikolwiek agent zacznie pisac, skrypt rag_query.py odpytuje Pinecone o kontekst. Query przechodzi przez dwa namespace'y (default + articles) i zwraca top-8 fragmentow ze score powyzej 0.3.

# rag_query.py - query do dwoch namespace'ow Pinecone

PINECONE_URL = "https://rag-lujoiy5.svc.aped-4627-b74a.pinecone.io/query"

def rag_query(topic, keyword="", top_k=8):
    """Query Pinecone RAG - zwraca liste fragmentow z bazy wiedzy."""
    query_text = f"{topic} {keyword}".strip()

    # 1. Embedding zapytania
    emb_resp = requests.post(
        "https://api.openai.com/v1/embeddings",
        headers={"Authorization": f"Bearer {OPENAI_API_KEY}"},
        json={"model": "text-embedding-3-large", "input": query_text},
    )
    vector = emb_resp.json()["data"][0]["embedding"]

    # 2. Query obu namespace'ow Pinecone
    contexts = []
    for namespace in [None, "articles"]:
        body = {"vector": vector, "topK": top_k, "includeMetadata": True}
        if namespace:
            body["namespace"] = namespace

        resp = requests.post(PINECONE_URL, headers=pinecone_headers, json=body)
        if resp.status_code == 200:
            matches = resp.json().get("matches", [])
            for m in matches:
                if m.get("score", 0) > 0.3:
                    contexts.append({
                        "text": m["metadata"]["text"],
                        "score": m["score"],
                        "title": m["metadata"].get("title", ""),
                    })

    # Deduplikacja i sortowanie
    contexts.sort(key=lambda x: x["score"], reverse=True)
    return unique[:top_k]

Ten kontekst jest nastepnie wstrzykiwany do promptu kazdego z 3 agentow. Dzieki temu content jest zakorzeniony w prawdziwych danych, a nie w wiedzy ogolnej modelu.

Pipeline publikacji z human-in-the-loop

Skrypt publish_content.py parsuje frontmatter YAML bez zewnetrznej biblioteki (celowo --- mniej zaleznosci), buduje payload JSON i wysyla go na webhook n8n content-approval. Stamtad leci email z podgladem do akceptacji.

# publish_content.py - parsowanie frontmatter bez pyyaml

def parse_frontmatter(content):
    """Parsuje YAML frontmatter z pliku Markdown (bez pyyaml)."""
    if not content.startswith("---"):
        return {}, content

    parts = content.split("---", 2)
    if len(parts) < 3:
        return {}, content

    fm_text = parts[1].strip()
    body = parts[2].strip()
    frontmatter = {}

    for line in fm_text.split("\n"):
        line_stripped = line.strip()
        if ":" in line_stripped and not line_stripped.startswith("-"):
            k, v = line_stripped.split(":", 1)
            k, v = k.strip(), v.strip()
            if v.startswith("[") and v.endswith("]"):
                items = v[1:-1].split(",")
                frontmatter[k] = [i.strip().strip('"') for i in items]
            else:
                frontmatter[k] = v.strip('"').strip("'")

    return frontmatter, body

Po kliknieciu "Approve" w mailu, n8n automatycznie publikuje artykul na blog przez API:

POST https://aiagents.biz.pl/api/blog
Authorization: Bearer $BLOG_API_KEY
Content-Type: application/json

{
  "title": "...",
  "content": "...",
  "category": "case-study",
  "tags": ["AI", "automatyzacja"],
  "seo": { "metaTitle": "...", "metaDescription": "...", "focusKeyword": "..." }
}

Workflow n8n --- harmonogram i webhooki

10 aktywnych workflow obsluguje rozne czesci systemu:

| Workflow | Harmonogram | Funkcja | |---|---|---| | AI News Content Generator | pon/sr/pt 08:00 | Automatyczne newsy AI | | SEO Rank Checker | poniedzialek 07:00 | Monitoring pozycji | | Medium Article Generator | wtorek 09:00 | Artykuly EN | | Blog Post Generator | webhook on-demand | Publikacja na blogu | | Article Approve & Publish | email trigger | Akceptacja contentu |

Caly scheduling oparty jest na cron triggerach w n8n. Nie musze pamietac o niczym --- system sam generuje newsy 3 razy w tygodniu, sprawdza SEO w poniedzialek i proponuje artykuly we wtorek.

Wyniki

Oto konkretne metryki po kilku miesiacach dzialania systemu:

Czas

| Etap | Przed | Po | Redukcja | |---|---|---|---| | Research (30+ artykulow) | 1-2h | 5-15 min (/temat) | ~85% | | Generowanie contentu (7 plikow) | 2-3h | 3-7 min (/content) | ~90% | | Publikacja i formatowanie | 30-60 min | 1-2 min (/publikuj) | ~95% | | Lacznie | 4-6h | 15-25 min | ~80% |

Skala

• 864 artykuly MD w 20 folderach tematycznych w research/
• 1000+ wektorow zaindeksowanych w Pinecone RAG
• 10 aktywnych workflow n8n z ponad 10 000 executions
• 22 skilli Claude Code i 16 skryptow Python
• 7 plikow na 7 platform z jednego tematu, w jednym ujednoliconym procesie

Koszt

• Embeddingi + query Pinecone: < $0.10 za artykul
• VPS Hostinger (n8n): $10/miesiac
• Pinecone: darmowy tier (starter) wystarcza przy 1000+ wektorach
• Laczny koszt operacyjny: ~$10-15/miesiac za caly system

Dla porownania --- gdybym zlecal pisanie 7 plikow contentu freelancerowi, jeden temat kosztowalbym $50-100. System zwrocil sie w pierwszym tygodniu.

Lekcje

1. RAG-first to absolutny game changer

Najwieksza roznica w jakosci contentu przyszla nie od lepszego modelu LLM, ale od podania mu prawdziwych danych jako kontekstu. Bez RAG, GPT-4o generuje poprawny, ale generyczny content. Z RAG --- pisze o konkretnych narzediach, cytuje prawdziwe dane, odnosi sie do aktualnych trendow. To jak roznica miedzy rozmowa z osoba ktora "cos slyszala" a taka ktora przeczytala 30 artykulow na temat.

2. Trzy rownolegle agenty to sweet spot

Testowalem rozne konfiguracje. Jeden agent na 7 plikow --- za wolno (15-20 minut) i traci kontekst pod koniec. Siedem agentow (po jednym na plik) --- chaos, duplikacje, niespojnosc. Trzy agenty pogrupowane tematycznie (PL Video+Social, PL Blog, EN International) to optymalny balans miedzy szybkoscia a spojnoscia.

3. Human-in-the-loop jest krytyczny

Na poczatku chcialem pelna automatyzacje --- research, generowanie, publikacja bez mojego udzialu. Szybko sie okazalo, ze to zly pomysl. Jeden bledny content opublikowany automatycznie moze zniszczyc wiarygodnosc. Email approval w n8n dodaje 30 sekund do procesu, ale daje mi pelna kontrole nad tym co wychodzi publicznie.

4. Self-hosting n8n daje pelna kontrole

Zaczynalem od n8n Cloud, ale szybko uderzylem w limity executions. Przeniesienie na wlasny VPS za $10/miesiac dalo mi nieograniczone wykonania, pelna kontrole nad danymi i mozliwosc customizacji. Przy 10 000+ executions, n8n Cloud bylby wielokrotnie drozszy.

5. Chunking 500 tokenow z overlap 50 to optymalny balans

To nie jest wartosc ktora wymyslilem --- to wynik testow. Przy mniejszych chunkach (200 tok) wyszukiwanie w Pinecone bylo precyzyjniejsze, ale fragmenty nie niosly wystarczajacego kontekstu. Przy wiekszych (1000 tok) embeddingi byly za "rozmyte". 500 z 50 tokenami overlap zapewnia, ze kazdy chunk ma sens samodzielnie i ze na granicach chunkow nie tracimy informacji.

Podsumowanie

AI Content Automation Hub to system ktory zamienil 4-6 godzin recznej pracy w 15-25 minut zautomatyzowanego pipeline'u. Kluczowe skladniki to: baza wiedzy RAG w Pinecone (zamiast polegania na pamieci LLM), rownolegle agenty (zamiast sekwencyjnego generowania), n8n jako silnik orkiestracji (zamiast recznego triggerowania) i human-in-the-loop (zamiast slepej automatyzacji).

Jesli budujesz wlasny system contentu, zacznij od RAG. Nie od promptow, nie od agentow --- od bazy wiedzy. Reszta kladzie sie na tym naturalnie.

Caly system dziala na stosie: Python + Pinecone + n8n + Claude Code + Next.js. Laczny koszt utrzymania to ~$10-15 miesiecznie. Kod zrodlowy skryptow i konfiguracje workflow sa opisane na tym blogu --- sprawdz inne artykuly z kategorii case-study.