Integration von Slack und SMS über Low-Code AI Studio

Einführung

Kleinen und mittleren Unternehmen fehlen oft die Ressourcen für vollwertige (und teure) Kundensupport-Lösungen. Mit der Low-Code-Plattform AI Studio von Vonage können Sie jedoch eine maßgeschneiderte, kosteneffiziente Customer-Experience-Lösung entwickeln, die auf Ihre Bedürfnisse zugeschnitten ist.

Dieses Tutorial zeigt Ihnen, wie Sie SMS und Slack integrieren können, um ein leistungsfähiges Kundensupportsystem zu schaffen. Durch die Verbindung von SMS mit Slack und Slack mit SMS können Sie Ihr Team in die Lage versetzen, Kundenanfragen direkt von Slack aus zu beantworten.

Mit Ihren bestehenden Mitarbeitern können Sie sich mit Kunden über SMS, Voice (Telefon) oder WhatsApp verbinden und direkt von Slack aus antworten. Und das Beste daran? Sie zahlen nur für das, was Sie nutzen! Diese leistungsstarke Lösung ist besonders für Startups von Vorteil, die Slack bereits für die Teamkommunikation nutzen.

Erfahren Sie, wie Sie SMS und Slack für einen Live-Kundensupport Failover verbinden können. Wenn Ihre Kunden vom virtuellen Agenten keine zufriedenstellende Antwort erhalten, wird das Gespräch nahtlos auf Slack übertragen, wo jedes Teammitglied helfen kann!

TL;DR: Finden Sie den refaktorisierten Server-Code auf Github um der Einrichtung von AI Studio und Slack zu folgen, ohne sich um die JavaScript-Programmierung kümmern zu müssen.

Integration von SMS mit Slack für den Kundensupport Übersicht

Ursprünglich wollte ich einen ähnlichen Ablauf wie bei dem berühmten Giphy-Schrägstrich-Befehl für diese SMS-zu-Slack-Integration. Allerdings sind benutzerdefinierte Slash-Befehle in Threads von Slack nicht erlaubt (Giphy ist ein Sonderfall). Die Verwendung eines Slash-Befehls in einer regulären Channel-Antwort verknüpft die Antwort nicht mit einer bestimmten Unterhaltung. Bei gleichzeitigen Unterhaltungen würde dieser Ansatz ein Chaos verursachen! Um Unterhaltungen in Threads zu halten, haben wir den folgenden Workaround implementiert:

1. Im Kundensupport-Kanal erscheint eine neue Nachricht mit dem conversation_id einer neuen SMS-Konversation.

2. Ein Teammitglied klickt auf eine Slack-Verknüpfung in der Nachricht, wodurch unsere Anwendung angewiesen wird, diese Unterhaltung mit dem aktuellen Slack-Thread zu verknüpfen.

3. Das Teammitglied verwendet den Befehl /reply Slash-Befehl, gefolgt von der session_id und seiner Antwort.

4. Unsere Anwendung verarbeitet die Antwort, sendet sie an AI Studio und fügt sie als Antwort in den Thread ein.

5. Unsere Anwendung verarbeitet auch Kundenantworten und fügt sie dem richtigen Thread zu.

6. Die Unterhaltung wird fortgesetzt, bis der Agent den Befehl /close_ticket Slash-Befehl verwendet, der die Sitzung in AI Studio beendet und eine "conversation resolved"-Antwort in den Slack-Thread einfügt.

Mit diesem Ansatz können Sie SMS und Slack für den Kundensupport nahtlos integrieren, so dass Ihr Team Konversationen direkt von Slack aus verwalten kann, während das richtige Threading und der Kontext erhalten bleiben.

Voraussetzungen

• Virtuelle Nummer von Vonage

• Slack Account und Erlaubnis zur Installation von Apps in Ihrem Arbeitsbereich

• Knotenpunkt

Vonage API-Konto

Um dieses Tutorial durchzuführen, benötigen Sie ein Vonage API-Konto. Wenn Sie noch keines haben, können Sie sich noch heute anmelden und mit einem kostenlosen Guthaben beginnen. Sobald Sie ein Konto haben, finden Sie Ihren API-Schlüssel und Ihr API-Geheimnis oben auf dem Vonage-API-Dashboard.

Sind Sie bereit, mit dem Bau zu beginnen?

Erleben Sie nahtlose Konnektivität, Echtzeit-Messaging und kristallklare Sprach- und Videoanrufe - alles auf Knopfdruck.

Einrichtung

Einrichten einer Node-Anwendung mit Express

1. Erstellen Sie ein neues Verzeichnis für Ihr Projekt und navigieren Sie mit Ihrem Terminal dorthin.

mkdir sms-to-slack
cd sms-to-slack

2. Initialisieren Sie ein neues Node.js-Projekt und installieren Sie die Abhängigkeiten

npm init -y
npm install express axios body-parser dotenv

3. Erstellen Sie Ihre Projektdateien

touch server.js .env .gitignore 

4. Öffnen Sie das Projekt im Code-Editor Ihrer Wahl.

In der .gitignore müssen wir eine einzelne Zeile hinzufügen, damit Git nicht versehentlich unsere .env-Anmeldedaten weitergibt:

.env

In unserer .env-Datei müssen wir unsere sicheren Werte von Slack und AI Studio hinzufügen. Wir werden diese in den nächsten Schritten ausfüllen. Fügen Sie zunächst hinzu:

SLACK_WEBHOOK_URL=""
AI_STUDIO_KEY=""

In der Datei server.js fügen Sie den folgenden Textbaustein hinzu:

// Import required modules
require('dotenv').config();
const express = require('express');
const axios = require('axios');
const bodyParser = require('body-parser');

// Create an Express application
const app = express();
const PORT = process.env.PORT || 3000;

// Import our secure ENV variables
const SLACK_WEBHOOK_URL = process.env.SLACK_WEBHOOK_URL;
const AI_STUDIO_KEY = process.env.AI_STUDIO_KEY;

// Middleware to parse JSON requests
app.use(express.json());

// Middleware to parse requests from Slack
const urlencodedParser = bodyParser.urlencoded({ extended: false })

// Define the /start endpoint
app.post('/start', (req, res) => {
    // Handle POST request to /start
    res.send('Start endpoint reached');
});

// Define the /inbound endpoint
app.post('/inbound', (req, res) => {
    // Handle POST request to /inbound
    res.send('Inbound endpoint reached');
});

// Define the /slack/start endpoint 
app.post('/slack/start', urlencodedParser, function (req, res){
res.send("Begin initiated");
});

// Define the /slack/message endpoint
app.post('/slack/message', urlencodedParser, function (req, res) {
  res.send("Response sent to user")
});

app.post('/slack/end', urlencodedParser, function (req, res) {
res.send("Conversation ended")
});

// Start the server
app.listen(PORT, () => {
    console.log(`Server is running on port ${PORT}`);
});

// We'll add our function declarations below here

In unserem Kesselstein tun wir vor allem 4 Dinge:

1. Importieren Sie unsere Abhängigkeiten.

• Express betreibt unseren Server.

• Axios ermöglicht es uns, HTTP-Anfragen zu stellen. HTTP-Anfragen ermöglichen es uns, Informationen zwischen Slack und AI Studio zu übertragen.

• bodyParser hilft uns beim Parsen oder Bereinigen der Daten, die wir von Slack zurückbekommen.

2. Konfigurieren Sie den Server, die Middleware und die Umgebungsvariablen unserer App.

3. Erstellen Sie Endpunkte für jede der Funktionen unserer Anwendung.

4. Starten Sie unseren Server.

Wie wir unsere Anwendung über localtunnel zugänglich machen

Für unsere Anwendung müssen Daten mehrmals zwischen AI Studio und Slack ausgetauscht werden. Wir verwenden localtunnel um unseren localhost freizulegen und öffentlich zugängliche Tunnel zu erstellen. Führen Sie in Ihrem Terminal den folgenden Befehl aus:

npx localtunnel --port 3000

Dadurch wird eine Tunnel-URL erstellt, die etwa so aussehen sollte:

➜  sms-to-slack npx localtunnel --port 3000

your url is: https://some-parks-beg.loca.lt

Die Url, die mit https und endet mit loca.lt endet, ist Ihre Tunnel-Url. Im weiteren Verlauf des Artikels wird immer dann, wenn TUNNEL_URL erwähnt wird, sollte dieser Wert verwendet werden.

Öffnen Sie für später eine zweite Registerkarte in Ihrem Terminal.

Wie man eine Slack-App einrichtet

1. Melden Sie sich bei Ihrem Slack-Arbeitsbereich an und öffnen Sie Ihre Applications.

2. Klicken Sie auf "Eine neue App erstellen". Wählen Sie die Option "Von Grund auf neu".

3. Geben Sie Ihrer Anwendung einen Namen und wählen Sie den Arbeitsbereich, in dem Sie sie verwenden möchten.

4. Klicken Sie auf "App erstellen".

Ta-da! Sie haben jetzt Ihre erste Slack-App! Es gibt noch eine letzte Sache, die Sie tun müssen. Du musst Eingehende Webhooks aktivieren. Sobald Sie die eingehenden Webhooks aktiviert haben, scrollen Sie zum Ende der Seite und klicken Sie auf "Add New Webhook to Workspace". Sie werden aufgefordert, den gewünschten Kanal auszuwählen und auf "Zulassen" zu klicken. Dadurch werden Sie zur Seite Eingehende Webhooks" Ihrer Anwendung weitergeleitet. Wenn Sie nun nach unten scrollen, sehen Sie eine Webhook-URL für den gewünschten Kanal.

Kopieren Sie die URL und fügen Sie sie als Wert für Ihre SLACK_WEBHOOK_URL in Ihre .env-Datei ein. Sie sollte in etwa wie folgt aussehen:

SLACK_WEBHOOK_URL="https://hooks.slack.com/services/..."

Wie man einen Inbound-SMS-Chatbot erstellt

Um Ihren Agenten zu erstellen, folgen Sie den Anweisungen in der AI Studio Dokumentation hier. Es gibt drei wichtige Optionen für unseren Agenten, wählen Sie:

• Typ: SMS

• Vorlage: Von Grund auf neu beginnen

• Veranstaltung: Inbound

Der Ablauf unseres Agenten wird relativ einfach sein.

1. Wenn der Benutzer den Agenten benachrichtigt, verwenden wir einen Knoten Eingabe sammeln um den Benutzer zu fragen, wozu er Hilfe benötigt. Die Antwort wird in einem Parameter namens inquiry gespeichert.

2. Dann verwenden wir einen bedingten Knoten um zu prüfen, ob inquiry gleich "eskalieren" ist.

3. Ist dies der Fall, senden wir dem Benutzer eine Nachricht mit dem Wortlaut "Bitte warten Sie, während wir Sie mit einem Live-Agenten verbinden". Handelt es sich um eine andere Anfrage, werden alle anderen möglichen Abläufe nachgeahmt, indem einfach die Nachricht "Vielen Dank für die Nutzung unseres Dienstes! (Knoten "Dankeschön senden").

4. Der Please Hold-Knoten verbindet sich mit einem Live-Agent-Routing-Knoten.

5. Schließlich ist der Live-Agent-Routing-Knoten und Dankeschön-Knoten senden eine Verbindung zu einem Gesprächsende-Knoten.

Overview of AI Studio SMS Agent

So richten Sie einen Live-Agent-Routing-Knoten ein

Im Live Agent Routing Node müssen wir 3 Dinge tun:

1. Fügen Sie Ihr ‘TUNNEL_URL/start’ in das Feld Start Verbindung EP

2. Fügen Sie Ihr ‘TUNNEL_URL/inbound’ in das Feld Eingangsüberweisung EP

3. Wählen Sie Anfrage in den Übertragungsparametern

Und klicken Sie auf "Speichern und Beenden".

Example of Live Agent Routing Node in AI Studio

Als Nächstes fügen Sie Ihren AI Studio API Schlüssel zu Ihrer .env Datei hinzu. Sie finden den X-Vgai-Key oben rechts in Ihrem AI Studio Canvas. Klicken Sie auf das Symbol "Benutzer" und dann auf "API-Schlüssel generieren".

Kopieren Sie den X-Vgai-Key und fügen Sie ihn als Wert für Ihren AI_STUDIO_KEY in Ihre .env-Datei ein. Sie sollte in etwa so aussehen:

AI_STUDIO_KEY="YOUR_KEY_VALUE"

Schließlich müssen Sie dem Agenten noch Ihre Vonage-Nummer zuweisen. Befolgen Sie die Anweisungen zur Veröffentlichung aus der Dokumentation.

So initiieren Sie eine Slack-Konversation mit eingehenden Webhooks

Die erste Aktion, die wir erstellen müssen, ist die Verbindung von AI Studio mit Slack. Dazu verwenden wir den Start Connection Endpoint des Live Agent und die Incoming Webhooks von Slack. Wir haben diese bereits im Setup konfiguriert, aber jetzt müssen wir die Logik hinzufügen, um sie tatsächlich zu verbinden.

Der Start Connection Endpoint unseres Agenten ist so konfiguriert, dass er eine Anfrage an unseren /start Endpunkt zu senden. Dort werden wir 2 Informationen an Slack senden: die SessionId und die Transkription unserer bisherigen Konversation. Wir verpacken diese Informationen in ein Datenobjekt, das den Erwartungen von Slack entspricht und ein wenig formatiert ist. Wir werden die axios-Bibliothek verwenden, um alle unsere POST-Anfragen zu senden.

So sieht unser /start Endpunkt jetzt so aus:

app.post('/start', (req, res) => {
  const sessionId = req.body.sessionId;
  const transcription =  handleTranscription(req.body.history.transcription);
  const data = { text: `Session: `${sessionId}`\nTranscription:${transcription}`, }
  axios.post(SLACK_WEBHOOK_URL, data)
  res.send('Start endpoint reached');
});

Sie werden feststellen, dass wir die Funktion handleTranscription. Diese Funktion formatiert unsere Rohtranskription in etwas Nettes für Slack. Sie können dies am Ende unserer Datei hinzufügen.

const handleTranscription = (transcription = []) => {
  if (!transcription.length) return null;

  let strTrans = '```';

  for (const message of transcription) {
    for (const key in message) {
      strTrans += `\n${key}: ${message[key]}`;
    }
  }

  strTrans += '```';

  return strTrans;
};

So testen Sie Ihre SMS-zu-Slack-Verbindung

Sie können nun testen, ob Ihr Agent mit Ihrem Slack-Kanal verbunden ist! Führen Sie in der zweiten Terminal-Registerkarte, die Sie zuvor geöffnet haben, Ihre Anwendung aus:

node server.js

Ist deine Transkription in Slack erschienen? Wie cool!

Da wir noch keine Möglichkeit zum Beenden von Konversationen in AI Studio implementiert haben, müssen Sie die Konversation bei jedem Test manuell beenden. Sie können dies tun, indem Sie eine POST-Anfrage an die Verbindung beenden EP mit einem Tool wie Postman senden. Sie finden Ihre aktiven Sitzungen unter der Registerkarte Registerkarte Berichte.

Außerdem müssen Sie jedes Mal, wenn Sie eine neue Änderung in Ihrer Node-Anwendung testen möchten, den Server neu starten.

Wie man eine Slack-Nachrichtenverknüpfung erstellt

Jetzt, wo wir unsere Konversation in Slack gestartet haben, könnte man meinen, der nächste Schritt wäre, unsere Slack-Kollegen antworten zu lassen, richtig? Nun, wir müssen zuerst das Problem lösen, unseren Slack-Thread irgendwie mit unserer AI Studio-Konversation zu verknüpfen, damit wir wissen, wie wir unsere Nachrichten hin und her organisieren können!

Wir tun dies, indem wir eine Slack-Nachrichten-Verknüpfung. Diese Nachrichtenverknüpfung wird unseren Agenten auffordern, ein Ticket zu eröffnen, indem er einfach auf eine Schaltfläche in der neuen Unterhaltung klickt. Dies sendet eine Anfrage an unsere Anwendung, in der wir die Informationen zum Konversations-Thread in einem neuen Objekt in Bezug auf die conversation_id.

Interaktivität der Slack-App aktivieren

Um Verknüpfungen erstellen zu können, müssen Sie die Interaktivität in Ihrer Slack-App aktivieren. Wie Sie das tun, sehen Sie unten. Für die Anfrage-URL fügst du deine TUNNEL_URL gefolgt von /slack/start. Dies wird der Endpunkt in unserer Anwendung sein, an den Slack eine Anfrage sendet, wenn die Verknüpfung ausgelöst wird.

Enable interactivity in your Slack App

Klicken Sie dann auf "Neue Verknüpfung erstellen" und geben Sie sie ein:

Name: Ein Ticket starten

Kurze Beschreibung: Erzeugt eine Konversation für eine Kundenanfrage

Rückruf-ID: begin_response

Create Slack Shortcut

Verknüpfung von Sitzungen mit Slack-Threads

Jetzt werden wir unsere Anwendung aktualisieren, um die Informationen, die wir von Slack erhalten, zu nutzen und sie mit unseren AI Studio-Sitzungen zu verknüpfen. Zuerst erstellen wir ein globales Objekt namens SESSIONS. Sie können dieses direkt über unseren Endpunkten hinzufügen:

const SESSIONS = {};

Innerhalb unserer Endpunkte werden wir 4 Dinge tun:

1. Verarbeiten Sie die Antwort, die wir von Slack erhalten, und extrahieren Sie thread_ts (Zeitstempel) und session_id

2. Erstellen Sie einen neuen Eintrag in SESSIONS für die aktuelle Sitzung/Thread

3. Bereiten Sie die Daten vor, die an Slack gesendet werden sollen. Dazu gehört auch die Formatierung unserer Initialisierungsnachricht für unseren Slack-Thread.

4. Senden unserer Anfrage an Slack, um die Initialisierungsnachricht im richtigen Thread zu posten

app.post('/slack/start', urlencodedParser, function (req, res){
  const response = JSON.parse(req.body.payload);
  const thread_ts = response.message.ts;
  const session_id = extractSessionId(response.message.text);
  newSession(session_id, thread_ts);

  const data = {
    "thread_ts": thread_ts,
    "text": `Session seen by <@${response.user.id}>`
  }

  axios.post(SLACK_WEBHOOK_URL, data);
  res.send("Begin initiated");

})

In unserem Endpunkt stützen wir uns auf zwei neue Funktionen. Sie können diese am Ende Ihrer Datei zusammen mit den anderen Funktionen hinzufügen. Die erste heißt extractSessionId die unsere Nutzlast von Slack nach dem aktuellen sessionId:

const extractSessionId = (input) => {
  const sessionIdPattern = /Session: `([0-9a-f-]{36})`/i;
  const match = input.match(sessionIdPattern);
  if (match && match[1]) {
    return match[1];
  }
  return null;
};

Die zweite Funktion newSessionerzeugt einen neuen Eintrag in unserer globalen SESSIONS Variable.

const newSession = (session_id, message_ts) => {
  SESSIONS[session_id] = {
    "session_id" : session_id,
    "thread_ts" : message_ts
  }
}

Wie man einen Slack Slash-Befehl für Nachrichtenantworten erstellt

Nun, da unser Agent die Konversation in unserer Anwendung initialisiert hat, wollen wir ihn tatsächlich auf unsere Kunden antworten lassen. Zu diesem Zweck erstellen wir unseren ersten Slash-Befehl.

Öffnen Sie im Dashboard unserer Slack-Anwendung die Registerkarte "Slash Commands". Klicken Sie dann auf "Neuen Befehl erstellen".

Erstellen Sie den folgenden Befehl:

Befehl: Antwort URL anfordern: TUNNEL_URL/slack/message Kurzbeschreibung: Antwort auf eingehende Anfragen Hinweis zur Verwendung: [session_id]

Und klicken Sie auf "Speichern".

Create Slack Slash Command

Jetzt müssen wir unseren ‘/slack/message’ Endpunkt aktualisieren, um die von Slack gesendeten Daten zu verarbeiten. Wir müssen zwei Dinge tun:

1. Erfassen Sie die Nachricht und fügen Sie sie als Kommentar in den richtigen Thread in Slack ein, zusammen mit einigen Formatierungen

2. Erfassen Sie die Nachricht und senden Sie sie an die richtige Sitzung in AI Studio

Wir können dies mit dem folgenden Code tun:

app.post('/slack/message', urlencodedParser, function (req, res) {
  const response = req.body;
  const agentResponse = parseMessage(req.body.text);
  const session_id = agentResponse['sessionId'];
  const message = agentResponse['message'];
  const studio_data = { message_type: 'text', text: message };
  const thread_ts = SESSIONS[session_id].thread_ts;
  const slack_data = {
    "thread_ts": thread_ts,
    "text": `Response sent by <@${response.user_id}> \`\`\`${message}\`\`\``,
  }
  axios.post(`https://studio-api-eu.ai.vonage.com/live-agent/outbound/${session_id}`, studio_data, {
    headers: { 'X-Vgai-Key': AI_STUDIO_KEY }
  })
  axios.post(SLACK_WEBHOOK_URL, slack_data);
  res.send("Response sent to user")
})

Sie werden feststellen, dass wir uns auf eine letzte Funktion namens parseMessage um unsere Daten aus Slack zu bereinigen. Sie können sie am Ende unserer Datei hinzufügen:

const parseMessage = (input) => {
  const [sessionId, ...messageParts] = input.split(' ');
  const message = messageParts.join(' ');

  // Check if the first part is a valid session ID format
  const sessionIdPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;

  if (sessionIdPattern.test(sessionId)) {
    return { sessionId, message };
  }

  // If the first part is not a valid session ID, treat the entire input as a message
  return { message: input };
};

Sie können jetzt das Senden von Nachrichtenantworten von Slack aus testen! Wie cool ist es, sie auf der SMS-Seite zu empfangen?!

Wie man SMS-Antworten an Slack sendet

Wir haben jetzt also fast unser komplettes Szenario zum Laufen gebracht. Aber eine Sache fehlt uns noch! Wir müssen unseren Benutzern erlauben, fortlaufend Nachrichten an Slack zu senden, um unseren menschlichen Agenten zu antworten. Wir können dies tun, indem wir unseren /inbound Endpunkt.

Hier verarbeiten wir die Daten aus AI Studio und ziehen die Nachricht und session_id. Mit Hilfe der session_id können wir unsere thread_ts. Sobald wir die thread_tshaben, können wir unsere Nachricht an den richtigen Thread mit einer POST-Anfrage an Slack senden.

Sie können Ihren Code wie folgt aktualisieren:

app.post('/inbound', (req, res) => {
  // console.log("inbound endpoint", req.body)
  const message = req.body.text
  const session_id = req.body.sessionId;
  const thread_ts = SESSIONS[session_id].thread_ts;
  const data = {
    "thread_ts": thread_ts,
    "text": `Customer respsonse: \`\`\`${message}\`\`\``
  }
  axios.post(SLACK_WEBHOOK_URL, data );
  res.send('Inbound endpoint reached');
});

So erstellen Sie einen Slack Slash-Befehl zum Beenden einer Konversation

Sie denken vielleicht: "Das war's! Ich bin fertig!". Nun, fast! Unser Live Agent Node weiß nicht, wie lange ein Gespräch zwischen AI Studio und einer anderen Schnittstelle dauern kann. Deshalb müssen wir AI Studio wissen lassen, wann es die Konversation beenden und den Live Agent Routing Knoten verlassen soll.

Wir werden einen weiteren Slash-Befehl erstellen, ähnlich wie bei der Erstellung von /reply. Diesmal erstellen wir einen Befehl für /close_ticket. Close-Ticket wird wieder die session_id akzeptieren, um zu wissen, welche Sitzung zu beenden ist.

Erstellen Sie den folgenden Befehl:

Befehl: /close_ticket URL anfordern: TUNNEL_URL/slack/end Kurze Beschreibung: Kundenproblem wurde behoben Hinweis zur Verwendung: [session_id]

Und klicken Sie auf "Speichern".

Innerhalb unseres /slack/end Endpunkts müssen wir die Anfrage von Slack bearbeiten. Wir müssen nur drei Dinge tun:

1. Ergreifen Sie die session_id mit Hilfe unserer parseMessage Funktion wieder

2. Senden Sie eine Anfrage an den Endpunkt "Stop Connection" in AI Studio, um die Konversation für die richtige session_id

3. Aktualisieren Sie den menschlichen Agenten in Slack, dass die Unterhaltung beendet wurde, indem Sie eine Nachricht im richtigen Thread posten

Aktualisieren Sie dazu Ihren /slack/end Code so, dass er wie folgt aussieht:

app.post('/slack/end', urlencodedParser, function (req, res) {
  const agentResponse = parseMessage(req.body.text);
  const session_id = agentResponse['sessionId'];
  const data = {};
  axios.post(`https://studio-api-eu.ai.vonage.com/live-agent/disconnect/${session_id}`, data, {
    headers: { 'X-Vgai-Key': AI_STUDIO_KEY }
  })
  const thread_ts = SESSIONS[session_id].thread_ts;
  const slack_data = {
    "thread_ts": thread_ts,
    "text": `This conversation has been marked as resolved.`,
  }
  axios.post(SLACK_WEBHOOK_URL, slack_data);
  res.send("Conversation ended")
})

Schlussfolgerung

Und das war's schon! Sie haben erfolgreich eine nahtlose SMS-zu-Slack- und Slack-zu-SMS-Integration für den Kundensupport mithilfe der AI Studio Low-Code-Plattform von Vonage implementiert. Starten Sie Ihren Node.js-Server neu, indem Sie node server.js in Ihrem Terminal ausführen, und testen Sie den kompletten Ablauf, indem Sie Nachrichten zwischen der SMS Ihres Telefons und Slack hin und her senden. Ist das nicht erstaunlich?

Um diese Anwendung weiter zu verbessern, sollten Sie die robuste Web-API von Slack nutzen, die Interaktivität auf Basis von Emoji-Reaktionen ermöglicht. Außerdem könnten Sie die WhatsApp-Agenten von AI Studio einbinden, um Kunden einen zusätzlichen Kommunikationskanal zu bieten.

Verwenden Sie andere Low-Code- oder No-Code-Lösungen zur Kundenbindung? Werden Sie Mitglied der Vonage Entwickler-Community Slack oder folgen Sie uns auf X, früher bekannt als Twitter um Ihre spannenden Projekte und Erkenntnisse zu teilen!

Die Integration von SMS und Slack für den Kundensupport ist nur ein Beispiel dafür, wie Low-Code-Plattformen wie AI Studio Geschäftsprozesse rationalisieren und die Kundenerfahrung verbessern können. Erkunden Sie weitere Möglichkeiten und bleiben Sie auf dem Laufenden über die neuesten Entwicklungen im Low-Code- und No-Code-Bereich.

Zusätzliche Ressourcen

• Steigerung des Chatbot-ROI: Ablenkung von Anfragen durch menschliche Agenten

• Aufbau eines ausfallsicheren Voice-Agenten: Ein Leitfaden für Failover-Systeme

• Aufbau einer Hierarchie zur Klassifizierung von Absichten

• Die neue Grenze für freiberufliche Möglichkeiten: Konversationsfähige KI-Agenten