Automate RSS Headlines to Slack with n8n & RAG

Imagine getting the most important news, competitor updates, or industry signals delivered straight into Slack, already summarized, enriched with context, and neatly logged for later. No more skimming endless RSS feeds or drowning in headlines that all look the same.

That is exactly what the “RSS Headlines Slack” n8n workflow template is built to do. It pulls in RSS items, turns them into embeddings with Cohere, stores them in Pinecone for semantic search, runs a RAG agent with OpenAI to interpret them, logs results to Google Sheets, and keeps you in the loop with Slack alerts if anything breaks.

Let’s walk through how it works, when you might want to use it, and how to get it running without a headache.

What this n8n template actually does

At its core, this workflow is an automated RSS-to-Slack pipeline with RAG and logging. Instead of just dumping raw headlines into a channel, it:

• Ingests RSS items via a Webhook Trigger
• Splits the text into chunks for stable embeddings
• Generates embeddings with Cohere’s embed-english-v3.0
• Stores and queries vectors in a Pinecone index
• Uses a RAG agent with OpenAI to add context, summaries, or classifications
• Logs each processed item to a Google Sheet for tracking and analysis
• Alerts you in Slack if something goes wrong

So instead of “yet another RSS feed,” you get a smart, searchable, and auditable alerting system that plugs right into your team’s daily workflow.

When this workflow is a perfect fit

Think about any situation where you need to stay on top of fast-moving information, but you do not want to manually read every single headline. This template shines when you are dealing with:

• Competitive intelligence – Track product updates, press releases, or blog posts from competitors.
• Industry monitoring – Follow niche news, regulations, or market trends.
• PR and comms – Keep an eye on mentions, announcements, or coverage.
• Newsroom workflows – Surface relevant stories for editors or analysts.

If you are already living in Slack and using RSS feeds somewhere in your stack, this workflow helps you cut noise, avoid duplicates, and get context at a glance.

Why it makes your life easier

Instead of manually checking feeds and copying links into Slack, this n8n template:

• Prevents headline overload by de-duplicating similar stories with semantic search.
• Adds meaning using a RAG agent that can summarize, classify, or tag each item.
• Creates an audit trail in Google Sheets so you can review, analyze, or export data later.
• Notifies you on errors in Slack so you do not quietly miss important updates.

In short, it takes a firehose of RSS data and turns it into a stream of useful, contextual alerts.

How the n8n workflow is structured

This template is an n8n workflow made up of several key nodes that each handle one part of the process.

1. Webhook Trigger: your RSS entry point

The workflow starts with a Webhook Trigger node that receives incoming RSS notifications as a POST request.

You can use:

• An RSS-to-webhook service
• Or another n8n workflow that polls an RSS feed and forwards new items

The payload should ideally include:

• headline
• url
• summary
• pubDate or published timestamp

2. Text Splitter: prepping content for embeddings

Some RSS items contain more than just a short headline. To make embeddings reliable, the workflow uses a Text Splitter node.

It uses a character-based splitter with:

• Chunk size: 400 characters
• Chunk overlap: 40 characters

This keeps context across chunk boundaries while staying within model limits so your embeddings are accurate and stable.

3. Embeddings (Cohere): turning text into vectors

Next, each chunk goes into the Embeddings (Cohere) node.

Here the workflow uses Cohere’s embed-english-v3.0 model to convert text into vector embeddings. These embeddings are what make semantic search and similarity checks possible later on.

4. Pinecone Insert and Query: memory for your headlines

Once embeddings are generated, the workflow talks to Pinecone, a vector database.

• Insert: Embeddings are stored in a Pinecone index named rss_headlines_slack.
• Metadata: Each vector keeps useful metadata like headline, URL, timestamp, and source.
• Query: Before inserting or when enriching, the workflow can query Pinecone to find near-duplicates or pull in context.

This is what lets the system avoid repeated alerts for essentially the same story and gives the RAG agent more context to work with.

5. Window Memory and Vector Tool: context for the RAG agent

The workflow then uses two tools to feed context into the RAG agent:

• Window Memory: Keeps a short rolling buffer of recent context so the agent can “remember” a bit of what happened earlier in the workflow.
• Vector Tool: Connects directly to the Pinecone index so the agent can retrieve relevant embeddings while reasoning.

Together, they help the agent generate responses that are grounded in actual stored data, not just the current input.

6. Chat Model (OpenAI) and RAG Agent: adding intelligence

Now the fun part. The workflow uses a Chat Model (OpenAI) together with a RAG Agent.

The RAG agent uses:

• Your configured OpenAI chat model
• The Vector Tool to pull relevant vectors from Pinecone

Based on the prompt you provide, the agent can:

• Summarize the article or headline
• Classify tone or sentiment
• Assign a priority level
• Detect topics or tags

You control this behavior through prompt design, which we will touch on in a moment.

7. Append Sheet (Google Sheets): logging everything

After the agent does its work, the output is written to a Google Sheet using an Append Sheet node.

Typically this goes into a sheet named something like “Log”, where each row might include:

• Headline
• URL
• Published date
• Summary or classification from the RAG agent
• Status, tags, or priority

This gives you a persistent audit trail you can review, filter, or export for analytics.

8. Slack Alert: catching issues early

If something goes wrong, you do not want to silently miss stories. That is why the workflow includes a Slack Alert node.

When the RAG agent errors out or the workflow detects an issue, it posts a message to a channel you choose, for example #alerts. That way, you or your team can jump in quickly and fix things.

How data flows through the workflow

To recap the journey of a single RSS item, here is the flow from start to finish:

1. An RSS item triggers the Webhook node.
2. The text is split into chunks by the Text Splitter.
3. Chunks are sent to Cohere to generate embeddings.
4. Embeddings are inserted into Pinecone and also used to query for similar vectors.
5. The RAG agent, powered by OpenAI + Vector Tool + Window Memory, enriches or summarizes the item.
6. Results are appended to Google Sheets for logging.
7. If something fails, a Slack alert is sent so you can respond.

Configuring the workflow: what you need to set up

API keys and environment setup

To keep everything secure and maintainable, store all credentials in the n8n credentials manager instead of hard-coding them.

You will need credentials for:

• OpenAI API (for the chat model)
• Cohere API (for embeddings)
• Pinecone (for vector storage and search)
• Google Sheets OAuth2 (for logging)
• Slack (for alerts)

For Google Sheets, use a scoped service account with only the access it needs, not your personal account with broad permissions.

Pinecone index configuration

Before you run the workflow, make sure Pinecone is set up correctly.

• Create an index named something like rss_headlines_slack.
• Choose the dimensionality that matches the Cohere embed-english-v3.0 model. Check Cohere’s model documentation for the exact dimension size.
• Use metadata fields such as:
  • headline
  • url
  • source
  • published_at

These metadata fields make it easier to filter and interpret query results later.

De-duplication with semantic similarity

No one wants to see the same story three times just because different feeds phrased it slightly differently.

To avoid that, use semantic similarity thresholds when querying Pinecone before inserting new vectors.

For example:

• Query Pinecone for similar items using the new embedding.
• If the top match has a similarity score above something like cosine > 0.95, treat it as a near-duplicate.
• In that case, you can either skip insertion or tag the item as a duplicate in your logs.

Prompt engineering for the RAG agent

The power of this workflow really comes from how you instruct the RAG agent. A good prompt means cleaner, more structured output.

Some tips:

• Use a concise system message that clearly defines the agent’s role, for example “You are an assistant that classifies and summarizes news headlines for a Slack-based monitoring system.”
• Ask for structured output such as:
  • status (e.g., “relevant”, “ignore”)
  • summary
  • tags or topics
  • priority

Structured responses are easier to append to Google Sheets and to use for downstream automations.

Ideas for enhancing and customizing the template

Once you have the basic workflow running, you can tweak it to better match your use case.

• Keyword filtering
  Insert a node to either discard or prioritize items that match certain high-value keywords, like specific product names or competitors.
• Content enrichment
  Instead of just embedding the RSS summary, add a step to fetch the full article text first. That gives you richer embeddings and better RAG results.
• Multi-channel delivery
  Send high-priority items not only to Slack but also to email, a ticketing system, or other tools your team uses.
• Analytics pipeline
  Periodically export your Google Sheet to BigQuery or another warehouse to analyze trends over time.

Testing and monitoring your setup

Before you point production feeds at this workflow, it is worth doing a safe test run.

• Start with a dev environment or a test n8n instance.
• Use a sample RSS feed so you can predict the kind of content you will see.
• Leverage the n8n execution history to inspect outputs at each node.
• Verify that Slack alerts fire correctly when you intentionally break something.
• Monitor Pinecone usage so you do not run into unexpected costs.

Security and cost considerations

A few practical things to keep in mind when you move this into real-world use:

• Limit API key scope
  Give each API key or service account the minimum permissions it needs.
• Rate limit incoming webhooks
  Prevent abuse or accidental overload by setting sensible rate limits on the Webhook Trigger.
• Sanitize incoming content
  RSS feeds can contain messy or unexpected data. Clean and validate inputs before passing them along.
• Control embedding and vector costs
  Embedding APIs and vector databases typically bill per request or per stored vector. To manage cost:
  • Batch requests when possible
  • Keep chunk sizes reasonable
  • Use de-duplication to avoid storing repeated content

Quickstart: get up and running fast

Ready to try it out? Here is a short checklist to get this n8n template working.

1. Import the template into your n8n instance.
2. Configure credentials for:
   • Cohere
   • Pinecone
   • OpenAI
   • Google Sheets
   • Slack
3. Create a Pinecone index with the correct dimensionality for Cohere’s embed-english-v3.0 model.
4. Point your RSS service or RSS-to-webhook tool to the workflow’s Webhook URL.
5. Test with a sample item, then check:
   • n8n execution logs
   • Your Google Sheet log
   • Slack alerts and any test messages

Common troubleshooting tips

If something is not working the way you expect, here are a few quick checks.

• No data in Pinecone
  Make sure the Embeddings node