Wie man eine Pipeline zur Zusammenfassung von Nachrichten mit GPT erstellt

Einmal client.responses.create aufzurufen ist unkompliziert. Die Verarbeitung von 1,000 Artikeln pro Tag bedeutet auch, die Kosten zu verwalten, Fakten zu prüfen und Zusammenfassungen zu vermeiden, die nur auf einer Schlagzeile basieren. Dieser Leitfaden erklärt, welcher Workflow verwendet werden soll, wie die Kosten geschätzt werden, wie Zusammenfassungen mit den Artikeln verglichen werden, wann Prompts zwischengespeichert werden sollen und wann die vorhandene Zusammenfassung des API die GPT unnötig macht.

Eine GPT-Nachrichtenzusammenfassungs-Pipeline ist ein Produktionssystem, das Nachrichtenartikel (roh oder über API) aufnimmt, jeden Artikel basierend auf der Token-Anzahl durch eine von vier LangChain-Zusammenfassungsstrategien (stuff, map_reduce, refine oder eine benutzerdefinierte LCEL-Kette) leitet, die Ausgabe durch eine Faktizitäts-Grundungs-Überprüfung nachbearbeitet und das Ergebnis mit Metadaten für nachgelagerte Verwendungen wie Digests, Warnungen oder Audio-Briefings speichert. Im Gegensatz zu generischen Tutorials zur Zusammenfassung großer Dokumente, die eine Kette liefern und weitergehen, muss die Nachrichtenzusammenfassung kurze Artikel in großen Mengen plus gelegentliche lange Features verarbeiten, muss vor Halluzinationen auf Entitätsebene schützen, da falsche Fakten in Nachrichten Reputationsvorfälle sind, und muss bei den Kosten gegen eine kostenlose Baseline konkurrieren — die extraktive Zusammenfassung, die Ihr Nachrichten-API bereits zurückgibt.

Was Sie bauen werden

Eine Sechs-Teile-Produktionspipeline:

1. Ein grundlegender GPT-Aufruf, der einen Artikel von APITube zusammenfasst
2. Ein verketteter Router, der stuff / map_reduce / refine / benutzerdefinierte LCEL nach Artikellänge auswählt
3. Ein monatlicher Kostenrechner, der drei OpenAI-Modellstufen bei Nachrichtenvolumen vergleicht
4. Eine Entitäts-Grounding-Prüfung, die halluzinierte Fakten vor der Veröffentlichung kennzeichnet
5. Prompt-Caching, das die Eingabekosten bei einem statischen System-Prompt um ~70% reduziert
6. Ein End-to-End-Runner: APITube → deduplizieren → verketten → erden → speichern

Offenlegung

Wir sind APITube. Unser /v1/news/everything Endpunkt liefert bereits eine extraktive summary (Schlüsselsätze mit Stimmungsanalyse pro Satz) pro Artikel – für viele Anwendungsfälle ist das die richtige Antwort und Sie überspringen GPT vollständig. Wir haben diesen Leitfaden trotzdem geschrieben, da die abstrakte GPT-Zusammenfassung ihren Preis für Digests, Audio-Briefings und die Synthese mehrerer Artikel wert ist. Wir werden die Build-vs-Buy-Linie aufzeigen.

Voraussetzungen

• Python 3.10+
• openai>=1.40, langchain>=0.3, tiktoken, requests
• Ein OpenAI API-Schlüssel mit aktivierter Abrechnung
• Ein APITube-Schlüssel (kostenlose Stufe: 30 Anfragen/30 Min – genug für Prototyping)
• Vertrautheit mit Chat-Abschlüssen und grundlegenden LangChain-Primitiven

Installation:

pip install openai langchain langchain-openai tiktoken requests
export OPENAI_API_KEY=sk-...
export APITUBE_KEY=...

Schritt 1 – Baseline: Fassen Sie einen Artikel von APITube zusammen

Artikel abrufen, zusammenfassen, Token zählen. Dies ist der Aufruf, um den sich alle anderen Abschnitte optimieren.

import os, requests
from openai import OpenAI
import tiktoken

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

def get_article(query):
    res = requests.get(
        "https://api.apitube.io/v1/news/everything",
        params={"title": query, "language.code": "en", "per_page": 1},
        headers={"X-API-Key": os.environ["APITUBE_KEY"]},
    )
    res.raise_for_status()
    return res.json()["results"][0]

SYSTEM = (
    "You are a news summarizer. Produce a 3-sentence summary that includes only "
    "facts present in the article. Do not infer beyond the text."
)

def summarize(article, model="gpt-4o-mini"):
    body = article.get("body") or article["description"]
    res = openai_client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": SYSTEM},
            {"role": "user", "content": body},
        ],
        max_tokens=200,
    )
    return res.choices[0].message.content, len(enc.encode(body))

article = get_article("election")
summary, in_tokens = summarize(article)
print(in_tokens, "input tokens —", summary)

Die Antwortstruktur von APITube ist { status, results[], has_next_pages, page, request_id }. Jedes Ergebnis enthält body (vollständiger Text), description (kurze Zusammenfassung), summary (extraktiv – dazu kommen wir noch), keywords, is_duplicate und words_count. Cache body, wenn Sie neu zusammenfassen werden.

Wie fassen Sie Nachrichtenartikel mit GPT zusammen?

Um Nachrichtenartikel mit GPT zusammenzufassen, senden Sie den Artikelkörper an einen Chat-Completions-Endpunkt mit einem eng gefassten System-Prompt, der das Modell auf Fakten in der Quelle beschränkt („nur Fakten verwenden, die im Artikel vorhanden sind; keine Schlussfolgerungen ziehen“), stellen Sie eine niedrige max_tokens ein, um die Ausgabe zu begrenzen, und verarbeiten Sie sie nach, um die Entitätsgrundlage zu erfassen, um halluzinierte Namen, Zahlen oder Daten zu erkennen. Für mehr als ca. 12K Tokens an Eingabe wechseln Sie von einem einzelnen Aufruf (stuff-Kette) zu map_reduce oder einer benutzerdefinierten LCEL-Kette.

Schritt 2 – Wählen Sie einen Ketten-Typ nach Token-Anzahl

LangChain liefert vier Kettenstrategien und die meisten Tutorials verwenden standardmäßig eine. Die richtige Wahl hängt von der Eingabelänge, dem Latenzbudget und davon ab, ob Sie inkrementelle Ausgaben wünschen.

Die meisten Nachrichten-Pipelines sollten standardmäßig auf stuff zurückgreifen. Moderne Chat-Modelle akzeptieren Hunderttausende von Eingabe-Tokens, und ein einzelner Nachrichtenartikel überschreitet selten 4,000 Tokens. map_reduce wird nur dann komplex, wenn Sie einen Multi-Artikel-Digest in einem einzigen Aufruf zusammenfassen.

from langchain_openai import ChatOpenAI
from langchain.chains.summarize import load_summarize_chain
from langchain.docstore.document import Document
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

def pick_chain(token_count, llm):
    if token_count <= 12_000:
        prompt = ChatPromptTemplate.from_messages([("system", SYSTEM), ("user", "{text}")])
        return prompt | llm | StrOutputParser()
    return load_summarize_chain(llm, chain_type="map_reduce")

llm = ChatOpenAI(model="gpt-4o-mini", max_tokens=200)
chain = pick_chain(in_tokens, llm)
result = chain.invoke({"text": article["body"]})

Was ist die beste LangChain-Kettentyp für die Zusammenfassung?

Der beste LangChain-Kettentyp für die Zusammenfassung hängt von der Eingabelänge ab: verwenden Sie stuff für Eingaben bis zu ca. 12,000 Token (ein Artikel oder ein kleines Bündel), map_reduce für 12K–500K Token (Multi-Artikel- Digests), refine für inkrementelles/Streaming-Ingest einer sich entwickelnden Geschichte und eine benutzerdefinierte LCEL-Kette (prompt | model | parser), wenn Sie eine Feinsteuerung über Wiederholungsversuche, strukturierte Ausgabe oder pro-Stufen-Beobachtbarkeit benötigen.

Schritt 3 – Kostenberechnung bei Nachrichtenvolumen

Preise ab 2026 – überprüfen Sie sie auf openai.com, bevor Sie sich festlegen, da OpenAI die Preisliste häufig aktualisiert. Die Zahlen unten sind indikative Größenordnungen.

Gehen Sie von einem durchschnittlichen Artikel mit 800 Eingabe-Tokens und einer Zusammenfassung mit 150 Ausgabe-Tokens aus. Für 1,000 Artikel pro Tag über drei Modellstufen hinweg:

Formel:

monthly_cost = articles_per_day × 30 × (
    avg_input_tokens / 1_000_000  × input_price +
    avg_output_tokens / 1_000_000 × output_price
)

Drei Erkenntnisse. Erstens ist die günstige Stufe bei 1,000 Artikeln/Tag fast kostenlos – beginnen Sie dort und eskalieren Sie nur, wenn die Qualität es erfordert. Zweitens dominieren Output-Tokens die Kosten auf Premium-Stufen; reduzieren Sie max_tokens auf 150–200 für Schlagzeilen-Zusammenfassungen. Drittens skalieren die Kosten linear mit dem Artikelvolumen, aber multiplikativ mit der Modellstufe – eine Kostensteigerung um das 17-fache von günstig auf mittel ist für kurze Nachrichtenzusammenfassungen selten die Qualitätssteigerung wert; reservieren Sie Premium für die Synthese mehrerer Artikel.

Was kostet die Zusammenfassung von Nachrichten mit GPT?

Das Zusammenfassen von Nachrichten mit GPT kostet ungefähr $6/Monat bei 1,000 Artikeln/Tag in einem günstigen Modell (GPT-4o-mini-Klasse), $105/Monat in einem mittleren Modell (GPT-4o-Klasse) und $190–630/Monat in einer Premium-Stufe — bei durchschnittlichen Eingaben von 800 Tokens und Ausgaben von 150 Tokens pro Artikel. Überprüfen Sie die aktuellen Preise auf openai.com, da OpenAI die Tarife regelmäßig aktualisiert.

Schritt 4 – Halluzinations-Grounding für Nachrichten

Nachrichten-Zusammenfassung schlägt anders fehl als generische Dokumenten-Zusammenfassung: Ein falscher Firmenname, ein falsch zugeschriebenes Zitat oder ein erfundener Dollarbetrag wird zu einem öffentlichen Fehler, sobald Ihre Zusammenfassung ausgeliefert wird. Die billige Absicherung ist die Entitätsgrundierung – extrahieren Sie Entitäten (PERSON, ORG, MONEY, DATE, GPE) aus der Eingabe und aus der Ausgabe und kennzeichnen Sie jede Ausgabeeinheit, die nicht in der Eingabe vorkommt.

import spacy

nlp = spacy.load("en_core_web_sm")
GROUND_LABELS = {"PERSON", "ORG", "MONEY", "DATE", "GPE", "PERCENT"}

def entities(text):
    return {(e.text, e.label_) for e in nlp(text).ents if e.label_ in GROUND_LABELS}

def grounding_check(input_text, summary_text):
    in_ents = entities(input_text)
    out_ents = entities(summary_text)
    in_strings = {e[0].lower() for e in in_ents}
    hallucinated = [e for e in out_ents if e[0].lower() not in in_strings]
    return hallucinated

bad = grounding_check(article["body"], result)
if bad:
    print("Hallucination flag:", bad)
    # retry with stricter prompt or escalate to human review

Dies fängt die lauten Fehler ab – erfundene Personen, ausgedachte Dollarbeträge –, aber nicht die leisen (paraphrasierte Zahlen, vertauschte Pronomen). Für Pipelines mit höherem Risiko sollten Sie ein NLI-Modell (facebook/bart-large-mnli-Stil) hinzufügen, das jeden Zusammenfassungssatz gegen die Eingabe als Folgerung / Widerspruch / neutral bewertet. Eine Fehlerrate über ~5% in Ihrem eigenen Korpus ist ein Signal, das Modell zu wechseln oder den Prompt zu verschärfen; unter 1% ist es mit einer stichprobenbasierten menschlichen Überprüfung veröffentlichbar.

Wie verhindert man Halluzinationen in Nachrichtenzusammenfassungen?

Verhindern Sie Halluzinationen in Nachrichtenzusammenfassungen mit drei Ebenen: Ein eingeschränkter System-Prompt, der keine Schlussfolgerungen über die Quelle hinaus verbietet, eine Entitätsprüfung, die jede PERSON/ORG/GELD/DATUM in der Ausgabe kennzeichnet, die nicht in der Eingabe vorhanden ist, und ein NLI-basierter Faktizitätsklassifikator, der jeden Zusammenfassungssatz anhand des Artikels als Entailment oder Widerspruch bewertet. Lehnen Sie jede Zusammenfassung mit einer Widerspruchsmarkierung ab oder lassen Sie sie von einem Menschen überprüfen.

Schritt 5 – Prompt-Caching zur Reduzierung der Produktionskosten

Statische System-Prompts, die über Tausende von Zusammenfassungsaufrufen wiederholt werden, qualifizieren sich für Prompt-Caching bei modernen OpenAI-Bereitstellungen. Der Mechanismus: Wenn dieselben Präfix-Token wiederholt auf den API treffen, werden gecachte Token zu einem Bruchteil des normalen Eingaberates abgerechnet. Die strukturelle Regel ist einfach: Stellen Sie alles Statische (System-Prompt, Formatbeispiele, Ausgabeschema) an den Anfang der Anfrage, den dynamischen Artikel an das Ende.

Für einen typischen Nachrichten-Summarizer, bei dem der System-Prompt ~500 Tokens und der Artikelkörper ~800 Tokens beträgt, ist der Prompt ~38% statisch. Erhöhen Sie den statischen Teil mit Beispielen, und Sie können 70–80% statisch erreichen. Mit einer 90% Cache-Trefferquote auf dem statischen Präfix sinken die gesamten Eingabekosten um ungefähr:

savings = static_fraction × hit_rate × cache_discount
        = 0.80 × 0.90 × 0.50
        = 36%   on total input cost

Kombiniert mit dem günstigen Tarifmodell ist dies der Unterschied zwischen $6/Monat und $4/Monat bei 1,000 Artikeln/Tag – geringfügig isoliert, aber erheblich bei 100K Artikeln/Tag, wo dasselbe Verhältnis $400/Monat gegenüber $250/Monat bedeutet. Überprüfen Sie den Cache-Rabatt und die Berechtigung in der aktuellen OpenAI-Dokumentation.

Schritt 6 — End-to-End-Pipeline

Zusammenfügen. Abrufen von APITube, Duplikate über is_duplicate verwerfen, nach Token-Anzahl weiterleiten, erden, speichern.

from sqlite3 import connect
db = connect("summaries.db")
db.execute("CREATE TABLE IF NOT EXISTS summaries (article_id TEXT PRIMARY KEY, summary TEXT, flagged INT)")

def fetch_articles(query, limit=20):
    res = requests.get(
        "https://api.apitube.io/v1/news/everything",
        params={"title": query, "language.code": "en", "per_page": limit},
        headers={"X-API-Key": os.environ["APITUBE_KEY"]},
    )
    res.raise_for_status()
    return res.json()["results"]

def run(query):
    for a in fetch_articles(query):
        if a.get("is_duplicate"):
            continue
        body = a.get("body") or a["description"]
        in_tokens = len(enc.encode(body))
        chain = pick_chain(in_tokens, llm)
        summary = chain.invoke({"text": body})
        flagged = bool(grounding_check(body, summary))
        db.execute(
            "INSERT OR REPLACE INTO summaries VALUES (?, ?, ?)",
            (a["id"], summary, int(flagged)),
        )
    db.commit()

run("election")

Bei 1,000 Artikeln/Tag läuft dies problemlos auf einem einzelnen Worker. Bei 10K/Tag parallelisieren Sie mit asyncio.gather und bündeln Sie die OpenAI-Aufrufe; bei 100K/Tag wechseln Sie zum OpenAI Batch API für den 50%-Rabatt auf nicht zeitkritische Zusammenfassungen.

Kann ChatGPT mehrere Nachrichtenartikel gleichzeitig zusammenfassen?

ChatGPT kann mehrere Nachrichtenartikel in einem einzigen Aufruf zusammenfassen, indem sie mit klaren Trennzeichen zu einer Eingabe verkettet werden, und eine map_reduce-Kette verwendet, die jeden Artikel im Map-Schritt zusammenfasst und im Reduce-Schritt eine einheitliche Zusammenfassung erstellt. Moderne Kontextfenster akzeptieren Dutzende von Artikeln pro Aufruf, aber die Kosten skalieren mit der Gesamtzahl der Eingabe-Tokens – für die routinemäßige Stapelzusammenfassung ist das Schleifen einzelner stuff-Aufrufe normalerweise günstiger und einfacher zu debuggen.

Build vs. Buy: GPT-Pipeline vs. vorgefertigte extraktive Zusammenfassung

Der /v1/news/everything-Endpunkt von APITube gibt bereits eine extraktive summary pro Artikel zurück – Schlüssel-Sätze direkt aus dem Text, mit Sentiment pro Satz. Sie bezahlen dafür einmal über den API-Aufruf. Ehrlicher Vergleich:

Wählen Sie extraktiv für jedes Volumen, bei dem die Qualität des Leseflusses nicht das Unterscheidungsmerkmal ist. Wechseln Sie zu Hybrid, wenn Sie eine einheitliche Stimme über Tausende von Artikeln hinweg benötigen. Behalten Sie die vollständige abstraktive Methode für Anwendungsfälle vor, bei denen das Modell wirklich synthetisiert – Multi-Artikel-Digests, Audio-Briefings, „Erklären Sie mir, was heute passiert ist“-Schnittstellen –, denn nur dort rechnet sich GPT gegenüber der vorgefertigten Zusammenfassung von API.

Kostenlos ausprobieren

Validieren Sie die gesamte Pipeline mit der kostenlosen Stufe von APITube – 30 Anfragen pro 30 Minuten reichen aus, um ein paar hundert Artikel End-to-End zusammenzufassen und zu entscheiden, ob Sie GPT überhaupt benötigen. Jedes Ergebnis enthält bereits die extraktive summary, sodass Sie es Seite an Seite mit Ihrer GPT-Ausgabe vergleichen können. Testen Sie APITube kostenlos unter apitube.io.

Ressourcen

• APITube — apitube.io — kostenlos testen, Sentiment und Entitäten in jedem Artikel enthalten
• Dokumentation — docs.apitube.io — Endpunkte, Parameter, Antwortstruktur, Integrationen
• Preise – apitube.io/pricing – alle Stufen
• APITube Blog — apitube.io/blog — weitere Leitfäden und Vergleiche