LiquidMetal AI: how do I connect Slack/Zapier/Intercom integrations to trigger workflows in my backend?

Quick Answer: You connect Slack, Zapier, and Intercom to your LiquidMetal AI backend by exposing Raindrop Services as HTTPS endpoints and wiring them into each tool’s webhook / HTTP action. Each integration sends structured JSON into your Raindrop API, where Actors and Smart Primitives (SmartMemory, SmartBuckets, SmartSQL, SmartInference) run the workflow and return a response.

Why This Matters

If your AI backend can’t be triggered from where your users already live—Slack channels, Intercom chats, or Zapier automations—it stays a demo. Connecting these integrations into Raindrop means every message, ticket, or event can drive a stateful, observable, and fully versioned workflow: route to the right agent, update SmartMemory, call SmartSQL, and ship a response back to the user in seconds.

Key Benefits:

• One backend for all channels: Slack, Intercom, and Zapier all call the same Raindrop Services and Actors, so you don’t duplicate logic per integration.
• Stateful, agent-friendly workflows: Use Actors + SmartMemory so your workflows don’t “forget everything between requests” like traditional serverless.
• Production-grade governance: Every call is versioned, logged, and traceable with built-in auth, making Slack/Zapier/Intercom triggers safe for real customer data.

Core Concepts & Key Points

Concept	Definition	Why it's important
Raindrop Service	A versioned HTTP API endpoint you define in a manifest, backed by Smart Primitives and/or Actors.	This is what Slack, Zapier, and Intercom call to trigger your workflow. One Service, many integrations.
Actor + SmartMemory	A stateful compute unit with persistent memory (working/episodic + semantic/procedural), identity routing, and scheduling.	Lets you keep context per user, channel, or conversation so workflows feel consistent across tools.
Smart Primitives (SmartBuckets, SmartSQL, SmartInference)	Built-in AI-native capabilities: AI-ready storage, natural language SQL, and unified model inference.	You don’t stitch together vector DBs or separate RAG stacks; integrations can immediately use retrieval, analytics, and models.

How It Works (Step-by-Step)

At a high level, you:

• Define a Raindrop Service that represents “the workflow trigger.”
• Implement the workflow using Actors and Smart Primitives.
• Wire Slack / Zapier / Intercom to call that Service over HTTPS.
• Use Raindrop’s auth, versioning, and observability to operate it in production.

1. Define a Raindrop Service as your integration entrypoint

In Developer Mode, you describe your backend as a manifest. For a cross-channel “trigger workflow” endpoint:

services:
  - name: integration-trigger
    route: POST /integrations/trigger
    auth:
      type: api_key  # or JWT/OAuth depending on your scenario
    handler: src/handlers/integrationTrigger.ts

This Service is fully versioned with the rest of your Raindrop app: code, data, and smart primitives can be rolled back or forward together.

The handler receives a JSON payload from Slack, Zapier, or Intercom, normalizes it, and dispatches to the right Actor:

// src/handlers/integrationTrigger.ts
import { getActor } from "@liquidmetal-ai/raindrop";

export default async function integrationTrigger(req, res) {
  const source = req.headers["x-lm-source"] ?? "unknown";

  const actorId = deriveActorId({ source, body: req.body }); // e.g., Slack channel ID, Intercom conversation ID
  const actor = await getActor("workflow-agent", actorId);

  const result = await actor.handleEvent({
    source,
    payload: req.body,
  });

  return res.json(result);
}

2. Implement the workflow in an Actor with SmartMemory

Create an Actor that owns state per conversation or account:

// actors/workflowAgent.ts
import { SmartMemory, SmartBuckets, SmartInference } from "@liquidmetal-ai/raindrop";

export default class WorkflowAgent {
  memory: SmartMemory;
  files: SmartBuckets;
  inference: SmartInference;

  async handleEvent(event) {
    // 1. Load context for this actor (user/channel/conversation)
    const context = await this.memory.loadContext();

    // 2. Enrich with any semantic knowledge (docs, history, etc.)
    const docs = await this.files.semanticSearch({
      query: event.payload.text ?? "",
      topK: 5,
    });

    // 3. Decide what to do using your chosen model
    const decision = await this.inference.chat({
      model: "gpt-4o-mini", // or another of the 60+ supported models
      messages: [
        { role: "system", content: "You route and execute backend workflows." },
        { role: "user", content: event.payload.text ?? "" },
      ],
      context: { docs, event, context },
    });

    // 4. Update memory so future events keep context
    await this.memory.save({
      last_message: event.payload,
      last_decision: decision,
    });

    // 5. Return what the integration needs (e.g., Slack reply text)
    return {
      reply: decision.output,
    };
  }
}

Because Actors are stateful compute units, your Slack/Zapier/Intercom-triggered workflows no longer need extra databases to remember per-session state. The memory and behavior are versioned with the application.

3. Wire each integration to the same Service

Slack → Raindrop

1. Create a Slack App in Slack’s API console.

2. Under Event Subscriptions, enable events and set the Request URL to:

   https://<your-raindrop-domain>/integrations/trigger
   

3. Subscribe to the events you care about (e.g., message.channels, app_mention).

4. In your Raindrop handler, detect Slack events:

   const source = req.headers["x-slack-signature"] ? "slack" : "unknown";
   

5. Verify the Slack signing secret in your handler if exposing publicly. Raindrop’s built-in auth (API keys, JWT, OAuth) plus Slack signature verification gives you defense in depth.

Slack messages now trigger your Actor workflow, and the Actor’s reply can be sent back via Slack’s Web API if you need asynchronous responses.

Zapier → Raindrop

Zapier gives you flexible, no-code entrypoints into the same backend:

1. In Zapier, create a new Zap.

2. Choose any trigger (e.g., new row in Google Sheets, Stripe event, Typeform submission).

3. For the Action, select Webhooks by Zapier → Custom Request (or POST).

4. Configure:

   • Method: POST

   • URL: https://<your-raindrop-domain>/integrations/trigger

   • Headers: include your API key or JWT, e.g. Authorization: Bearer <token>

   • Body: JSON with the data you want to send:

     {
       "source": "zapier",
       "event_type": "new_submission",
       "payload": {
         "email": "{{email}}",
         "answers": "{{answers}}"
       }
     }
     

5. In integrationTrigger.ts, treat source: "zapier" as another event type and route into the same Actor.

Zapier now becomes a front door into your Raindrop workflows without you writing more integration-specific infrastructure.

Intercom → Raindrop

Intercom webhooks let you react to conversations, tags, and user updates:

1. In Intercom, go to Developer Hub → your app → Webhooks.

2. Add a webhook with the URL:

   https://<your-raindrop-domain>/integrations/trigger
   

3. Choose events like conversation.user.created, conversation.admin.replied, or contact.tag.created.

4. Add a secret for signature validation (recommended).

5. In your Raindrop handler:

   const source =
     req.headers["x-intercom-signature"] ? "intercom" : "unknown";
   
   const actorId = deriveActorId({
     source,
     body: req.body, // e.g., conversation_id or contact_id
   });
   
   // same workflowAgent as Slack/Zapier
   

Now support conversations in Intercom can trigger the same backend intelligence your Slack bot and Zapier automations use, with one shared stateful backbone.

Common Mistakes to Avoid

• Building separate workflows per integration:
  How to avoid it: Treat Slack, Zapier, and Intercom as different “event sources” feeding the same Raindrop Service + Actor. Normalize input at the edge; keep business logic in one place.

• Letting integrations bypass auth and governance:
  How to avoid it: Always terminate at a Raindrop Service with auth configured (API keys, JWT, OAuth). Use Raindrop’s complete versioning and observability so every call—from any integration—is logged, traceable, and safe to roll back.

Real-World Example

A team wants a “unified AI support agent” that can:

• Answer questions in a Slack support channel.
• Auto-summarize new Intercom conversations and tag them by topic.
• Log every high-priority conversation to a Google Sheet via Zapier.

Instead of three separate stacks, they:

• Define one Raindrop Service: POST /integrations/trigger.
• Implement one workflow-agent Actor with SmartMemory and SmartBuckets to hold conversation history and documentation.
• Wire Slack events, Intercom webhooks, and a Zapier webhook step to the same endpoint.

Slack messages, Intercom events, and Zapier triggers all become events on the same Actor, which:

• Uses SmartInference to analyze the message.
• Uses SmartBuckets semantic search to pull relevant docs.
• Decides how to respond and which downstream actions to take.
• Persists state in SmartMemory so the next message has full context.

They get a single, auditable log of every AI decision across channels, can roll back changes to the workflow in one place, and don’t maintain three different “bots.”

Pro Tip: Start with one Raindrop Service and one Actor that simply logs and echoes events from Slack, Zapier, and Intercom. Once the plumbing is correct and observable, layer in SmartMemory and SmartBuckets for intelligence—this keeps integration debugging separate from workflow complexity.

Summary

To connect Slack, Zapier, and Intercom integrations to trigger workflows in your LiquidMetal AI backend, treat Raindrop as the central, versioned control plane. Expose a Raindrop Service as the common webhook endpoint, route each integration’s events into Actors, and use Smart Primitives to handle memory, retrieval, and inference. You get one stateful, observable workflow backend that scales across channels without stitching together separate bots, databases, or RAG pipelines.

Next Step

Get Started