Telegram, Slack & Messaging

Your team is drowning in newsletters and blog feeds. Important articles get missed and nobody has time to read everything. What if an AI bot automatically scanned your favorite RSS feeds every hour, wrote a crisp two-sentence summary of each new article, and posted it straight to your Discord channel? That’s exactly what you’ll build here: a fully automated n8n workflow that monitors RSS feeds, uses OpenAI to generate smart summaries, and delivers them to Discord, with a Google Sheet keeping track so nothing gets posted twice.

Prefer to skip the setup? Grab the ready-made template → and be up and running in under 10 minutes.

What You’ll Build

1. A scheduled n8n workflow that wakes up every hour and fetches the latest items from any RSS feed you choose.
2. A deduplication layer backed by Google Sheets so the same article is never posted twice, even across restarts.
3. An OpenAI call that reads each article’s title and snippet and writes a punchy 2 to 3 sentence summary tailored for a Discord audience.
4. An automatic Discord post that drops the summary, the article title, and the link into your chosen channel, formatted and ready to read.
5. A log entry written back to Google Sheets so the system stays in sync across all future runs.

How It Works: The Big Picture

The workflow runs on a timer, pulls from your RSS feed, filters out anything already posted, summarizes the new items with AI, and delivers them to Discord, all without you touching a thing.

┌──────────────────────────────────────────────────────────────────┐
│  RSS FEED AI SUMMARIZER TO DISCORD                               │
│                                                                  │
│  [Schedule Trigger]                                              │
│       │  (every 1 hour)                                          │
│       ▼                                                          │
│  [RSS Feed Read]                                                 │
│       │  (fetch all items from feed)                             │
│       ▼                                                          │
│  [Get Tracked URLs] ◄── Google Sheets (Tracked tab)             │
│       │  (read previously posted URLs)                           │
│       ▼                                                          │
│  [Filter New Articles]                                           │
│       │  (Code node: remove duplicates, cap at 5 items)          │
│       ▼                                                          │
│  [Summarize with OpenAI]                                         │
│       │  (HTTP Request → OpenAI Chat Completions API)            │
│       ▼                                                          │
│  [Build Discord Message]                                         │
│       │  (Set node: format title + summary + link)               │
│       ▼                                                          │
│  [Post to Discord]                                               │
│       │  (HTTP Request → Discord Webhook URL)                    │
│       ▼                                                          │
│  [Log URL to Sheet]                                              │
│       (Append row: url, title, summary, posted_at)               │
└──────────────────────────────────────────────────────────────────┘

What You’ll Need

• n8n: self-hosted (v1.0+) or n8n Cloud (any paid plan)
• An RSS feed URL: any public feed (TechCrunch, Hacker News, a podcast, a company blog…)
• An OpenAI account: API key from platform.openai.com; GPT-4o-mini usage is very cheap (roughly $0.002 per summary)
• A Google account: for the tracking spreadsheet (Google Sheets OAuth2)
• A Discord server: with permission to create a Webhook URL in the target channel

Estimated build time: 35 to 50 minutes from scratch, or under 10 minutes with the ready-made template.

Part 1: The Workflow, Node by Node

1 Schedule Trigger (Schedule Trigger)

This is the engine that starts the whole thing. It fires the workflow automatically on a fixed interval so you never have to run it manually. Set Trigger Interval to Hours and the value to 1. The workflow will now run every hour.

2 RSS Feed Read (RSS Feed Read)

Fetches the RSS feed and returns all available items as individual records, typically 10 to 25 per feed. Paste your RSS feed URL into the URL field. For example, TechCrunch’s feed is https://techcrunch.com/feed/.

{
  "title": "Anthropic Raises $4B Series E at $18B Valuation",
  "link": "https://techcrunch.com/2026/04/05/anthropic-series-e/",
  "pubDate": "Sat, 05 Apr 2026 14:22:00 +0000",
  "contentSnippet": "Anthropic, the AI safety company behind Claude, has raised $4 billion..."
}

3 Get Tracked URLs (Google Sheets)

Before processing anything, the workflow reads a Google Sheet to see which article URLs have already been posted to Discord. Connect your Google Sheets OAuth2 credential, set Document ID to your spreadsheet ID, sheet name to Tracked, and operation to Read.

4 Filter New Articles (Code)

This JavaScript node cross-references the RSS items against the tracked URLs and returns only articles that haven’t been posted yet. It also caps the output at 5 items per run to prevent Discord channel flooding. Set the node to Run Once for All Items mode.

const rssItems = $('RSS Feed Read').all();
const trackedItems = $('Get Tracked URLs').all();
const trackedUrls = new Set(
  trackedItems.map(item => (item.json.url || item.json.URL || '').trim()).filter(Boolean)
);
const newItems = rssItems.filter(item => {
  const url = (item.json.link || item.json.url || '').trim();
  return url && !trackedUrls.has(url);
});
return newItems.slice(0, 5).map(item => ({ json: item.json }));

5 Summarize with OpenAI (HTTP Request)

Sends each new article’s title and snippet to the OpenAI API and gets back a tight 2 to 3 sentence summary. Set method to POST, URL to https://api.openai.com/v1/chat/completions. Set authentication to HTTP Header Auth with header Authorization: Bearer YOUR_API_KEY.

{
  "model": "gpt-4o-mini",
  "messages": [
    {"role": "system", "content": "Summarize this article in 2-3 sentences for a Discord audience."},
    {"role": "user", "content": "Title: {{ $json.title }}\nContent: {{ $json.contentSnippet }}"}
  ],
  "max_tokens": 200
}

6 Build Discord Message (Set)

This node assembles the final Discord message by combining the article title, AI summary, link, and timestamp. Add an assignment named discord_message:

📰 **{{ $('Filter New Articles').item.json.title }}**

{{ $json.choices[0].message.content }}

🔗 Read more: {{ $('Filter New Articles').item.json.link }}

_{{ $now.format('MMMM d, yyyy · h:mm a') }} UTC_

7 Post to Discord (HTTP Request)

Sends the formatted message to your Discord channel using a Webhook URL. To create a webhook: go to your Discord server → right-click the channel → Edit Channel → Integrations → Webhooks → New Webhook. Copy the URL and paste it as the node’s URL. Set method to POST with this JSON body:

{
  "content": "{{ $json.discord_message }}",
  "username": "RSS News Bot"
}

8 Log URL to Sheet (Google Sheets)

After posting, this node appends a row to the Google Sheet with the article URL, title, AI summary, and timestamp. Set operation to Append, use the same spreadsheet and Tracked sheet, and map columns: url, title, summary, posted_at.

The Data Structure

The Google Sheet is the workflow’s memory. Create a sheet named Tracked with these column headers in row 1:

Full System Flow

Schedule Trigger (every hour)
       │
       ▼
RSS Feed Read → [10-25 items: title, link, contentSnippet]
       │
       ▼
Get Tracked URLs (Google Sheets READ) → [list of previously posted URLs]
       │
       ▼
Filter New Articles (Code) → [0-5 new items only]
       │
       ▼  (for each new item)
Summarize with OpenAI → [2-3 sentence AI summary]
       │
       ▼
Build Discord Message → [formatted text with title + summary + link]
       │
       ▼
Post to Discord (Webhook) → [message appears in channel]
       │
       ▼
Log URL to Sheet (Google Sheets APPEND) → [new row: url|title|summary|time]
       │
       ↑ cycle repeats next hour

Testing Your Workflow

1. Before activating, run the workflow manually using the Test workflow button in n8n’s top toolbar.
2. After the RSS Feed Read executes, click it and confirm you see article items in the output panel.
3. On the first run your sheet is empty. Filter New Articles should pass through up to 5 items.
4. Check your Discord channel: formatted news messages should appear within seconds.
5. Check your Google Sheet, the Tracked tab should have rows for each posted article.
6. Run the workflow a second time manually. Filter should return 0 items, deduplication is working.

Frequently Asked Questions

What’s Next?

• Add Slack support: Duplicate the Discord posting step and route summaries to a Slack channel.
• Filter by keyword: Add an IF node to only process articles containing keywords like “AI”, “funding”, or your company name.
• Weekly digest: Change the Schedule Trigger to run weekly and bundle all new items into a single long-form Discord post.
• Add sentiment scoring: Extend the OpenAI prompt to return a sentiment score, then route only positive articles to your channel.

Every team has that one Slack channel, the one where the same five questions get asked every single week. “Where’s the onboarding doc?” “What’s the refund policy?” “How do I reset my API key?” Your senior engineers are answering these instead of shipping. Your support lead is copy-pasting the same response for the third time today. With this n8n workflow, you’ll build an AI-powered Slack bot that reads incoming questions, searches your company knowledge base using semantic vector search, and posts precise answers back in the thread, automatically, in about 2 seconds.

Prefer to skip the setup? Grab the ready-made template → and be running in under 10 minutes.

What You’ll Build

1. A Slack bot that listens for messages in any channel it’s invited to
2. An OpenAI step that converts each incoming question into a 1,536-dimensional vector embedding
3. A Pinecone semantic search that retrieves the most relevant chunks from your knowledge base
4. A GPT-4o-mini step that reads the retrieved context and writes a clear, grounded answer
5. An automatic thread reply in Slack so teammates get instant answers without leaving the channel

How It Works: The Big Picture

This workflow uses the RAG pattern, Retrieval-Augmented Generation. Instead of asking an AI to recall facts from its training data (which goes stale), you store your up-to-date company knowledge in Pinecone as vector embeddings. When a question arrives, the bot finds the semantically closest knowledge chunks and hands them to GPT-4o-mini as context. The result: factual, grounded answers drawn only from your approved content.

┌─────────────────────────────────────────────────────────────────────┐
│  SLACK KNOWLEDGE BASE BOT                                           │
│                                                                     │
│  [Slack Trigger]                                                    │
│        ↓                                                            │
│  [Filter Bot Messages] ──(bot message)──→ (stop — no loop)         │
│        ↓ (user message)                                             │
│  [Generate Question Embedding]  (OpenAI text-embedding-3-small)    │
│        ↓ 1,536-dim vector                                           │
│  [Query Pinecone]  (top-5 semantic matches from knowledge base)     │
│        ↓ matched chunks + scores                                    │
│  [Extract Context]  (filter score > 0.7, join top 3 chunks)        │
│        ↓ formatted context string                                   │
│  [Generate AI Answer]  (GPT-4o-mini + RAG prompt)                  │
│        ↓ natural language answer                                    │
│  [Post Answer to Slack]  (reply in the original thread)            │
└─────────────────────────────────────────────────────────────────────┘

What You’ll Need

• n8n, self-hosted (v1.0+) or n8n Cloud
• Slack app with Events API enabled and a Bot User Token (starts with xoxb-)
• OpenAI account: API key with access to text-embedding-3-small and gpt-4o-mini
• Pinecone account: free Starter plan is plenty; create an index with dimension 1536 and metric cosine
• A pre-populated Pinecone namespace called knowledge-base (the Credentials Guide includes a Python ingestion script)

Estimated build time: 45 to 60 minutes from scratch, or under 10 minutes with the template.

Building the Bot: Step by Step

1 Slack Trigger

This node opens a webhook endpoint that Slack’s Events API calls every time a message is posted in a channel your bot belongs to. It’s the entry point for everything.

1. Add a Slack Trigger node to your canvas.
2. Select your Slack Bot Token credential (or create one, see the Credentials Guide).
3. Set the Trigger to Message.
4. Copy the Webhook URL n8n displays. Paste it into your Slack app’s Event Subscriptions → Request URL field.
5. In Slack app settings, enable the message.channels and message.groups event scopes, then reinstall the app to your workspace.

A message event payload looks like this:

{
  "type": "message",
  "text": "What is our refund policy for annual subscriptions?",
  "user": "U04ABCDEF12",
  "channel": "C06XYZABC99",
  "ts": "1743784201.000100",
  "subtype": null
}

2 Filter Bot Messages (IF)

This IF node stops the workflow from processing bot messages. It’s a one-condition check that routes user messages forward and drops everything else.

1. Add an IF node connected to the Slack Trigger output.
2. Set Value 1 to ={{ $json.subtype }}.
3. Condition: Is Not Equal To → bot_message.
4. Connect the True output to Step 3. Leave False unconnected.

3 Generate Question Embedding (HTTP Request → OpenAI)

This node calls the OpenAI Embeddings API and converts the user’s question into a 1,536-dimensional vector, a list of numbers that captures the semantic meaning of the sentence. Pinecone will use this to find similar content.

1. Add an HTTP Request node.
2. Method: POST | URL: https://api.openai.com/v1/embeddings
3. Authentication: Generic Credential Type → HTTP Header Auth. Create a credential with Name = Authorization and Value = Bearer YOUR_OPENAI_API_KEY.
4. Body Content Type: JSON. Paste this body:

{
  "input": "={{ $('Slack Trigger').item.json.text }}",
  "model": "text-embedding-3-small"
}

The response contains the embedding inside data[0].embedding:

{
  "object": "list",
  "data": [
    {
      "object": "embedding",
      "index": 0,
      "embedding": [0.0023, -0.0189, 0.0341, "...1,533 more values..."]
    }
  ],
  "model": "text-embedding-3-small",
  "usage": { "prompt_tokens": 11, "total_tokens": 11 }
}

4 Query Pinecone (HTTP Request)

This node sends the question vector to Pinecone and gets back the five most semantically similar knowledge chunks, each scored between 0 (irrelevant) and 1 (identical).

1. Add another HTTP Request node.
2. Method: POST | URL: https://YOUR_PINECONE_INDEX_HOST/query (replace with your index host from the Pinecone console, it looks like my-index-abc123.svc.us-east-1.pinecone.io)
3. Add a header: Name = Api-Key, Value = YOUR_PINECONE_API_KEY.
4. Body Content Type: JSON. Use this expression as the body:

{
  "vector": "={{ $json.data[0].embedding }}",
  "topK": 5,
  "includeMetadata": true,
  "namespace": "knowledge-base"
}

Pinecone responds with the top matches and their stored metadata:

{
  "matches": [
    {
      "id": "doc-refund-annual-001",
      "score": 0.921,
      "metadata": {
        "text": "Annual subscriptions may be refunded within 30 days of purchase for a full refund. After 30 days, refunds are prorated based on remaining months.",
        "source": "help-center/billing",
        "last_updated": "2026-03-01"
      }
    },
    {
      "id": "doc-refund-annual-002",
      "score": 0.874,
      "metadata": {
        "text": "To request a refund, email billing@acme-corp.com with your order number and reason for cancellation. Refunds are processed within 5 business days.",
        "source": "help-center/billing",
        "last_updated": "2026-03-01"
      }
    }
  ],
  "namespace": "knowledge-base"
}

5 Extract Context (Code)

This JavaScript node processes the Pinecone results: filters low-confidence matches, takes the top 3 chunks, formats them into a numbered context string, and bundles the data for the next node.

const matches = $input.item.json.matches || [];
const slackData = $('Slack Trigger').item.json;

if (matches.length === 0) {
  return [{
    json: {
      context: 'No relevant information found in the knowledge base.',
      question: slackData.text,
      channel: slackData.channel,
      thread_ts: slackData.ts
    }
  }];
}

const context = matches
  .filter(m => m.score > 0.7)
  .slice(0, 3)
  .map((m, i) => `[${i + 1}] ${m.metadata.text}`)
  .join('\n\n');

return [{
  json: {
    context: context || 'No highly relevant information found.',
    question: slackData.text,
    channel: slackData.channel,
    thread_ts: slackData.ts
  }
}];

After this node, the data is clean and ready for the AI:

{
  "context": "[1] Annual subscriptions may be refunded within 30 days...\n\n[2] To request a refund, email billing@acme-corp.com...",
  "question": "What is our refund policy for annual subscriptions?",
  "channel": "C06XYZABC99",
  "thread_ts": "1743784201.000100"
}

6 Generate AI Answer (HTTP Request → OpenAI Chat)

This node sends the retrieved context and the original question to GPT-4o-mini. The system prompt instructs the model to answer strictly from the provided context, with no hallucinating facts that aren’t in your knowledge base.

1. Method: POST | URL: https://api.openai.com/v1/chat/completions
2. Reuse your OpenAI HTTP Header Auth credential.
3. Body (JSON):

{
  "model": "gpt-4o-mini",
  "messages": [
    {
      "role": "system",
      "content": "You are a helpful company knowledge base assistant. Answer questions using ONLY the provided context. If the context does not contain the answer, say so clearly and suggest the user contact the team directly. Keep answers concise and actionable."
    },
    {
      "role": "user",
      "content": "Context:\n={{ $json.context }}\n\nQuestion: ={{ $json.question }}"
    }
  ],
  "max_tokens": 500,
  "temperature": 0.2
}

7 Post Answer to Slack

The final node takes GPT-4o-mini’s answer and posts it as a thread reply, so the answer lives directly under the original question rather than flooding the main channel.

1. Add a Slack node. Resource: Message, Operation: Post.
2. Channel: ={{ $('Extract Context').item.json.channel }}
3. Text: ={{ $json.choices[0].message.content }}
4. Under Other Options, set Thread Timestamp to ={{ $('Extract Context').item.json.thread_ts }}
5. Use the same Slack credential as the Slack Trigger.

The Data Flow

Here’s how a single question moves through all seven nodes, from Slack message to bot reply:

Pinecone Knowledge Base Schema

Every vector record you upsert into Pinecone must follow this structure. The text metadata field is required, and the Extract Context node reads it directly.

Full System Flow

User posts question in Slack
          │
          ▼
┌─────────────────────┐
│    Slack Trigger    │  Receives message.channels event via webhook
└─────────────────────┘
          │
          ▼
┌─────────────────────┐
│ Filter Bot Messages │──── subtype = "bot_message"? ──→ STOP
└─────────────────────┘
          │ user message passes
          ▼
┌──────────────────────────┐
│ Generate Question        │  POST https://api.openai.com/v1/embeddings
│ Embedding (OpenAI)       │  model: text-embedding-3-small → 1,536-dim vector
└──────────────────────────┘
          │
          ▼
┌──────────────────────────┐
│ Query Pinecone           │  POST {index-host}/query
│ (vector search)          │  topK=5 · namespace: knowledge-base
└──────────────────────────┘
          │ top matches with metadata + scores
          ▼
┌──────────────────────────┐
│ Extract Context          │  Filter: score > 0.7
│ (Code node)              │  Join top 3 chunks into context string
└──────────────────────────┘
          │
          ▼
┌──────────────────────────┐
│ Generate AI Answer       │  POST https://api.openai.com/v1/chat/completions
│ (GPT-4o-mini)            │  RAG prompt · temperature: 0.2 · max_tokens: 500
└──────────────────────────┘
          │ grounded answer text
          ▼
┌──────────────────────────┐
│ Post Answer to Slack     │  Thread reply on original message
└──────────────────────────┘
          │
          ▼
Team member sees the answer in 2 to 3 seconds ✓

Testing Your Workflow

1. Make sure the workflow is toggled to Active in n8n.
2. Invite your bot to a test channel: type /invite @YourBotName.
3. Post a question you know is covered in your knowledge base, for example: “What’s the refund policy for annual plans?”
4. Within 2 to 3 seconds, a thread reply should appear with a grounded answer drawn from your Pinecone content.
5. Post a question that’s definitely not in your knowledge base. The bot should say it doesn’t have that information and suggest contacting the team.
6. Check the n8n Execution log to confirm all 7 nodes completed with green checkmarks and no errors.

Frequently Asked Questions

What’s Next?

• Add answer feedback: Let users react 👍 or 👎 on bot replies, log reactions to Airtable, and use quality scores to identify gaps in your knowledge base.
• Auto-ingest from Notion or Confluence: Build a companion n8n workflow that watches for document updates and automatically re-embeds modified pages into Pinecone.
• Add a Slack slash command: Create a /ask command so users can query the bot privately in DMs without cluttering a shared channel.
• Multi-namespace routing: Create separate Pinecone namespaces for HR, Engineering, and Sales, and route questions to the right namespace based on which Slack channel they came from.