Strukturierte Berichte generieren
Berichte anhand von Vorlagen: Managementzusammenfassung, Erkenntnisse, Belege, Empfehlungen.
Strukturierte Berichte generieren ist eine kostenlose AI Agents-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Agents-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.
Von Fakten zum verständlichen Bericht
Ein Recherche-Agent, der nur eine Liste von Fakten ausgibt, ist schwer nutzbar. Entscheidungsträger benötigen strukturierte Berichte: eine Executive Summary, einen Hintergrundabschnitt, zentrale Erkenntnisse, Belege und Empfehlungen.
Diese Lektion behandelt die schrittweise Erstellung professioneller Berichte aus überprüften Fakten.
Die Berichtsvorlage
Definieren Sie die Berichtsstruktur im Voraus. Das LLM erstellt jeweils einen Abschnitt und hält dadurch jeden Abschnitt fokussiert, während Wiederholungen vermieden werden.
REPORT_SECTIONS = [
'executive_summary',
'background',
'key_findings',
'evidence',
'recommendations',
'sources'
]
SECTION_PROMPTS = {
'executive_summary': 'Write a 2-3 sentence executive summary of the key findings. Business audience.',
'background': 'Provide background context for the research topic (3-5 sentences).',
'key_findings': 'List 3-5 key findings as bullet points, each with one supporting fact.',
'evidence': 'Summarize the evidence for each finding with inline source citations.',
'recommendations': 'Based on the findings, provide 2-4 actionable recommendations.',
'sources': 'List all sources cited in the report, formatted as numbered URLs.'
}
if __name__ == '__main__':
print('Report sections:', REPORT_SECTIONS)
for section in REPORT_SECTIONS:
print(f'{section}: {SECTION_PROMPTS[section]}')
Abschnitt für Abschnitt generieren
Den gesamten Bericht in einem Prompt zu generieren, ist unzuverlässig – das LLM verliert den Überblick über Fakten und Struktur. Generieren Sie den Bericht Abschnitt für Abschnitt und übergeben Sie die vorherigen Abschnitte als Kontext.
import openai
client = openai.OpenAI(api_key='YOUR_OPENAI_KEY')
def generate_section(section_name: str, question: str,
facts: list[dict], prior_sections: dict) -> str:
facts_text = '\n'.join(
f'- {f["fact"]} (source: {f["source"]})' for f in facts[:25]
)
prior_text = '\n\n'.join(
f'## {k.replace("_"," ").title()}\n{v}'
for k, v in prior_sections.items()
)
prompt = (
f'Research question: "{question}"\n\n'
f'Verified facts:\n{facts_text}\n\n'
f'Report so far:\n{prior_text}\n\n'
f'Now write the "{section_name}" section.\n'
f'Instructions: {SECTION_PROMPTS[section_name]}'
)
resp = client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': prompt}]
)
return resp.choices[0].message.contentDen Bericht iterativ erstellen
Durchlaufen Sie alle Abschnitte und übergeben Sie dabei den laufend erweiterten Kontext. Jeder Abschnitt berücksichtigt, was zuvor kam, sodass der Bericht schlüssig bleibt und Widersprüche innerhalb des Berichts vermieden werden.
def build_report(question: str, facts: list[dict]) -> dict:
report = {}
sections_to_generate = [s for s in REPORT_SECTIONS if s != 'sources']
for section in sections_to_generate:
print(f'Generating section: {section}...')
report[section] = generate_section(
section_name=section,
question=question,
facts=facts,
prior_sections={k: v for k, v in report.items()}
)
# Sources section: generate citation list from fact URLs
unique_sources = list(dict.fromkeys(f['source'] for f in facts))
report['sources'] = '\n'.join(
f'{i+1}. {url}' for i, url in enumerate(unique_sources[:20])
)
return reportInline-Zitate einfügen
Ersetzen Sie in den generierten Abschnitten Faktenverweise durch nummerierte Zitate, die auf die Quellenliste verweisen. So lässt sich jede Behauptung zurückverfolgen.
import re
def inject_citations(section_text: str, facts: list[dict]) -> str:
source_index = {} # url -> int
for i, fact in enumerate(facts):
url = fact['source']
if url not in source_index:
source_index[url] = len(source_index) + 1
annotated = section_text
for fact in facts:
if fact['fact'] in annotated:
num = source_index[fact['source']]
annotated = annotated.replace(
fact['fact'],
f'{fact["fact"]} [{num}]',
1 # replace first occurrence only
)
return annotated
if __name__ == '__main__':
demo_text = 'Revenue grew 12% last quarter. The team also launched two new products.'
demo_facts = [{'fact': 'Revenue grew 12% last quarter', 'source': 'https://example.com/report'}]
print(inject_citations(demo_text, demo_facts))
Als Markdown formatieren
Geben Sie die Berichtsabschnitte als Markdown aus. Dadurch kann die Ausgabe in HTML oder PDF umgewandelt oder direkt in Tools wie Notion oder Confluence angezeigt werden.
def render_markdown(report: dict, title: str) -> str:
section_titles = {
'executive_summary': 'Executive Summary',
'background': 'Background',
'key_findings': 'Key Findings',
'evidence': 'Evidence',
'recommendations': 'Recommendations',
'sources': 'Sources'
}
lines = [f'# {title}', '']
for key in REPORT_SECTIONS:
if key in report:
lines.append(f'## {section_titles[key]}')
lines.append('')
lines.append(report[key])
lines.append('')
return '\n'.join(lines)
# Usage:
# md = render_markdown(report, 'Causes of Inflation in 2024')
# with open('report.md', 'w') as f: f.write(md)Bericht mit Quellenlinks generieren
Wandeln Sie beim Rendern für das Web die Quell-URLs in Hyperlinks um. Fügen Sie außerdem einen Metadatenblock mit dem Datum der Berichtserstellung, der Anzahl der Quellen und der Überprüfungsquote hinzu.
from datetime import date
def render_html_report(report: dict, title: str,
facts: list[dict], question: str) -> str:
meta = (
f'<p><em>Generated: {date.today()} | '
f'Sources: {len(set(f["source"] for f in facts))} | '
f'Research question: {question}</em></p>'
)
html_parts = [f'<h1>{title}</h1>', meta]
section_titles = {
'executive_summary': 'Executive Summary',
'background': 'Background',
'key_findings': 'Key Findings',
'evidence': 'Evidence',
'recommendations': 'Recommendations',
'sources': 'Sources'
}
for key in REPORT_SECTIONS:
if key in report:
content = report[key].replace('\n', '<br>')
html_parts.append(f'<h2>{section_titles[key]}</h2><p>{content}</p>')
return '\n'.join(html_parts)Qualitätsprüfungen vor der Veröffentlichung
Führen Sie vor der Bereitstellung des Berichts automatisierte Qualitätsprüfungen durch: eine Mindestwortzahl pro Abschnitt, mindestens N Zitate, ausschließlich Handlungsverben in allen Empfehlungen und keinen Platzhaltertext wie „[INSERT]“.
def quality_check(report: dict) -> list[str]:
issues = []
for section in ['executive_summary', 'background', 'key_findings']:
word_count = len(report.get(section, '').split())
if word_count < 30:
issues.append(f'{section} too short: {word_count} words (min 30)')
if report.get('sources', '').count('http') < 3:
issues.append('Less than 3 cited sources')
if '[INSERT]' in str(report) or 'TODO' in str(report):
issues.append('Report contains placeholder text')
recs = report.get('recommendations', '')
if recs and not any(verb in recs.lower()
for verb in ['should', 'recommend', 'consider', 'implement']):
issues.append('Recommendations may not be actionable')
return issues
if __name__ == '__main__':
demo_report = {
'executive_summary': 'Too short.',
'background': 'Also short.',
'key_findings': 'Short too.',
'sources': 'http://a.com',
'recommendations': 'Looks fine as is.',
}
for issue in quality_check(demo_report):
print('-', issue)
Executive Summary: Strenge Vorgaben
Die Executive Summary sollte in sich geschlossen sein: Wer nur diesen Abschnitt liest, sollte die zentrale Erkenntnis und die empfohlene Maßnahme verstehen. Verwenden Sie einen strikten Prompt mit einer Wortbegrenzung.
def generate_executive_summary(question: str, facts: list[dict],
max_words: int = 80) -> str:
top_facts = '\n'.join(f'- {f["fact"]}' for f in facts[:10])
prompt = (
f'Research question: "{question}"\n\n'
f'Key facts:\n{top_facts}\n\n'
f'Write an executive summary in EXACTLY {max_words} words or fewer.\n'
f'Format: [Main finding]. [Why it matters]. [Recommended action].'
)
resp = client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': prompt}]
)
return resp.choices[0].message.contentBerichte für mehrere Zielgruppen
Dieselbe Recherche kann für verschiedene Zielgruppen unterschiedliche Berichtsstile erfordern: eine technische Vertiefung für Entwickler, eine Executive Summary für die Führungsebene oder eine verständliche Zusammenfassung für Nichtfachleute. Erzeugen Sie jede Variante aus demselben Faktensatz.
AUDIENCE_STYLES = {
'executive': 'Brief, strategic. Avoid jargon. Focus on business impact and decisions.',
'technical': 'Detailed, precise. Include methodology, caveats, and data sources.',
'general': 'Plain language. Avoid technical terms. Use analogies where helpful.'
}
def generate_for_audience(facts: list[dict], question: str, audience: str) -> str:
style = AUDIENCE_STYLES.get(audience, AUDIENCE_STYLES['general'])
facts_text = '\n'.join(f'- {f["fact"]}' for f in facts[:20])
prompt = (
f'Synthesize these facts into a report for a {audience} audience.\n'
f'Style guide: {style}\n'
f'Question: "{question}"\n\n'
f'Facts:\n{facts_text}'
)
resp = client.chat.completions.create(
model='gpt-4o',
messages=[{'role': 'user', 'content': prompt}]
)
return resp.choices[0].message.contentBerichte speichern und versionieren
Speichern Sie Berichte mit einem Zeitstempel und dem Hash der Recherchefrage. So können Sie Berichtsversionen vergleichen, wenn die Recherche mit aktualisierten Quellen erneut ausgeführt wird.
import hashlib, json, os
from datetime import datetime, timezone
def save_report(report: dict, question: str, output_dir: str = '/tmp/reports'):
os.makedirs(output_dir, exist_ok=True)
q_hash = hashlib.md5(question.encode()).hexdigest()[:8]
timestamp = datetime.now(timezone.utc).strftime('%Y%m%d_%H%M')
filename = f'{output_dir}/report_{q_hash}_{timestamp}.json'
with open(filename, 'w') as f:
json.dump({
'question': question,
'generated': timestamp,
'sections': report
}, f, indent=2)
print(f'Report saved: {filename}')
return filename
if __name__ == '__main__':
import tempfile
demo_dir = tempfile.mkdtemp()
save_report({'executive_summary': 'AI agent adoption grew significantly in 2026.'},
'What are the key AI agent trends in 2026?', output_dir=demo_dir)
Welcher Abschnitt sollte in der Berichtsstruktur immer in sich geschlossen sein?
Die Berichtsstruktur ist so gestaltet, dass Leser mit wenig Zeit einen Nutzen daraus ziehen können, ohne das gesamte Dokument zu lesen. Zu verstehen, welcher Abschnitt für sich allein stehen muss, ist für die Gestaltung von Berichten wichtig.
Zusammenfassung zur Erstellung strukturierter Berichte
Erstellen Sie Berichte Abschnitt für Abschnitt anhand einer festen Vorlage (Executive Summary → Hintergrund → Zentrale Erkenntnisse → Belege → Empfehlungen → Quellen). Fügen Sie Inline-Zitate ein, führen Sie Qualitätsprüfungen durch und unterstützen Sie mehrere Zielgruppenstile aus demselben Faktensatz.
Speichern Sie Berichte immer mit Zeitstempeln und Frage-Hashes zur Versionierung.
Häufig gestellte Fragen
Ist die Lektion „Strukturierte Berichte generieren“ kostenlos?
Ja — der vollständige Text von „Strukturierte Berichte generieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Agents-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Strukturierte Berichte generieren“?
Berichte anhand von Vorlagen: Managementzusammenfassung, Erkenntnisse, Belege, Empfehlungen. Du übst AI Agents mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um AI Agents zu starten?
Keine Vorkenntnisse erforderlich. AI Agents auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Strukturierte Berichte generieren“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser AI Agents-Lektion Code schreiben und ausführen?
Ja. Jede AI Agents-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Entwurf mehrstufiger Recherche-Schleifen
- Quellenprüfung und Zitierung
- Strukturierte Berichte generieren
- Faktenprüfung und Vermeidung von Halluzinationen