> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt. # Slack ## Översikt Slack-integrationen låter en ElevenLabs-agent skicka och ta emot meddelanden i Slack. När den är ansluten svarar agenten i en tråd när den nämns i en kanal och håller separat samtalskontext för varje tråd. ## Funktioner | Funktion | Stöd | | --------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Nollagringsläge (ZRM) | Stöds inte | | Bilagor i utlösare | Bilder (PNG, JPEG, GIF, WebP) och PDF-filer i inkommande meddelanden, när **Tillåt filbilagor** är aktiverat i agentinställningarna och agentens LLM har stöd för bild- eller dokumentinmatning | | Bilagor i verktyg | Stöds inte — verktyg fungerar endast med text | ## Konfiguration Integrationen erbjuder två sätt att ansluta: * **OAuth** — installera den delade ElevenLabs Slack-appen i din arbetsyta. En Slack-arbetsyta motsvarar en ElevenLabs-anslutning. Snabbaste konfigurationen, ingen hantering av Slack-appar krävs. * **Använd din egen app** — anslut med en Slack-app som du skapar och äger. Använd detta när boten ska visas under ditt varumärke eller när arbetsytans policyer kräver att appar installeras av en administratör. ### Alternativ A — OAuth Användaren som installerar appen måste ha behörighet att lägga till appar i Slack-arbetsytan. #### Öppna integrationssidan I ElevenLabs-panelen går du till **Agents** > **Integrations** och väljer **Slack**. #### Klicka på Connect Välj OAuth-autentiseringsuppgiften och klicka på **Connect**. Du omdirigeras till Slack för att välja vilken arbetsyta ElevenLabs-appen ska installeras i och godkänna de begärda behörigheterna. #### Slutför omdirigeringen Efter godkännandet omdirigerar Slack dig tillbaka till ElevenLabs och anslutningen skapas. Slack-arbetsytans ID registreras automatiskt och används när utlösare konfigureras. ### Alternativ B — Använd din egen Slack-app Använd detta om du vill att boten ska visas med ditt eget appnamn och din egen ikon, eller om din arbetsyta kräver att appar granskas och installeras av en administratör. #### Skapa en Slack-app Gå till [Slack API: Your Apps](https://api.slack.com/apps) och klicka på **Create New App** > **From scratch**. Namnge appen och välj Slack-arbetsytan där den ska installeras. #### Lägg till bot-behörigheter Öppna **OAuth & Permissions** och lägg till följande Bot Token Scopes: `app_mentions:read`, `channels:history`, `channels:join`, `channels:manage`, `chat:write`, `files:read`, `groups:history`, `groups:write`, `im:history`, `reactions:write`. Klicka sedan på **Install to Workspace** och godkänn. Kopiera **Bot User OAuth Token** (börjar med `xoxb-`). #### Kopiera signeringshemligheten Öppna **Basic Information** > **App Credentials** och kopiera **Signing Secret**. #### Skapa anslutningen i ElevenLabs I ElevenLabs-panelen går du till **Integrations**, klickar på knappen **Add integration** och väljer **Slack**. Välj autentiseringsuppgiften **Bring your own app**. Klistra in bot-token och signeringshemligheten och spara. ElevenLabs verifierar token mot Slack och registrerar ditt arbetsyte-ID. När anslutningen har skapats visar anslutningssidan två webhook-URL:er baserade på din Slack-apps identitet. Samma Slack-app, återansluten från samma ElevenLabs-arbetsyta, ger alltid samma URL:er — så du kan ta bort och återskapa anslutningen utan att behöva uppdatera Slack-appens konfiguration igen. Håll sidan öppen inför nästa steg. #### Konfigurera Event Subscriptions I din Slack-app öppnar du **Event Subscriptions**, aktiverar händelser och klistrar in **Events URL** från ElevenLabs anslutningssida i **Request URL**. Slack verifierar URL:en med signeringshemligheten som du angav. Prenumerera på bothändelser baserat på hur agenten ska bete sig i kanaler: * **Endast omnämnanden** — prenumerera på `app_mention`. Agenten svarar bara när en användare `@`-nämner boten. * **Alla meddelanden** — prenumerera på `message.channels` och `message.groups`. Agenten svarar på varje meddelande i kanaler där boten finns, utan att kräva ett omnämnande. Om du använder utlösaren **SlackDirectMessage** ska du också prenumerera på `message.im`. Prenumerera inte på både `app_mention` och kanalhändelserna `message.*` om du inte avser att hantera dubbla leveranser. När en användare `@`-nämner boten kan Slack skicka både en `app_mention`-händelse och en `message`-händelse för samma meddelande, vilket gör att agenten svarar två gånger. #### Konfigurera Interactivity Öppna **Interactivity & Shortcuts**, aktivera interaktivitet och klistra in **Interactivity URL** från ElevenLabs anslutningssida i **Request URL**. #### Installera om vid uppmaning Om Slack uppmanar dig att installera om appen efter att du har ändrat behörigheter eller händelser gör du det för att tillämpa ändringarna. > **Note** > > En Slack-arbetsyta kan bara anslutas en gång via den delade ElevenLabs OAuth-appen. En ominstallation > från en annan ElevenLabs-arbetsyta ger felet `duplicate Slack workspace` — ta först bort den > befintliga anslutningen. Anslutningar med egen app är oberoende och orsakar inga konflikter. ## OAuth-behörigheter ElevenLabs Slack-app begär följande behörigheter: | Behörighet | Syfte | | ------------------- | ---------------------------------------------------------------------------------------------- | | `app_mentions:read` | Ta emot meddelanden där boten `@`-nämns. | | `channels:history` | Läsa meddelanden i offentliga kanaler där boten finns. | | `channels:join` | Låta boten automatiskt gå med i offentliga kanaler när en utlösare skapas. | | `channels:manage` | Utföra åtgärder för kanalhantering. | | `chat:write` | Publicera meddelanden i kanaler och trådar. | | `files:read` | Ladda ned filer bifogade meddelanden så att agenten kan läsa bilder och PDF:er. | | `groups:history` | Läsa meddelanden i privata kanaler där boten finns. | | `groups:write` | Användas i privata kanaler. | | `im:history` | Läsa meddelanden i direktmeddelandekanaler med boten. | | `reactions:write` | Lägga till och ta bort reaktioner, används för tänkeindikatorn i meddelanden och agentverktyg. | ## Agentverktyg När du lägger till Slack-verktyg i en agent finns följande inbyggda verktyg tillgängliga: | Verktyg | Beskrivning | | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `slack_add_reaction` | Lägger till en emoji-reaktion. Som standard fylls kanal och meddelande-`ts` i från `integration__slack_channel_id` och `integration__slack_trigger_message_ts`; modellen väljer bara emojins kortkod (utan kolon), till exempel `thumbsup`. Utanför Slack-utlösta konversationer saknas dessa variabler om du inte anger dem — justera verktygsschemat om modellen måste skicka kanal och `ts` uttryckligen. | | `slack_remove_reaction` | Tar bort en emoji-reaktion (samma standardvärden som för att lägga till). Enligt Slack får den anropande boten bara ta bort reaktioner som den själv har lagt till; se [reactions.remove](https://docs.slack.dev/reference/methods/reactions.remove). | ## Ta bort anslutningen Om du tar bort anslutningen från sidan **Integrations** avinstalleras ElevenLabs Slack-app från Slack-arbetsytan. Efter borttagningen finns boten inte längre i någon kanal. För anslutningar med egen app kan ElevenLabs inte avinstallera en app som vi inte äger — att ta bort anslutningen raderar bara den lokala mappningen. Om du vill ta bort boten helt från din Slack-arbetsyta avinstallerar du appen från Slack-administratörsinställningarna. ## Konfigurera utlösaren Integrationen har en enda utlösare, **SlackMessage**. Den aktiveras när boten ser ett nytt användarmeddelande i en konfigurerad kanal. #### Lägg till en SlackMessage-utlösare På agentens konfigurationssida lägger du till en ny utlösare och väljer **SlackMessage**. #### Välj agent och kanal Konfigurera utlösarfälten: * **Agent**: agenten som hanterar konversationen. * **Channel ID**: Slack-kanalens ID, till exempel `C0123456789`. Gränssnittet erbjuder en djuplänk för att öppna kanalen i Slack. #### Spara utlösaren Spara utlösaren. ElevenLabs bjuder automatiskt in boten till offentliga kanaler. Om du senare tar bort utlösaren lämnar boten den kanalen. > **Info** > > Slack tillåter inte appar att automatiskt gå med i privata kanaler. För en privat kanal kör du `/invite > @Eleven` i kanalen efter att du har sparat utlösaren så att boten kan se meddelanden. > **Warning** > > Endast en utlösare tillåts per par av `(Slack workspace, channel)`. Redigera den befintliga utlösaren > i stället för att skapa en dubblett. ## Konfigurera DM-utlösaren Utlösaren **SlackDirectMessage** låter alla Slack-användare chatta med agenten genom att skicka ett direktmeddelande till boten. Till skillnad från kanalutlösaren behövs inget `@`-omnämnande — varje meddelande som en användare skickar i ett DM med boten behandlas. #### Lägg till en SlackDirectMessage-utlösare På agentens konfigurationssida lägger du till en ny utlösare och väljer **SlackDirectMessage**. #### Välj agent Välj den **Agent** som hanterar DM-konversationer. #### Spara utlösaren Spara utlösaren. Alla Slack-användare i arbetsytan kan nu öppna ett DM med boten och starta en konversation. > **Info** > > För BYO-appar ska du se till att du prenumererar på bothändelsen `message.im` och har lagt till > bot-behörigheten `im:history`. Installera om appen vid uppmaning efter att du har lagt till dessa. > **Warning** > > Endast en DM-utlösare tillåts per Slack-anslutning. Redigera den befintliga utlösaren för att byta agent. ## Prata med boten i Slack När utlösaren är aktiv och boten finns i kanalen startar du en konversation i en kanaltråd. Hur du fortsätter tråden beror på Slack-appens händelseprenumerationer (OAuth använder beteendet med endast omnämnanden). ### Endast omnämnanden (`app_mention`) #### Starta en tråd med ett omnämnande Nämn boten i en kanal för att starta en ny tråd, till exempel `@Eleven what's the status of order 1234?`. Boten svarar i en tråd under det meddelandet. #### Fortsätt tråden Nämn boten igen i varje meddelande som du vill att den ska svara på, även i uppföljningar i samma tråd. Meddelanden utan omnämnande ignoreras. ### Alla meddelanden (`message.channels`, `message.groups`) #### Starta en tråd Skicka valfritt meddelande i en kanal där boten finns. Boten svarar i en tråd under det meddelandet. Du behöver inte `@`-nämna boten. #### Fortsätt tråden Svara i samma tråd utan att nämna boten. Varje nytt meddelande i tråden behandlas. Medan boten genererar ett svar lägger den till en `:eyes:`-reaktion på användarens utlösande meddelande och tar bort den när svaret har publicerats. Inställningen **Respond to messages from** på utlösaren för kanalmeddelanden styr vem som kan utlösa agenten: * **Only humans** (standard): meddelanden från andra botar och från Slack-workflows ignoreras. Detta är det säkra standardvalet och bevarar beteendet för befintliga utlösare. * **Humans and bots**: meddelanden från andra botar och meddelanden som publicerats av workflows (inklusive äldre `bot_message`-händelser) utlöser också agenten. Boten ignorerar alltid sina egna meddelanden — med hjälp av botanvändar- och appidentiteten i Slacks signerade webhook — oavsett inställning, så den svarar aldrig sig själv även om den nämns av sig själv. Den fortsätter också att ignorera redigerade meddelanden (`message_changed`) och raderade meddelanden (`message_deleted`). Den hanterar händelserna `message` och `app_mention` och fungerar i både offentliga och privata kanaler. > **Note** > > Äldre bothändelser som endast innehåller ett `bot_id` identifierar avsändaren men inte den mottagande appen. De > behandlas som meddelanden från en annan bot; identifiering av självslingor för denna Slack-app använder botanvändar- > eller appidentiteten som ingår i moderna Slack-händelsenyttolaster. > **Warning** > > Om din Slack-app prenumererar på både `app_mention` och `message.channels` / `message.groups` kan ett > enda `@`-omnämnande utlösa två agentsvar. Prenumerera på det ena läget eller det andra. ## Konversationsmodell Konversations-ID:t är deterministiskt per `(agent_id, channel_id, thread_ts)`: * En ny Slack-tråd mappas till en ny ElevenLabs-konversation. * Att fortsätta i samma tråd fortsätter samma konversation, inklusive transkriptshistorik och dynamiska variabler. När chatthistoriken skapas läser boten Slack-tråden direkt. Meddelanden från Slack-medlemmar och andra botar behandlas som användarturer, medan botens egna meddelanden behandlas som agentturer. Omnämnanden av botanvändaren (`<@BOT_USER_ID>`) skrivs om till `@` innan agenten behandlar dem. ### Dynamiska variabler När en agent körs från Slack är följande dynamiska variabler tillgängliga i prompter och verktyg: | Variabel | Beskrivning | | --------------------------------------- | ---------------------------------------------------------------------------------------------------- | | `integration__slack_channel_id` | Slack-kanal-ID. | | `integration__slack_thread_ts` | Tidsstämpel för Slack-tråd. | | `integration__slack_user_id` | Slack-avsändar-ID. Detta är ett användar-ID, eller ett bot-ID för äldre bothändelser utan användare. | | `integration__slack_team_id` | Slack-arbetsytans (teamets) ID. | | `integration__slack_connection_id` | ID för ElevenLabs integrationsanslutning. | | `integration__slack_trigger_message_ts` | Slack-`ts` för meddelandet som utlöste denna agenttur (unikt meddelande-ID i kanalen). | Se [dynamiska variabler](/docs/sv/eleven-agents/customization/personalization/dynamic-variables) för hur du refererar till dem i prompter och verktygsanrop. ## Felsökning ### Filbilagor fungerar inte När en användare bifogar en bild eller PDF i Slack men agenten inte behandlar den (eller beter sig som om ingen fil skickades), går du igenom kontrollerna nedan. #### Bekräfta att Slack-appen har files:read Boten behöver bot-behörigheten `files:read` för att ladda ned bilagor från Slack. * **Använd din egen app** — öppna din app på [Slack API: Your Apps](https://api.slack.com/apps), gå till **OAuth & Permissions** och kontrollera att `files:read` finns under **Bot Token Scopes**. Om du nyligen lade till den installerar du om appen i arbetsytan så att token får den nya behörigheten. #### Bekräfta att agentmodellen har stöd för filinmatning Filbilagor vidarebefordras bara när agentens LLM har stöd för multimodal inmatning — bildinmatning och/eller dokumentinmatning (PDF), beroende på filtypen. I agentkonfigurationen öppnar du fliken **Agent** och kontrollerar den valda modellen. Om modellen inte har stöd för bilagetypen byter du till en modell som har det. #### Aktivera Allow file attachments i agentinställningarna På agentens konfigurationssida öppnar du **Settings** > **Advanced**. Aktivera **Allow file attachments** under **Multimodal input**. Spara agenten. Utan denna inställning ignoreras Slack-bilagor även när Slack-appen och modellen har stöd för filer. ## Användbara länkar * [Slack API-dokumentation](https://api.slack.com/docs) * [Slack-appbehörigheter](https://api.slack.com/scopes)