Jak na ChatGPT API pro souhrn článků na Internetu. Další velmi dobrý příklad včetně kompletního skriptu 💎
Jedna z velmi častých věcí pro zdejší newsletter, ale i pro #tyden. Shrnout článek odněkud do odstavce textu. Není to až tak triviální, jak by se mohlo zdát.
Tento příspěvek je bonus pro platící odběratele newsletteru 365tipů. Extra obsah můžete mít za 5 USD měsíčně, 50 USD ročně. Za 14 dní od vydání se tento tip odemkne.
Nahradil jsem DeepL (viz Jak na ChatGPT API pro překlad z a do češtiny) a na klávesové zkratce mám překlad clipboard z/do češtiny (sám pozná kam překládat). A potřeboval jsem ještě souhrn v podobě dvou/tří odstavců. Vlastně tak nějak, jak to (třeba) dělá TechMeme.
V klasické webové/aplikační ChatGPT to můžete udělat snadno, hodíte tam URI článku a řeknete, ať vám udělá zpravodajský souhrn, maximálně 3 věty a případně to ještě trochu omezíte. Má ale tendenci si vymýšlet, na adresu se prostě často vůbec nepodívá a taky je strašně ochotná tím, že tam přidává věci, které tam ani nechcete. Souvislosti a tak.
Přes API to má jednu výhodu, udělá jen to co po ní chcete a na Internet stejně nemůže jít. Ten článek jí totiž musíte dovat vy jako součást zadání (promptu).
Je a to trochu dražší než obyčejný překled, protože na vstupu budete mít článek - stovky až tisíce znaků a je s tím spojených pár zádrhelů.
článek bude stahovat váš Python a často narazí na to, že ho médium zablokuje jako robota
z URL nemůžete poslat do ChatGPT všechno, jde vám jenom o článek jako takový, ne to smetí okolo
moc dlouhé články je praktické poslat do ChatGPT postupně
ChatGPT má každopádně výhodu v tom, že je jedno v jakém jazyce článek je, ale musíte přesně striktně určit, že výsledek má být česky.
Opět si vezmete na pomoc ChatGPT
Vlastně nemusíte umět programovat, protože ChatGPT vám skript vytvoří sama (pro Python) a pomůže i s promptem. Tady ale už to není tak snadné jako poslat, přeložit, získat zpět. Při vytváření skriptů narazíte totiž na výše uvedené zádrhele.
Anti-robotická ochrana je řešitelná tak, že posíláte košatý user-agent co odpovídá (třeba) Chrome. Na tom ChatGPT na první dobrou nepřišla, ale když se dozvěděla o chyb 40x, tak jí to došlo.
Do user-agent ale pak přidala accept-encoding pro gzip, takže jsem překvapeně zíral, že místo článku dorazil nějaký binární kód. Vtipné je, že když jí ten kód ukážete, tak řekne, že to je gzip a stačilo accept-encoding vyhodit, zpět se prak vrací text.
To jak z URL dostat článek vyřešila sama hned na samém počátku, pro Python totiž existuje trafilatura a musím říct, že je to neuvěřitelně dobrá pomůcka. Postará se o to, aby ze stažené kompletní HTML stránky do ChatGPT šel opravdu jen text článku.
Vyřešila i zacházení s příliš dlouhými články rozdělením na části (po tuší 6 000 znacích max) a posláním do ChatGPT postupně a pak zpracováním těch více výsledků do jednoho. Zatím to podle všeho funguje docela dobře.
Tady už to chtělo dobré ladění
Při postupné budování skriptu jsem narazil na to, že to různě nedělá co má a řekl si, že by bylo vedle klasického pípní jednou když OK a třikrát když chyba doplnit opravdu “logování” toho co se děje.
O tohle opět můžete požádat ChatGPT ať na potřebná místa dá logování souboru (uložit tam kde je skript, při spuštění skriptu smazat) a také ať uloží co vlastně bylo staženo do ještě extra souboru (něco co jsem pak ve finální podobě skriptu vypnul.
Chce to precizní prompt
Tady už je dobrý prompt ještě víc důležitý než u překladu - musí totiž vrátit “to podstatné” a musí se to vejít do jednoho odstavce (řekněme dvě, tři věty). Při ladění se navíc ukázalo, že občas svévolně shrne do angličtiny, ačkoliv tam bylo “česky”. Ale i to řeší lépe postavený prompt, tady dokonce česky, protože anglický prompt by opět občas “chyboval”.
TECHMEME_PROMPT = (
"Shrň článek do jednoho krátkého zpravodajského briefu v češtině, ve stylu Techmeme.\n"
"Pravidla:\n"
"- 1–2 věty, celkem maximálně 35 slov.\n"
"- Zaměř se jen na hlavní děj (kdo, co, kdy); bez pozadí a komentářů.\n"
"- Uveď klíčové firmy/osoby a konkrétní čísla, pokud jsou v článku.\n"
"- VŽDY odpověz česky. Nepřidávej nic navíc. Vypiš pouze ten jeden odstavec."
)
Tohle je prozatím finální podoba, která docela funguje, byť je možné, že časem bude ještě nějaké drobné dolaďování. Těch “35 slov” je klasicky plus mínus, LLM neumějí dobře počítat, ale tady to nemusí být přesně.
Nezapomenout na teplotu
Teplota/temperature je něco, co v klasické chatgpt (web, aplikace) nemůžete ovlivnit, ale v API ano. Je to parametr, který říká Říká modelu jak moc má být „kreativní“ nebo „náhodný“ při výběru slov (číslo od nuly do jedné, ale může být i víc).
temperature = 0.0
model je deterministický: při stejném vstupu vrátí pořád stejný výstup.
nejvíc se hodí na překlady, sumarizace, faktické odpovědi.
temperature ≈ 0.7 (výchozí u hodně knihoven)
texty jsou pestřejší, méně „robotické“, ale občas uhne do méně přesného vyjádření.
hodí se na kreativní psaní, brainstorming, generování nápadů.
temperature > 1.0
model se chová až moc „divoce“, častěji nesmysly, překlepy, halucinace.
využitelné jen pro hraní / experimenty.
V sumarizační i překladovém skriptu pak asi nepřekvapi, že je použita nula.
Jaké je tady workflow?
Tenhle další kousek mého arzenálu funguje jako předchozí, tady vstupem je clipboard (v něm je uložená URL), script zavolá chatgpt a co od ní získá, uloží opět do clipboard.
Stačí jen Ctrl/Cmd+C URL, klávesovou zkratku skriptu a chvíli počkat až pípne, pak Ctrl/Cmd+V na cílové místo. Proti dřívějšímu zadávání do chatu na webu/aplikaci je to fantastická úspora času.
Chce to ale opravdu kontrolovat, jestli to shrnutí nevyrobilo nějaký renonc. A nejen proto, že to jede aktuálně přes gpt-4o-mini - pokud by to nedávalo dobré souhrny, tak je možné zkusit gpt-4o (plné) a případně pokračovat k pětkové.
Původně jsem ten předchozí překladový skript měl na jedné klávesové zkratce a tenhle sumarizační na druhé, ale lze snadno dát na jednu. Ale o tom až v další samostatném tipu, co vlastně nebude ani tak o ChatGPT API, ale prostě jen o Pythonu a “routeru” co zavolá správný skript podle vstupu.
O týden později, jak vypadá finální skript
Výše napsané je staré týden, od té doby se ještě udály nějaké změny ve skriptu:
Novinky vracely gzip, takže je tam přidán test a “odzipování”)
Chunking po 6000 znacích je neaktivní, respektive nastavený pro mnohem vyšší hranici. 4o-mini i 4o mají dost velké kontext windows na prakticky všechny články
A tuším že tady už je i vyřešeno natažení API klíče z .env (a není tedy přímo ve skriptu, tak jak to má být)
Ale hlavně, postupně jsem zkoušel různé prompty pro sumarizaci. Takže v následujícím kompletním aktuálním kódu jsou vidět i ty různé varianty. A místo 4o-mini je tak plná 4o - dává přeci jen lepšá výsledky, byť je mírně dražší. Ale testovat se musí.
#!/usr/bin/env python3
# @raycast.schemaVersion 1
# @raycast.title Summarize URL to Czech brief
# @raycast.mode silent
# @raycast.packageName AI Tools
# @raycast.icon 📰
import os, sys, re, json, subprocess, urllib.error, traceback, datetime, pathlib
import urllib.request
from dotenv import load_dotenv
load_dotenv()
# --- Log do stejné složky jako skript (při startu vymažeme) ---
LOG_FILE = pathlib.Path(__file__).with_suffix(".log")
LOG_FILE.write_text("", encoding="utf-8")
def log(msg: str):
timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
with open(LOG_FILE, "a", encoding="utf-8") as f:
f.write(f"[{timestamp}] {msg}\n")
# --- KONFIG ---
API_KEY = os.getenv("OPENAI_API_KEY")
# MODEL = "gpt-4o-mini"
MODEL = "gpt-4o"
CHUNK_CHARS = 6000
TECHMEME_PROMPT = (
"Shrň článek do jednoho krátkého zpravodajského briefu v češtině, ve stylu Techmeme.\n"
"Pravidla:\n"
"- 1–2 věty, celkem maximálně 35 slov.\n"
"- Zaměř se jen na hlavní děj (kdo, co, kdy); bez pozadí a komentářů.\n"
"- Uveď klíčové firmy/osoby a konkrétní čísla, pokud jsou v článku.\n"
"- VŽDY odpověz česky. Nepřidávej nic navíc. Vypiš pouze ten jeden odstavec."
)
HEADLINE_PROMPT3 = (
"Převeď článek do jedné až dvou vět, jako kdybys psal titulek na titulní stranu velkého média.\n"
"Pravidla:\n"
"- Maximálně 30 slov.\n"
"- Úderný, chytlavý, snadno srozumitelný pro laiky.\n"
"- Zvýrazni drama, klíčový spor nebo zásadní otázku.\n"
"- Používej aktivní jazyk, ne suché konstatování.\n"
"- Vždy odpověz česky. Vypiš pouze titulek/krátký text, nic navíc."
)
HEADLINE_PROMPT = (
"Převeď článek do jedné až dvou vět, jako titulek na titulní stranu.\n"
"Pravidla:\n"
"- Maximálně 30 slov.\n"
"- Úderný, chytlavý, pro laiky.\n"
"- Zvýrazni drama/kontrast/otázku.\n"
"- Aktivní jazyk, žádné suché konstatování.\n"
"- Nepoužívej vykřičníky ani CAPS; povoleno jen . , : – ? ; max. 1 otazník.\n"
"- Větu ukonči tečkou NEBO otazníkem (nikdy vykřičníkem). Pokud bys použil '!', nahraď jej tečkou.\n"
"- Vždy česky. Vrať pouze titulek."
)
HEADLINE_PROMPT2 = (
"Zapomeň na shrnutí. Jsi novinový titulkář.\n"
"Tvým úkolem je z článku udělat 1–2 věty, které čtenáře okamžitě přitáhnou.\n"
"Pravidla:\n"
"- Délka 22–32 slov.\n"
"- Úderný, chytlavý, může být i řečnická otázka.\n"
"- Zvýrazni velkou sázku, riziko nebo kontrast.\n"
"- Používej silná slovesa a obrazný jazyk (např. 'spaluje', 'vsází všechno', 'honba za svatým grálem').\n"
"- Vyhni se neutrálním frázím typu 'Společnost X, vedená Y…'.\n"
"- Vždy česky. Vrať jen titulek/perex, nic víc."
)
DUAL_PROMPT = (
"Zpracuj článek do dvou verzí:\n\n"
"1) TECHMEME BRIEF:\n"
"- 1–2 věty, max. 35 slov.\n"
"- Suchý, faktický, neutrální zpravodajský styl (Techmeme).\n"
"- Uveď klíčové osoby/firma a čísla.\n\n"
"2) HEADLINE:\n"
"- 1 věta, max. 18 slov.\n"
"- Úderný, chytlavý, expresivní jazyk.\n"
"- Zvýrazni drama nebo kontroverzi (např. 'spaluje miliardy', 'honba za svatým grálem').\n"
"- Může být i řečnická otázka.\n\n"
"Vždy odpověz česky. Vrať obě verze, jasně označené jako 'TECHMEME BRIEF:' a 'HEADLINE:'."
)
ACTIVE_PROMPT = TECHMEME_PROMPT
# --- util ---
def pbpaste() -> str:
return subprocess.check_output("pbpaste", text=True)
def pbcopy(text: str) -> None:
subprocess.run("pbcopy", text=True, input=text, check=True)
def beep(times=1):
subprocess.run(["osascript", "-e", f'beep {times}'])
# --- OpenAI chat/completions přes urllib (rychlé, bez requests) ---
def call_openai_chat(messages, max_tokens=220, temperature=0):
if not API_KEY or API_KEY.startswith("sk-proj-REPLACE_ME"):
log("ERROR: Missing API key")
print("ERROR: Missing OPENAI_API_KEY"); sys.exit(1)
url = "https://api.openai.com/v1/chat/completions"
payload = {
"model": MODEL,
"temperature": temperature,
"max_tokens": max_tokens,
"messages": messages
}
req = urllib.request.Request(
url,
data=json.dumps(payload).encode("utf-8"),
method="POST",
headers={
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json",
},
)
try:
with urllib.request.urlopen(req, timeout=60) as resp:
data = json.loads(resp.read().decode("utf-8"))
return data["choices"][0]["message"]["content"].strip()
except urllib.error.HTTPError as e:
body = e.read().decode("utf-8", errors="ignore")
log(f"HTTP {e.code} ERROR: {body}")
print(f"HTTP {e.code} ERROR:\n{body}")
sys.exit(1)
except Exception as e:
log(f"HTTP ERROR: {e}")
raise
# --- Detailní fetch se status/hlavičkami + UA jako prohlížeč ---
def fetch_with_status(url: str, timeout=20):
import gzip
headers = {
"User-Agent": ("Mozilla/5.0 (Macintosh; Intel Mac OS X 14_7) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/126.0.0.0 Safari/537.36"),
"Accept": ("text/html,application/xhtml+xml,application/xml;q=0.9,"
"image/avif,image/webp,image/apng,*/*;q=0.8"),
"Accept-Language": "en-US,en;q=0.9,cs-CZ;q=0.8,cs;q=0.7",
"Cache-Control": "no-cache",
"Pragma": "no-cache",
"Connection": "keep-alive",
"Upgrade-Insecure-Requests": "1",
}
req = urllib.request.Request(url, headers=headers)
try:
with urllib.request.urlopen(req, timeout=timeout) as resp:
status = getattr(resp, "status", None)
hdrs = dict(resp.headers)
log(f"HTTP status: {status}")
log(f"Content-Type: {hdrs.get('Content-Type', 'NA')}")
raw = resp.read()
# --- detekce gzip magic bytes ---
if raw.startswith(b"\x1f\x8b"):
try:
raw = gzip.decompress(raw)
log("Applied manual gzip decompression")
except Exception as e:
log(f"Gzip decompress failed: {e}")
# charset z Content-Type (fallback utf-8)
charset = "utf-8"
m = re.search(r"charset=([a-zA-Z0-9_\-]+)", hdrs.get("Content-Type", ""))
if m:
charset = m.group(1).strip()
try:
html = raw.decode(charset, errors="ignore")
except Exception:
html = raw.decode("utf-8", errors="ignore")
return status, hdrs, html
except urllib.error.HTTPError as e:
log(f"HTTPError {e.code}: {e.reason}")
return e.code, {}, None
except urllib.error.URLError as e:
log(f"URLError: {e.reason}")
return None, {}, None
except Exception as e:
log(f"FETCH EXCEPTION: {e}")
return None, {}, None
# --- Fallback kandidáti (AMP/print) ---
def try_fallback_urls(original_url: str):
cands = []
base = original_url[:-1] if original_url.endswith("/") else original_url
cands.extend([
base + "/amp",
base + "/amp/",
base + "?outputType=amp",
base + "?amp",
base + "/print",
base + "/print/",
])
# deduplikace v pořadí
seen, result = set(), []
for u in cands:
if u not in seen:
result.append(u); seen.add(u)
return result
# --- Extrakce článku: fetch -> (případně fallback) -> trafilatura.extract ---
def extract_article_text(url: str) -> str:
try:
import trafilatura
except Exception:
log("ERROR: chybí 'trafilatura'")
print("ERROR: chybí 'trafilatura'. Nainstaluj: python3 -m pip install --user trafilatura")
sys.exit(1)
log(f"Fetching {url}")
status, headers, html = fetch_with_status(url)
if not html or (status in (401, 403)):
log(f"Primary fetch failed or blocked (status={status}); trying fallbacks…")
for fu in try_fallback_urls(url):
log(f"Fallback fetch {fu}")
status, headers, html = fetch_with_status(fu)
if html and (status is None or 200 <= status < 300):
log(f"Fallback OK with {fu}")
break
if not html:
raise RuntimeError(f"Stahování selhalo, status={status}, hlavičky={headers}")
# Extrakce jádra článku
try:
text = trafilatura.extract(
html,
include_comments=False,
include_tables=False,
favor_recall=True,
with_metadata=False
)
except Exception as e:
log(f"trafilatura.extract exception: {type(e).__name__}: {e}")
raise
clean = (text or "").strip()
if len(clean) < 200:
# Logni náhled toho, co se povedlo vyextrahovat (max 500 znaků)
preview = (clean[:500] + ("…" if len(clean) > 500 else "")) if clean else "None"
log(f"Extraction too short ({len(clean)} chars). Preview:\n{preview}")
# Pro hlubší debug ulož i část původního HTML (20 kB) vedle skriptu
debug_html = LOG_FILE.with_suffix(".debug.html")
try:
debug_html.write_text(html[:20000], encoding="utf-8", errors="ignore")
log(f"Saved first 20kB of HTML to {debug_html}")
except Exception as e:
log(f"Failed to write debug HTML: {e}")
raise RuntimeError("Extrakce nenašla dostatek článkového textu.")
# Lehké vyčištění prázdných řádků
clean = re.sub(r'\n{3,}', '\n\n', clean)
log(f"Extracted text length: {len(clean)} chars")
return clean
# --- Shrnutí (s map-reduce pro dlouhé články) ---
def call_brief(article_text: str) -> str:
return call_openai_chat([
{"role": "system", "content": ACTIVE_PROMPT},
{"role": "user", "content": article_text},
])
# Kolik znaků bezpečně pošleme v jednom zátahu (rezerva proti limitu kontextu)
SAFE_SINGLESHOT_CHARS = 80_000 # klidně zvedni na 120_000 podle modelu
def summarize_text_cz(article_text: str) -> str:
# 1) Preferuj one-shot přes celý text (lepší „příběh“ i headline)
if len(article_text) <= SAFE_SINGLESHOT_CHARS:
try:
return call_brief(article_text) # call_brief používá DUAL_PROMPT (nebo tvůj HEADLINE_PROMPT2)
except Exception as e:
# Když by to selhalo kvůli délce, spadneme na map-reduce
if "context" in str(e).lower() or "length" in str(e).lower():
log("One-shot přes limit kontextu, přecházím na chunking…")
else:
raise
# 2) Fallback: map-reduce (rychlé, ale jen fakta v map fázi)
chunks = [article_text[i:i+CHUNK_CHARS] for i in range(0, len(article_text), CHUNK_CHARS)]
log(f"Splitting into {len(chunks)} chunks")
# Důležité: v map fázi vytahuj jen telegrafická fakta, ne mikro-shrnutí (aby finále nebylo sterilní)
chunk_prompt = (
"Z následující části článku vypiš 3–6 telegrafických bodů česky.\n"
"- Pouze klíčové fakty, jména, čísla, citace (jen zásadní).\n"
"- Bez shrnutí, bez stylistiky, bez spekulací.\n"
"- Každý bod na nový řádek, bez odrážek."
)
partials = []
for idx, chunk in enumerate(chunks, 1):
part = call_openai_chat(
[{"role": "system", "content": chunk_prompt}, {"role": "user", "content": chunk}],
max_tokens=160
)
partials.append(part)
log(f"Chunk {idx} summarized ({len(chunk)} chars)")
joined = "\n".join(partials)
# Finální reduce: použij DUAL_PROMPT (nebo tvůj HEADLINE_PROMPT2, pokud chceš jen titulek)
final = call_openai_chat(
[
{"role": "system", "content": DUAL_PROMPT}, # nebo HEADLINE_PROMPT2, podle cíle
{"role": "user", "content": "PODKLADY:\n" + joined},
],
max_tokens=220,
temperature=0.6 # trochu „šťávy“ pro headline
)
return final
# --- Helpery ---
def is_url(s: str) -> bool:
return bool(re.match(r'^https?://', s.strip(), re.I))
# --- Main ---
def main():
clip = pbpaste().strip()
if not is_url(clip):
log("ERROR: Clipboard does not contain URL")
print("ERROR: Ve schránce není URL")
beep(3); sys.exit(1)
try:
article_text = extract_article_text(clip)
except Exception as e:
log("Extract ERROR: " + str(e))
print(f"ERROR: Extrakce textu selhala: {e}")
beep(3); sys.exit(1)
try:
summary = summarize_text_cz(article_text)
except Exception as e:
log("Summarize ERROR: " + str(e))
print(f"ERROR: Shrnutí selhalo: {e}")
beep(3); sys.exit(1)
pbcopy(summary)
print(summary)
log("Summary done OK")
beep(1)
if __name__ == "__main__":
try:
main()
except Exception as e:
log("FATAL ERROR: " + str(e))
log(traceback.format_exc())
print(f"ERROR: {e}")
beep(3)
sys.exit(1)