Turn Slack Meeting Notes into Saved Action Items with n8n, LangBot and GPT-6 Astra

A meeting summary can read beautifully and still fail at the only question that matters tomorrow: who is doing what, and by when?

This workflow turns pasted meeting notes into structured action items, validates the result, saves a draft through a small local API, and returns a receipt through LangBot. Slack is a natural front door; Telegram works with the same pipeline. GPT-6 Astra extracts the information, while n8n handles the steps that should be explicit and inspectable.

The workflow we will build

1. Start n8n and LangBot from scratch

You need Docker Compose and an OpenAI-compatible API credential with access to gpt-6-astra. The tested versions are n8n 2.39.6 and LangBot 4.10.11, with English interfaces. The model ID is the one provided by the gateway used in this lab; verify your own provider's ID and endpoint.

Create a new directory and save this as compose.yaml.

name: langbot-n8n-astra
services:
  n8n:
    image: docker.n8n.io/n8nio/n8n:2.39.6
    environment:
      TZ: Asia/Shanghai
      GENERIC_TIMEZONE: Asia/Shanghai
      N8N_HOST: localhost
      N8N_PORT: 5678
      N8N_PROTOCOL: http
      N8N_EDITOR_BASE_URL: http://localhost:5690
      WEBHOOK_URL: http://localhost:5690/
      N8N_DIAGNOSTICS_ENABLED: 'false'
      N8N_PERSONALIZATION_ENABLED: 'false'
    ports:
      - '127.0.0.1:5690:5678'
    volumes:
      - n8n_data:/home/node/.n8n
      - ./workflows:/imports:ro
    restart: unless-stopped
  demo-api:
    image: python:3.12-alpine
    command: [python, /app/demo-api.py]
    volumes:
      - ./demo-api.py:/app/demo-api.py:ro
      - ./data/demo:/data
    restart: unless-stopped
  runtime:
    image: rockchin/langbot:v4.10.11
    command: [uv, run, --no-sync, -m, langbot_plugin.cli.__init__, rt]
    volumes:
      - ./data/langbot/plugins:/app/data/plugins
    restart: unless-stopped
  langbot:
    image: rockchin/langbot:v4.10.11
    depends_on: [runtime, n8n]
    environment:
      TZ: Asia/Shanghai
      BOX__ENABLED: 'false'
      PLUGIN__RUNTIME_WS_URL: ws://runtime:5400/control/ws
      API__WEBUI_URL: http://localhost:5370
      API__WEBHOOK_PREFIX: http://localhost:5370
    volumes:
      - ./data/langbot:/app/data
    ports:
      - '127.0.0.1:5370:5300'
    restart: unless-stopped
volumes:
  n8n_data:

Save demo-api.py beside it. This complete service contains synthetic orders and a persistent draft-task endpoint.

"""Local synthetic order/task service. No real customer data or external writes."""
from http.server import BaseHTTPRequestHandler, HTTPServer
import json
import sqlite3
from pathlib import Path

Path('/data').mkdir(exist_ok=True)
db = sqlite3.connect('/data/tasks.sqlite')
db.execute('CREATE TABLE IF NOT EXISTS meetings (id TEXT PRIMARY KEY, payload TEXT NOT NULL)')
ORDERS = {
 'DEMO-1001': {'order_id':'DEMO-1001','status':'shipped','carrier':'Demo Express','tracking':'DEMO-TRACK-901','estimated_delivery':'2026-09-20','items':['USB-C Hub']},
 'DEMO-1002': {'order_id':'DEMO-1002','status':'processing','carrier':None,'tracking':None,'estimated_delivery':None,'items':['Desk Lamp']},
}
class Handler(BaseHTTPRequestHandler):
 def reply(self, data, code=200):
  body=json.dumps(data,ensure_ascii=False).encode();self.send_response(code);self.send_header('Content-Type','application/json');self.end_headers();self.wfile.write(body)
 def do_GET(self):
  if self.path.startswith('/orders/'):
   key=self.path.rsplit('/',1)[-1];self.reply({'found':key in ORDERS,'order':ORDERS.get(key),'source':'Synthetic tutorial order database'})
  elif self.path=='/tasks':
   self.reply({'meetings':[json.loads(x[0]) for x in db.execute('SELECT payload FROM meetings ORDER BY rowid DESC LIMIT 20')]})
  else:self.reply({'service':'LangBot tutorial demo API','fixtures':True})
 def do_POST(self):
  if self.path!='/tasks':return self.reply({'error':'Not found'},404)
  try:
   obj=json.loads(self.rfile.read(int(self.headers.get('Content-Length','0'))));key=obj['meeting_id']
   if not isinstance(obj.get('tasks'),list) or not key:raise ValueError('Invalid task payload')
   db.execute('INSERT INTO meetings VALUES (?,?) ON CONFLICT(id) DO UPDATE SET payload=excluded.payload',(key,json.dumps(obj,ensure_ascii=False)));db.commit()
   self.reply({'saved':True,'meeting_id':key,'task_count':len(obj['tasks']),'record':obj})
  except (ValueError,KeyError):self.reply({'error':'Invalid task payload'},400)
HTTPServer(('0.0.0.0',8080),Handler).serve_forever()

mkdir -p workflows
docker compose up -d
docker compose ps

Open http://localhost:5690 to create the local n8n owner, then initialize LangBot at http://localhost:5370. Skip bot onboarding for now and create the pipeline first. These ports bind to loopback for the lab. Docker volumes and the data directory retain state across container restarts.

The local n8n owner setup screen
In LangBot 4.10.11, the native n8n runner lives in the pipeline settings. Later releases may expose it through a Runner plugin, so use the version shown here when following the screenshots.

2. Build the workflow with explicit steps

Start the notes with a unique meeting ID. The demo API uses it as its database key: processing the same meeting ID again replaces the draft instead of appending another copy.

The model returns meeting_id, summary, and a tasks array. Every task has owner, task, and due_date; missing owners and dates stay null. Validate Task JSON parses and checks the structure. Save Draft Tasks then makes a real HTTP POST. The reply says saved only after that request succeeds.

The supplied Python service persists to SQLite in a mounted data directory. It is a small runnable task sink, not a Slack task manager or a production assignment system. To use your own tracker, replace the persistence node and map chat identities to the tracker identities.

The complete workflow, from chat input to HTTP response
Create a workflow in n8n and add the nodes shown. Keep the names below unchanged: expressions refer to upstream nodes by name. Configure them as follows.

Node	Type	Settings
Chat Webhook	webhook	POST; Path: astra-meeting; Respond: Using Respond to Webhook Node
GPT-6 Astra - Extract Tasks	httpRequest	POST; https://newapi.rockchin.top/v1/chat/completions; Header Auth
Validate Task JSON	code	Run Once for All Items; JavaScript
Save Draft Tasks	httpRequest	POST; http://demo-api:8080/tasks
Reply to LangBot	code	Run Once for All Items; JavaScript
Respond to Chat	respondToWebhook	Text; Content-Type: application/json; charset=utf-8

Validating extracted task JSON

Posting the draft to the local task API

Model credential and request body

Create a Header Auth credential in n8n: Name is Authorization, Value is Bearer YOUR_API_KEY. In the model HTTP Request node, select Generic Credential Type → Header Auth and bind that credential. Do not put a real key in Code nodes or workflow exports. LangBot does not automatically pass its model credential to n8n.

Enable Send Body → JSON → Using JSON, switch to Expression, and enter the expression below. The URL shown is the compatible gateway used for this lab; change it and the model ID for your own provider.

{{
JSON.stringify({
  model: "gpt-6-astra",
  messages: [
    {
      role: "system",
      content:
        "Extract meeting action items. Return JSON only: {meeting_id:string,summary:string,tasks:[{owner:string|null,task:string,due_date:string|null}]}. Preserve the supplied meeting ID. Do not invent owners, deadlines or completed actions. Use null when unknown. Respond in the language of the notes. This is a draft extraction, not a message to assignees.",
    },
    {
      role: "user",
      content: JSON.stringify(
        $("Chat Webhook").first().json.body.chatInput,
      ),
    },
  ],
  stream: false,
  max_tokens: 1500,
  response_format: { type: "json_object" },
})
}}

Code node contents

Validate Task JSON

const text = $json.choices[0].message.content;
const d = JSON.parse(text.replace(/^```
{% endraw %}
(?:json)?\s*|\s*
{% raw %}
```$/g, ""));
if (!d.meeting_id || !Array.isArray(d.tasks))
  throw new Error("Invalid meeting schema");
for (const t of d.tasks) {
  if (typeof t.task !== "string" || !t.task.trim())
    throw new Error("Empty task");
  t.owner = t.owner || null;
  t.due_date = t.due_date || null;
}
return [{ json: d }];

Reply to LangBot

const d = $json.record;
const lines = d.tasks.map(
  (t, i) =>
    `${i + 1}. ${t.task} | Owner: ${t.owner || "Unassigned"} | Due: ${t.due_date || "Not specified"}`,
);
return [
  {
    json: {
      response: `Meeting ${d.meeting_id} — ${$json.task_count} draft tasks saved.\n${d.summary}\n\n${lines.join("\n")}\n\nReview before assigning. No notifications were sent.`,
    },
  },
];

JSON Body for the persistence request:

{{
JSON.stringify($json)
}}

Connections and the final response

• Chat Webhook → GPT-6 Astra - Extract Tasks
• GPT-6 Astra - Extract Tasks → Validate Task JSON
• Validate Task JSON → Save Draft Tasks
• Save Draft Tasks → Reply to LangBot
• Reply to LangBot → Respond to Chat

The final Respond to Chat is a Respond to Webhook node. Choose Text, add the response header Content-Type: application/json; charset=utf-8 in Options, and use this Response Body expression:

{{
JSON.stringify($json).replace(
  /[\u007f-\uffff]/g,
  (c) => "\\u" + c.charCodeAt(0).toString(16).padStart(4, "0"),
)
}}

This is still a JSON response. Non-ASCII characters are escaped on the wire and restored by JSON parsing. It avoids a chunk-decoding issue observed with long Chinese replies in this LangBot build. The final object must contain a string named response. Set Options → Timeout in the model HTTP Request to 90000 milliseconds.

Click Publish when the workflow is ready. In n8n 2.39.6, that enables its production webhook. Do not leave LangBot pointing at a temporary /webhook-test/ URL after a manual test.

An explicit JSON response that preserves Unicode text

3. Connect the workflow to LangBot

Create a pipeline in LangBot. Open Configuration → AI and select n8n Workflow API as the Runner. Use:

• Webhook URL: http://n8n:5678/webhook/astra-meeting
• Output Key: response
• Timeout: 150
• Webhook Response Handling: Forward as chat reply
• Authentication Type: None (this isolated local lab only)

The hostname is the common gotcha. Your browser uses localhost:5690; the LangBot container reaches the n8n service at n8n:5678 on the Compose network. Inside that container, localhost points back to LangBot itself.

For a deployment across hosts, use HTTPS and configure matching Header Auth or Basic Auth on the n8n Webhook and LangBot runner. The unauthenticated tutorial endpoints are limited to the local lab, not a public deployment recipe.

The n8n Runner settings in LangBot; use this case's webhook path
Save the pipeline, open Debug Chat, and send:

Meeting ID: DEMO-MEETING-02. Maya will prepare the API checklist by 2026-09-21. Leo will review webhook errors; no deadline was agreed. The onboarding guide needs an update, but no owner was assigned. Save draft action items.

A real request and reply through LangBot Debug Chat
The run saved three tasks. The first had an owner and a date, the second had an owner with no deadline, and the third had neither. Reading the database back matched the persistence node's output, including the null fields.

Extraction is not assignment. These are draft records, and the workflow sent no teammate notifications. Before wiring it into a real tracker, add review, scope access to the right meetings, and validate the meeting ID against the submitted request. The tutorial sink is intentionally limited to synthetic notes.

The n8n execution view lets you inspect each step
Read back the records independently to verify persistence:

docker compose exec demo-api python -c "import urllib.request; print(urllib.request.urlopen('http://localhost:8080/tasks').read().decode())"

The persistence node returns the stored record

4. Put it behind your messaging platform

The tested path is LangBot Debug Chat → n8n → model/data API → LangBot reply. No real Slack, Discord, Telegram or LINE account was connected for these screenshots. The following is the adapter setup path, not a claim of live delivery to those platforms.

Platform	Platform-side setup	LangBot setup
Slack	Create a Slack app, configure bot scopes and subscribed events, install it in the workspace; retain the bot token and signing secret	Select Slack, enter those credentials, and register the callback URL shown by LangBot in Event Subscriptions. Reinstall after changing scopes. Guide
Discord	Create an application and bot; obtain the client ID and bot token, enable the required gateway intents, and invite the bot with the required permissions	Select Discord and enter the client ID and token. Bind the pipeline below. Guide
Telegram	Create a bot with BotFather and retain its token. For group use, configure privacy mode for the messages the bot should receive	Select Telegram, enter the token, save, and bind the pipeline. Guide
LINE	Enable Messaging API for the channel, obtain the channel secret and channel access token	Select LINE, enter both values, copy LangBot's public HTTPS callback URL to LINE, and enable Use Webhook. Guide
Lark / Feishu	Create an app with bot capability and message permissions	Enter App ID / App Secret in Lark. Use long connection where supported, or configure the generated webhook callback. Guide
DingTalk	Create an enterprise bot and enable Stream Mode Push	Enter Client ID / Client Secret in DingTalk. Card streaming also needs a configured template and permissions. Guide
WeCom / WeChat Official Account	Use the corresponding enterprise or official-account credentials and message-encryption settings	Select the matching adapter and register its callback; the credential sets are different. WeCom, Official Account
QQ / OneBot	Configure a QQ official bot or a running OneBot v11 implementation	Choose QQ Official API or OneBot v11 and configure the callback/WebSocket connection. QQ, OneBot

LangBot also offers adapters for Mattermost, Matrix, KOOK and Satori, plus HTTP and embedded webpage bots. Personal WeChat options depend on the adapter and version. Check Create Bot and the platform index for your installed release.

The platform selector in the English LangBot interface
After creating the bot, bind it to this pipeline and enable it. For group chats, also check the @-mention or prefix rules under Trigger. A bot that is online but silent may never be triggering the workflow. Callback-based adapters need reachable HTTPS; long-connection and polling adapters have their own network requirements.

5. Three places to check when it fails

• Webhook 404: confirm the workflow is published and the URL uses /webhook/.
• A successful execution but an empty chat reply: inspect the final JSON for a string named response, then check the runner's Output Key.
• A model-node 401, timeout or empty result: check the credential bound inside n8n, the complete endpoint, the model ID and that execution's data. LangBot and n8n have separate model configurations.

I would lock down the input, evidence and response contract before adding more models or channels. LangBot makes the division useful: business steps stay in n8n, while a new chat destination mainly changes the adapter and pipeline binding.

References: LangBot n8n integration, LangBot source, n8n source and releases.

Configuration and screenshots come from a running local lab. Test inputs are synthetic. AI assisted with drafting; the instructions were checked against execution records.