Nachrichten und Rich Blocks senden
Klartext, Markdown und Block-Kit-JSON – Slack-Nachrichten formatieren.
Nachrichten und Rich Blocks senden 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.
Einfache Textnachrichten mit say()
Die einfachste Möglichkeit, eine Slack-Nachricht zu posten, ist say(text). Der Text unterstützt mrkdwn – Slacks Markdown-Variante. Verwenden Sie *bold*, _italic_, ~strike~, `code` und Erwähnungen wie <@USERID>.
@app.event('app_mention')
def handle_mention(event, say):
user = event['user']
# Simple text response with mrkdwn formatting
say(
text=(
f'Hello <@{user}>!\n'
'*Agent Report:*\n'
'- Tasks completed: `42`\n'
'- Errors: `0`\n'
'- _Runtime: 3.2 seconds_'
),
mrkdwn=True # enabled by default
)
# Slack mentions
say(f'<@{user}> your request is being processed')
say('Posting to <!channel>: all hands meeting tomorrow')Einführung in Block Kit
Block Kit ist Slacks UI-Framework zum Erstellen umfangreicher, interaktiver Nachrichten. Statt aus einfachem Text setzen Sie Nachrichten aus typisierten Blöcken zusammen: section, header, divider, actions, context. Blöcke werden als Liste an den Parameter blocks von say() oder chat_postMessage() übergeben.
@app.event('app_mention')
def handle_mention(event, say):
blocks = [
{
'type': 'header',
'text': {'type': 'plain_text', 'text': 'Agent Status Report'}
},
{
'type': 'divider'
},
{
'type': 'section',
'text': {
'type': 'mrkdwn',
'text': '*Status:* Running\n*Tasks:* 42 completed'
}
}
]
say(
text='Agent Status Report', # fallback for notifications
blocks=blocks
)Section-Blöcke mit Textfeldern
Der section-Block ist am vielseitigsten. Er kann Text (mrkdwn oder plain_text), eine Liste von Schlüssel-Wert-Paaren oder ein zusätzliches Element wie eine Schaltfläche, ein Bild oder ein Überlaufmenü anzeigen. Verwenden Sie fields für nebeneinander angeordnete Schlüssel-Wert-Paare – ideal für Dashboards.
def build_task_summary_blocks(tasks):
blocks = [
{
'type': 'header',
'text': {'type': 'plain_text', 'text': 'Daily Task Summary'}
},
{
'type': 'section',
'text': {
'type': 'mrkdwn',
'text': f'Processed *{len(tasks)} tasks* today.'
}
},
{
'type': 'section',
'fields': [
{'type': 'mrkdwn', 'text': f'*Completed:*\n{sum(1 for t in tasks if t["status"]=="done")}'},
{'type': 'mrkdwn', 'text': f'*Failed:*\n{sum(1 for t in tasks if t["status"]=="error")}'},
{'type': 'mrkdwn', 'text': f'*Pending:*\n{sum(1 for t in tasks if t["status"]=="pending")}'},
{'type': 'mrkdwn', 'text': f'*Avg Time:*\n3.2s'}
]
}
]
return blocks
# --- demo ---
tasks = [
{'status': 'done'}, {'status': 'done'}, {'status': 'error'}, {'status': 'pending'}
]
blocks = build_task_summary_blocks(tasks)
for b in blocks:
print(b)
Header- und Divider-Blöcke
Verwenden Sie header-Blöcke für große Abschnittstitel und divider-Blöcke zur visuellen Trennung. Der Header-Block unterstützt nur plain_text und kein mrkdwn. Kombinieren Sie beide, um übersichtlich strukturierte Berichtsnachrichten zu erstellen.
def build_report_message(title, sections):
blocks = []
# Header
blocks.append({
'type': 'header',
'text': {'type': 'plain_text', 'text': title, 'emoji': True}
})
for section_title, content in sections:
# Divider between sections
blocks.append({'type': 'divider'})
# Section header as bold mrkdwn
blocks.append({
'type': 'section',
'text': {'type': 'mrkdwn', 'text': f'*{section_title}*\n{content}'}
})
return blocks
blocks = build_report_message(
title='Weekly Agent Report',
sections=[
('Emails Processed', '142 emails classified, 38 replies drafted'),
('Tasks Completed', '89 tasks completed, 3 failures logged')
]
)
# --- demo ---
for b in blocks:
print(b)
Action-Blöcke mit Schaltflächen
Actions-Blöcke enthalten interaktive Elemente wie Schaltflächen. Jede Schaltfläche verfügt über eine action_id (zum Weiterleiten von Klicks an Handler), einen text-Wert und optional einen value-Wert, der Daten überträgt. Verwenden Sie style: 'primary' für die wichtigste CTA und style: 'danger' für destruktive Aktionen.
def build_approval_message(task_id, task_description):
blocks = [
{
'type': 'section',
'text': {
'type': 'mrkdwn',
'text': f'*Task ready for approval:*\n{task_description}'
}
},
{
'type': 'actions',
'elements': [
{
'type': 'button',
'text': {'type': 'plain_text', 'text': 'Approve'},
'style': 'primary',
'action_id': 'approve_task',
'value': task_id
},
{
'type': 'button',
'text': {'type': 'plain_text', 'text': 'Reject'},
'style': 'danger',
'action_id': 'reject_task',
'value': task_id
}
]
}
]
return blocks
# --- demo ---
blocks = build_approval_message('task_42', 'Deploy backend v2.3 to production')
for b in blocks:
print(b)
Context-Blöcke für Metadaten
Context-Blöcke zeigen am unteren Rand einer Nachricht kleinen, ergänzenden Text an – ideal für Metadaten wie Zeitstempel, Quellen oder Informationen zur Agent-Version. Sie unterstützen mrkdwn und Bilder für kleine Symbole.
import datetime
def add_context_footer(blocks, agent_version='v1.2'):
timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M UTC')
blocks.append({
'type': 'context',
'elements': [
{
'type': 'mrkdwn',
'text': f'Generated by Agent {agent_version} | {timestamp}'
}
]
})
return blocks
# Full message with context footer
blocks = [
{
'type': 'section',
'text': {'type': 'mrkdwn', 'text': 'Analysis complete. See results below.'}
}
]
blocks = add_context_footer(blocks)
print(f'Message has {len(blocks)} blocks')mrkdwn in Textfeldern
Slacks mrkdwn unterstützt einen Teil der Markdown-Syntax. Wichtige Formatierungsoptionen für Agent-Nachrichten sind Fettdruck, Kursivschrift, Code, Links, Kanal- und Benutzererwähnungen sowie Listen. Verwenden Sie diese Optionen, um von der KI generierte Inhalte in Slack gut lesbar zu machen.
def format_ai_response_as_mrkdwn(title, bullet_points, code_snippet=None):
lines = [f'*{title}*']
for point in bullet_points:
lines.append(f'• {point}')
if code_snippet:
lines.append(f'```{code_snippet}```') # code block
return '\n'.join(lines)
content = format_ai_response_as_mrkdwn(
title='Security Issues Found',
bullet_points=[
'SQL injection risk in `user_search()` function',
'Hardcoded API key in `config.py` line 42',
'Missing HTTPS on login endpoint'
],
code_snippet='SELECT * FROM users WHERE id = " + userId + "\n# ^ UNSAFE: use parameterized queries'
)
print(content)Ephemere Nachrichten mit respond()
Ephemere Nachrichten sind nur für den Benutzer sichtbar, der die Aktion ausgelöst hat, nicht für andere Mitglieder des Kanals. Verwenden Sie sie für Statusaktualisierungen, Fehlermeldungen und Bestätigungen, die den Kanal nicht unnötig füllen sollen. Sie sind nur über respond() (Slash Commands) oder chat_postEphemeral() verfügbar.
@app.command('/check-status')
def handle_status(ack, respond, body, client):
ack()
user_id = body['user_id']
channel_id = body['channel_id']
# Ephemeral: only the user who ran /check-status sees this
respond(
text='Checking agent status...',
response_type='ephemeral'
)
status = get_agent_status()
# Or use chat_postEphemeral for more control
client.chat_postEphemeral(
channel=channel_id,
user=user_id,
text=f'Agent Status: {status}',
blocks=build_status_blocks(status)
)Nachrichten nach dem Senden aktualisieren
Nach dem Posten einer Nachricht können Sie sie mit client.chat_update() aktualisieren, indem Sie den Kanal und den Nachrichtenzeitstempel (ts) angeben. Das ist für Statusaktualisierungen nützlich: Posten Sie zunächst eine Nachricht mit „Processing...“ und aktualisieren Sie sie anschließend mit dem Ergebnis.
@app.command('/analyze')
def handle_analyze(ack, say, respond, body, client):
ack()
text = body.get('text', '')
channel = body['channel_id']
# Post initial message
initial = client.chat_postMessage(
channel=channel,
text='Analyzing... this may take a moment.'
)
message_ts = initial['ts']
# Do the work
import threading
def do_work():
result = slow_ai_analysis(text)
# Update the original message with the result
client.chat_update(
channel=channel,
ts=message_ts,
text=f'Analysis complete: {result}',
blocks=build_result_blocks(result)
)
threading.Thread(target=do_work, daemon=True).start()In bestimmte Kanäle posten
Verwenden Sie client.chat_postMessage(channel=channel_id, text=...), um in jeden Kanal zu posten, auf den Ihr Bot Zugriff hat. Sie finden Kanal-IDs in der Slack API oder indem Sie mit der rechten Maustaste auf einen Kanal klicken. Verwenden Sie conversations_list(), um Kanäle programmgesteuert anhand ihres Namens zu suchen.
def post_alert_to_channel(client, channel_name, alert_message):
# Look up channel ID by name
result = client.conversations_list(
types='public_channel,private_channel',
limit=200
)
channel_id = None
for ch in result['channels']:
if ch['name'] == channel_name:
channel_id = ch['id']
break
if not channel_id:
print(f'Channel #{channel_name} not found')
return None
# Post the alert
response = client.chat_postMessage(
channel=channel_id,
text=alert_message,
unfurl_links=False, # don't expand URLs
unfurl_media=False
)
print(f'Posted to #{channel_name}: ts={response["ts"]}')
return response
# --- demo: minimal stand-in for the Slack client ---
class _FakeClient:
def conversations_list(self, **kwargs):
return {'channels': [{'name': 'alerts', 'id': 'C123'}, {'name': 'general', 'id': 'C456'}]}
def chat_postMessage(self, **kwargs):
print(f"[slack] postMessage to {kwargs['channel']}: {kwargs['text']}")
return {'ts': '1699999999.000100'}
post_alert_to_channel(_FakeClient(), 'alerts', 'Disk usage above 90% on web-1')
Builder-Muster zum Erstellen von Block-Kit-Nachrichten
Verwenden Sie eine Builder-Funktion, die Daten entgegennimmt und eine Liste von Blöcken zurückgibt. Dadurch wird die Nachrichtenformatierung von der Geschäftslogik getrennt und Sie können Ihre Blöcke in verschiedenen Event-Handlern wiederverwenden.
def build_alert_blocks(level, title, details, link=None):
level_emoji = {'info': ':information_source:',
'warning': ':warning:', 'error': ':x:'}.get(level, '')
blocks = [
{
'type': 'header',
'text': {'type': 'plain_text', 'text': f'{level_emoji} {title}'}
},
{
'type': 'section',
'text': {'type': 'mrkdwn', 'text': details}
}
]
if link:
blocks.append({
'type': 'actions',
'elements': [{
'type': 'button',
'text': {'type': 'plain_text', 'text': 'View Details'},
'url': link,
'action_id': 'view_details'
}]
})
import datetime
blocks.append({
'type': 'context',
'elements': [{'type': 'mrkdwn',
'text': datetime.datetime.now().strftime('%Y-%m-%d %H:%M UTC')}]
})
return blocks
# --- demo ---
blocks = build_alert_blocks('warning', 'High latency', 'p95 latency is 3.2s', link='https://dash.example.com')
for b in blocks:
print(b)
Kurzer Test: Blocktypen
Testen Sie Ihr Verständnis von Slack Block Kit.
Zusammenfassung: Umfangreiche Nachrichten
Ihr Agent kann jetzt professionelle, interaktive Slack-Nachrichten posten:
- say(text) – einfacher mrkdwn-Text; unterstützt *bold*, _italic_, `code` und Erwähnungen
- say(blocks=[...]) – Block Kit für strukturierte Layouts
- header – großer Abschnittstitel, nur plain_text
- section – Textkörper mit optionalen Feldern (Schlüssel-Wert-Raster) oder einem zusätzlichen Element
- divider – horizontale Trennlinie
- actions – Container für Schaltflächen und interaktive Elemente
- context – kleiner Metadatentext am unteren Rand
- respond(response_type='ephemeral') – Nachricht, die nur für den auslösenden Benutzer sichtbar ist
- chat_update(ts=...) – eine zuvor gepostete Nachricht mit neuen Inhalten aktualisieren
Häufig gestellte Fragen
Ist die Lektion „Nachrichten und Rich Blocks senden“ kostenlos?
Ja — der vollständige Text von „Nachrichten und Rich Blocks senden“ 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 „Nachrichten und Rich Blocks senden“?
Klartext, Markdown und Block-Kit-JSON – Slack-Nachrichten formatieren. 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 „Nachrichten und Rich Blocks senden“?
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
- Grundlagen des Slack Bolt SDK
- Auf Ereignisse und Slash Commands reagieren
- Nachrichten und Rich Blocks senden
- Einen Benachrichtigungs-Bot für Teams erstellen