Invio di messaggi e blocchi avanzati
Testo semplice, markdown e JSON di Block Kit: formattazione dei messaggi Slack
Invio di messaggi e blocchi avanzati è una lezione AI Agents gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Agents, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Agents include 4 lezioni in totale.
Messaggi di testo semplici con say()
Il modo più semplice per pubblicare un messaggio Slack è say(text). Il testo supporta mrkdwn, la variante del markdown di Slack. Utilizzi *bold*, _italic_, ~strike~, `code` e menzioni come <@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')Introduzione a Block Kit
Block Kit è il framework dell'interfaccia utente di Slack per creare messaggi ricchi e interattivi. Anziché usare testo semplice, componga i messaggi utilizzando blocchi tipizzati: section, header, divider, actions, context. I blocchi vengono passati come elenco al parametro blocks di say() o chat_postMessage().
@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
)Blocchi section con campi di testo
Il blocco section è il più versatile. Può visualizzare testo (mrkdwn o plain_text), un elenco di coppie chiave-valore oppure un elemento accessorio (pulsante, immagine, menu overflow). Utilizzi fields per disporre affiancate le coppie chiave-valore: è ideale per le dashboard.
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)
Blocchi header e divider
Utilizzi i blocchi header per i titoli di sezione grandi e i blocchi divider per la separazione visiva. Il blocco header supporta solo plain_text e non mrkdwn. Li combini per creare messaggi di report ben strutturati.
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)
Blocchi actions con pulsanti
I blocchi Actions contengono elementi interattivi come i pulsanti. Ogni pulsante ha un action_id, utilizzato per indirizzare i clic ai gestori, un text e un value facoltativo che contiene dati. Utilizzi style: 'primary' per la CTA principale e style: 'danger' per le azioni distruttive.
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)
Blocchi context per i metadati
I blocchi Context visualizzano un testo secondario di piccole dimensioni nella parte inferiore di un messaggio: sono perfetti per metadati come timestamp, fonti o informazioni sulla versione dell'agente. Supportano mrkdwn e immagini, ad esempio per piccole icone.
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 nei campi di testo
Il mrkdwn di Slack supporta un sottoinsieme del markdown. Le principali opzioni di formattazione per i messaggi dell'agente sono: grassetto, corsivo, codice, link, menzioni di canali, menzioni di utenti ed elenchi. Le utilizzi per rendere leggibili in Slack i contenuti generati dall'IA.
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)Messaggi effimeri con respond()
I messaggi effimeri sono visibili solo all'utente che ha attivato l'azione, non agli altri membri del canale. Li utilizzi per aggiornamenti di stato, messaggi di errore e conferme che non devono appesantire il canale. Sono disponibili solo tramite respond() (slash command) o chat_postEphemeral().
@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)
)Aggiornamento dei messaggi dopo l'invio
Dopo aver pubblicato un messaggio, può aggiornarlo utilizzando client.chat_update() con il canale e il timestamp del messaggio (ts). È utile per gli aggiornamenti sullo stato di avanzamento: pubblichi un messaggio iniziale «Elaborazione...», quindi lo aggiorni con il risultato al termine dell'operazione.
@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()Pubblicazione in canali specifici
Utilizzi client.chat_postMessage(channel=channel_id, text=...) per pubblicare in qualsiasi canale a cui il Suo bot ha accesso. Trovi gli ID dei canali nell'API di Slack oppure facendo clic con il pulsante destro del mouse su un canale. Utilizzi conversations_list() per cercare programmaticamente i canali in base al nome.
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')
Pattern builder per i messaggi Block Kit
Utilizzi una funzione builder che accetta dati e restituisce un elenco di blocchi. In questo modo separa la formattazione dei messaggi dalla logica di business e rende i blocchi riutilizzabili in diversi gestori di eventi.
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)
Verifica rapida: tipi di blocco
Verifichi la Sua comprensione di Slack Block Kit.
Riepilogo dei messaggi ricchi
Ora il Suo agente può pubblicare messaggi Slack professionali e interattivi:
- say(text) — testo mrkdwn semplice; supporta *bold*, _italic_, `code` e le menzioni
- say(blocks=[...]) — Block Kit per una struttura organizzata
- header — titolo di sezione grande, solo plain_text
- section — corpo del testo con campi facoltativi, disposti in una griglia chiave-valore, oppure un elemento accessorio
- divider — linea separatrice orizzontale
- actions — contenitore per pulsanti ed elementi interattivi
- context — piccolo testo con metadati nella parte inferiore
- respond(response_type='ephemeral') — messaggio visibile solo all'utente che ha attivato l'azione
- chat_update(ts=...) — aggiorna un messaggio pubblicato in precedenza con nuovi contenuti
Domande Frequenti
La lezione «Invio di messaggi e blocchi avanzati» è gratuita?
Sì — il testo completo di «Invio di messaggi e blocchi avanzati» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Agents, passa a CoddyKit PRO. Il corso AI Agents include 4 lezioni in totale.
Cosa imparerò in «Invio di messaggi e blocchi avanzati»?
Testo semplice, markdown e JSON di Block Kit: formattazione dei messaggi Slack Eserciti AI Agents con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare AI Agents?
Non è richiesta alcuna esperienza precedente. AI Agents su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.
Quanto tempo richiede la lezione «Invio di messaggi e blocchi avanzati»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione AI Agents?
Sì. Ogni lezione AI Agents include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Nozioni di base di Slack Bolt SDK
- Ascolto degli eventi e dei comandi slash
- Invio di messaggi e blocchi avanzati
- Creazione di un bot per le notifiche del team