Bearbeta bilder och dokument i ElevenAgents

En arbetsledare upptäcker materialbrist på en byggarbetsplats. Han tar ett foto, skickar bilden till inköpsagenten på WhatsApp och bekräftar leveransadressen med röstmeddelande. Agenten behandlar fotot, identifierar vad som saknas och lägger en expressbeställning – allt i samma samtal. Företagsflöden innehåller ofta kontext som inte går att förmedla med bara ord. Informationen som behövs för att lösa ett ärende kan vara ett foto på en trasig vara eller en PDF med en policy. Att skicka det direkt till agenten gör samtalet kortare och snabbare att lösa. När en kund kan visa istället för att förklara, kan agenten felsöka snabbare utan att be kunden byta kanal.Rohlik, en av Europas största online-matbutiker, använder sin agent via telefon, webben, appen och WhatsApp på sex språk och löser 90 % av kundärendena automatiskt. Multimodal indata gör att samma lösningsgrad gäller även när kunden behöver visa istället för att berätta. ElevenAgents behandlar filer som förstklassiga indata i samma agent som redan hanterar röst, WhatsApp, webben och mobilen. Filer når modellen som ursprungliga meddelanden, så en och samma agent hanterar alla indatatyp i en och samma konversation.

Här går vi igenom vad multimodalitet innebär på plattformen, hur filer går från kundens enhet till modellens kontext, vad varje kanal stödjer och hur du behåller kontext mellan sessioner när kunden återkommer.

Kanaler och indata

ElevenAgents är byggt kring de kanaler företag redan använder för att nå kunder: webb- och mobilappar, supportsystem, telefon, SMS, e-post, WhatsApp och fler. Agentens inställningar (prompt, modell, verktyg, kunskapsbas och röst) sätts upp en gång och delas över alla kanaler. Två saker skiljer sig mellan kanaler: transportlagret och vilka indatatyp som stöds. Webb- och mobilappar kopplas via den inbäddade widgeten, ett av SDK:erna eller Agents WebSocket. Telefonsamtal kopplas via Twilio, SIP-trunk eller websocket-baserade integrationer. SMS går via Twilio-integrationen. WhatsApp kopplas genom att importera ett WhatsApp Business-konto och aktivera integrationen på agenten. En och samma agent kan användas på alla dessa kanaler samtidigt.

Filindata (bilder och PDF:er) stöds just nu på webben, mobilen och WhatsApp. Indata hanteras utifrån typ, inte kanal: ett foto och ett röstmeddelande som kommer in i samma WhatsApp-session går genom helt olika flöden innan de når modellen. Oavsett kanal eller indatatyp samlas allt i samma förbehandlingslager innan det skickas till modellen som ursprunglig kontext, där det följer en av två vägar.

Indatarepresentation: filbaserad vs. inline

Oavsett indatatyp eller kanal normaliserar plattformen varje indata till en av två interna representationer innan den skickas till modellen. Den klassificeringen avgör hur indatan kodas i modellens kontextfönster och vad din integration behöver hantera.

Filbaserad indata

Bilder och PDF:er skickas till modellen som ursprungliga filreferenser, inte textsammanfattningar. Plattformen lagrar filen, tilldelar den ettfile_idoch kopplar det till användarens tur. En modell som kan hantera bilder eller dokument får själva filen i sitt kontextfönster istället för en härledd representation. Integrationskravet är enkelt: fånga uppfile_idsom returneras av uppladdnings-endpointen och inkludera det i meddelandet. Om meddelandet skickas utanfile_idhar modellen ingen referens till filen, oavsett om uppladdningen lyckades. Filen lagras per konversation. Allt som behöver sparas längre än sessionen (själva filen, extraherade fält eller strukturerad output) måste hanteras av din integration. Hur det görs beror på kanal och användningsfall.

Inline

Den andra representationen är inline och gäller allt annat. Röst och röstmeddelanden transkriberas. Skriven text, transkriberat tal, platsnålar och kontaktkort i WhatsApp normaliseras till vanlig text i transkriptet innan modellen körs. En platsnål blir koordinater och eventuell adress; en kontakt blir namn och telefonnummer. Inget av detta lagras som filer eller får en filreferens. Dessa indata finns direkt i transkriptet.

Varför skillnaden är viktig

Uppdelningen avgör var du behöver lägga integrationsarbetet. Inline-vägen kräver inget av dig under samtalet: plattformen normaliserar dessa indata till text och de finns direkt i transkriptet. Filbaserad indata har en tydlig integrationsyta. Istället för att konvertera filinnehåll till text innan modellen körs, skickar orkestratorn själva filen direkt in i modellens kontextfönster. Modellen arbetar på filens struktur istället för en härledd text eller beskrivning, vilket bevarar spatiala relationer, visuell layout och dokumentformat som annars skulle gå förlorade. Med det i åtanke går vi nu igenom implementationen: hur du konfigurerar agenten, hur filer rör sig i varje kanal och hur du behåller kontext mellan sessioner.

Ställa in multimodal indata

Att aktivera multimodal indata börjar med samma agentinställning på webben, mobilen och WhatsApp. Därefter beror det på kanalen hur filen laddas upp och hur du hämtar den efteråt.

Aktivera filindata

Två inställningar måste vara aktiverade i agentkonfigurationen för att filindata ska fungera. Först, sättconversation_config.conversation.file_input.enabledtillTrue, antingen via API:et när agenten skapas eller underInställningar > Avancerade inställningar > Filindatai dashboarden. Sedan måste agenten vara konfigurerad med en modell som kan hantera bilder och dokument. Flaggan gör inget om modellen inte kan hantera bild- eller dokumentblock; båda måste vara inställda innan du testar.

SDK och WebSocket

Filindata på webben eller mobilen kräver en egen chattklient byggd på SDK:et eller en rå Agents websocket-anslutning. Flödet är identiskt för alla tre och ordningen är viktig: filen måste laddas upp innan meddelandet skickas, eftersom meddelandet refererar till identifieraren som uppladdningen returnerar.

Ladda upp filen först:

from elevenlabs import ElevenLabs

client = ElevenLabs(api_key="YOUR_API_KEY")

response = client.conversational_ai.conversations.files.create(
    conversation_id="your_conversation_id",
    file=open("example_file.jpg", "rb"),
)

file_id = response.file_id  

Sefiluppladdningför hela request och response:

Skicka sedan ett meddelande över anslutningen som refererar till den returneradefile_id:

{ 
	"type": "multimodal_message",
	"text": { 
		"type": "user_message", 
		"text": "What does this show?" 
	 },
	"file": { 
		"type": "file_input", 
		"file_id": "<file_id>" 
 	}
}

SDK:erna slår ihop uppladdning och referens i ett enda anrop och hanterar filidentifieraren internt. Semultimodal_messagespecifikationen för hela meddelandeformatet. Eftersom din applikation laddar upp filen har du redan filen vid det laget. Om du bara behöver den för den aktuella konversationen räcker det att ladda upp och referera till identifieraren. Om du behöver spara den längre, är det enklast att lagra den från din applikation vid uppladdning. Den kan också hämtas i efterhand via post-call-webhooken, som beskrivs i avsnittet om kontext mellan sessioner.

WhatsApp

På WhatsApp hanterar din applikation inte uppladdningen. När en kund skickar en bild, ett dokument eller en sticker går filen först till Metas infrastruktur. Meta meddelar ElevenLabs via WhatsApp Business API-webhooken, och ElevenLabs använder dina WhatsApp Business-kontouppgifter för att ladda ner filen server-till-server, lagrar en egen kopia och kopplar den till konversationen på samma sätt som vid uppladdning från webben eller SDK. Agenten tar emot den som multimodal indata och transkriptet loggar enfile_inputhändelse.

Eftersom din applikation aldrig hanterar uppladdningen har du aldrig filen direkt. Det finns ingen möjlighet att fånga den vid uppladdning som på webben och mobilen. Filen når ditt system viafile_urli post-call-webhooken, som pekar på ElevenLabs lagrade kopia. Metas media-URL används bara för inläsning och exponeras aldrig externt. Hur du hämtar filen, inklusive tidsbegränsningar för nedladdning, beskrivs i avsnittet om kontext mellan sessioner.

På WhatsApp skickar kunden filen i chatten. ElevenLabs hämtar den från Meta, lagrar den och kopplarfile_idpå plattformssidan. Det betyder att det inte finns något uppladdningssteg på klientsidan. Till skillnad från webben och mobilen anropar din applikation inte POST/v1/convai/conversations/{id}/fileseller skickarmultimodal_messageöver WebSocket. ElevenLabs hanterar leverans, lagring och agentens tur.

Behålla kontext mellan sessioner

ElevenAgents behandlar varje konversation separat. Inget som kunden skickar, och inget agenten löser under en konversation, följer automatiskt med till nästa. Agenten skickar allt från en avslutad konversation till ditt system via post-call-webhooken, men minnet som sträcker sig över flera konversationer finns utanför ElevenLabs. Det är du som ansvarar för kontinuiteten.

Den arkitektoniska gränsen är viktig att tänka på. De konversationer där multimodal indata är viktigast (en kund fotar en trasig vara, laddar upp en policy, delar plats) löses ofta inte i en enda session. En kund som skickar ett foto på en trasig del och bokar återuppringning förväntar sig att agenten minns fotot vid nästa kontakt. Utan explicit kontexthantering börjar agenten om från noll varje gång och kunden får upprepa sig. Lösningen består av två delar. När en konversation avslutas levererar post-call-webhooken transkriptet, analysresultat, eventuella strukturerade datafält du har definierat och fil-URL:er för filer som passerat sessionen. Din backend sparar det som är relevant mot ett beständigt kund-ID, t.ex. telefonnummer, användar-ID eller kontonyckel. När kunden återkommer injicerar din applikation den sparade kontexten vid sessionens start via dynamiska variabler, så agenten börjar samtalet med det den redan vet. För filbaserad indata pekar fil-URL:en i webhooken på ElevenLabs lagrade kopia och är enda sättet att hämta filen efter att konversationen avslutats. Plattformens kopia gäller bara för sessionen, så om du behöver filen i framtida konversationer eller i egna system måste du ladda ner den från webhooken innan tidsfönstret stängs. Hur snabbt du behöver agera beror på retention-policyn, som beskrivs i referensdokumentationen. Webhooken skickar ut tillståndet. Dynamiska variabler skickar in det igen. Allt däremellan är ditt systems ansvar, och det är där det verkliga integrationsarbetet ligger för alla användningsfall där kunder återkommer, eskalerar eller fortsätter mitt i en lösning.

Hur du injicerar kontext beror på kanal

Injektionsmekanismen skiljer sig mellan kanaler, men mönstret är detsamma. För telefoni ringer ElevenLabs din server innan samtalet kopplas, så du kan slå upp numret och returnera dynamiska variabler som namn, order-ID eller kontonivå innan agenten pratar. På WhatsApp triggas en pre-message-webhook vid varje inkommande meddelande, så du kan lägga till identitet och affärskontext från dina system innan agenten behandlar det. Annars skickas samma fält iconversation_initiation_client_datanär sessionen startar. ElevenAgents slår inte ihop sessioner från olika kanaler till en tråd. En WhatsApp-konversation och en webbkonversation är separata sessioner även om det är samma kund. Men eftersom webhook-utdata och dynamisk variabelinjektion fungerar likadant i alla kanaler räcker ett enda lagringslager för alla. Bygg det en gång så täcker det alla kanaler agenten körs på. Kontextinjektion hanterar textdata: namn, order-ID, sammanfattningar, strukturerade fält. Filer är ett separat fall och kräver en annan hantering.

Föra filer vidare

Filer gäller bara för en konversation och sparas inte automatiskt. Vad du ska föra vidare beror på om nästa konversation behöver informationen från filen eller själva filen. Oftast räcker det med informationen. Agenten tolkar en uppladdad fil när den kommer in, men skriver inte automatiskt tolkningen någonstans beständigt. Den strukturerade utdata kommer från post-call-datan: transkriptet, transkriptsammanfattningen och eventuella datainsamlingsfält du har definierat. Om en kund skickar ett foto på en sprucken dörrtätning och återkommer en vecka senare för att följa upp ärendet behöver agenten inte fotot igen. Den behöver veta att ärendet gäller en sprucken dörrtätning. Du hämtar det ur post-call-datan, sparar det mot kund-ID och injicerar det som en dynamisk variabel när kunden återkommer. En kort sammanfattning eller några strukturerade fält räcker oftast.

När du behöver originalfilen, till exempel för egna register, regelefterlevnad eller vidare system, är post-call-webhooken vägen att hämta den. Varje uppladdad fil syns i transkriptet som enfile_inputhändelse med en signerad fil-URL. Den URL:en är giltig i femton minuter, så ladda ner och spara filen direkt när webhooken kommer istället för att vänta. Om du missar tidsfönstret medan konversationen fortfarande finns kvar kan GET conversation API ge nya URL:er som reserv. Räkna med attfile_inputkan saknas i vissa fall, till exempel vid zero-retention-läge, istället för att anta att varje filbaserad tur har en URL.

Det täcker hela livscykeln: en fil kommer in i sessionen, modellen arbetar på den direkt, strukturerad utdata skickas ut via webhooken och ditt lagringslager avgör vad agenten vet nästa gång.

Sammanfattning

Samma agentinställning tar emot bilder och PDF:er på webben, mobilen och WhatsApp utan att du behöver bygga separat för varje kanal. Filer normaliseras, kopplas till turen och skickas till modellen som ursprungliga block istället för textsammanfattningar, så layout, visuell struktur och dokumentformat bevaras. Kontext mellan sessioner följer samma mönster i alla kanaler: post-call-webhooken skickar ut tillståndet, dynamiska variabler skickar in det igen.

Om du bygger på ElevenLabs Agents och vill att din agent ska kunna arbeta med bilder och dokument tillsammans med röst och text, aktivera multimodal indata och berätta gärna vad du tycker.