Posts List
Novidades
lightning/accApi no LWC: Como Controlar o Painel do Agentforce Programaticamente em Componentes Lightning
Como transformar componentes Lightning Web Components em gatilhos inteligentes para o painel nativo de inteligência artificial, enviando comandos contextuais e dados não salvos em tempo de execução.
Durante as primeiras iterações do Agentforce, a interação do usuário com os agentes de inteligência artificial ocorria quase exclusivamente de maneira passiva: o usuário precisava clicar manualmente no ícone do painel lateral, digitar sua dúvida em linguagem natural e aguardar a resposta. Embora esse modelo funcione bem para consultas abertas, ele cria atrito em fluxos operacionais corporativos onde a interface já possui todo o contexto do registro aberto.
Para unir a experiência rica e estruturada dos componentes Lightning Web Components (LWC) com a flexibilidade conversacional do Agentforce, a Salesforce disponibilizou o módulo headless lightning/accApi (conhecido como Agentforce Conversation Client API, ou simplesmente ACC API).
Esse módulo atua como uma ponte programática entre o código JavaScript do seu componente front-end e o painel nativo do Agentforce no desktop. Com ele, um botão customizado na tela pode abrir o painel, selecionar o agente correto e disparar uma instrução estruturada contendo dados que o usuário acabou de digitar no formulário, mesmo antes do registro ser gravado no banco de dados.
Neste guia técnico, vamos explorar os métodos fundamentais da ACC API, analisar o fluxo de mensagens entre o LWC e o painel, e implementar um componente completo de assistência de casos pronto para produção.
1. O Que É o Módulo lightning/accApi?
O lightning/accApi é um módulo JavaScript sem interface gráfica (headless) que expõe métodos assíncronos para manipular o ciclo de vida do painel do Agentforce na experiência desktop do Lightning Experience.
Ele foi desenhado para atender a três casos de uso principais:
- Abertura e Fechamento Controlados: Permitir que botões de ação na página abram ou minimizem o painel lateral conforme a etapa do processo de negócio.
- Disparo de Utterances Programáticas: Enviar frases e instruções pré-formatadas diretamente para a caixa de diálogo do agente, simulando a digitação do usuário.
- Injeção de Contexto Volátil: Enviar valores de campos modificados na tela que ainda não passaram por um comando DML no backend, garantindo que o agente analise o estado mais recente da interação.
+-------------------------------------------------------------+
| Custom Lightning Web Component |
| (Ex: Botão "Analisar Risco de Churn" ou Formulário) |
+-------------------------------------------------------------+
|
import { open, execute } from 'lightning/accApi';
|
v
+-------------------------------------------------------------+
| Agentforce Conversation Client |
| (lightning/accApi Bridge) |
+-------------------------------------------------------------+
|
v [App-to-Panel Message Router]
+-------------------------------------------------------------+
| Painel Lateral Nativo do Agentforce |
| (Abre na tela, seleciona o agente e executa a instrução) |
+-------------------------------------------------------------+
2. Métodos Principais da ACC API
Para utilizar o módulo, você deve importá-lo no seu arquivo JavaScript definindo a versão mínima da API como 59.0 (recomendado 67.0 para desfrutar de todas as otimizações do runtime moderno).
Os métodos disponíveis são:
open(options)
Abre o painel lateral do Agentforce. Pode receber opcionalmente o identificador do agente (agentId ou botId) para o qual a conversa deve ser direcionada:
JavaScript
import { open } from 'lightning/accApi';
// Abertura simples do painel
await open();
// Abertura apontando para um Employee Agent específico
await open({ agentId: '0Xxxx0000000001CAA' });
close()
Fecha ou minimiza o painel lateral do Agentforce programaticamente:
JavaScript
import { close } from 'lightning/accApi';
await close();
execute(options)
O método mais poderoso da API. Ele abre o painel (caso esteja fechado), seleciona o agente especificado e envia uma mensagem de texto (utterance) como se tivesse sido redigida pelo operador:
JavaScript
import { execute } from 'lightning/accApi';
await execute({
agentId: '0Xxxx0000000001CAA',
text: 'Resuma as três últimas interações deste cliente e sugira a próxima melhor oferta.'
});
3. Arquitetura de UI Agêntica: Passando Valores Não Salvos ao Agentforce
Um dos maiores desafios em telas complexas de atendimento ou cotação é que o operador preenche vários campos de texto (como anotações de triagem ou justificativas de desconto) antes de salvar o registro. Se o agente de IA consultar apenas os dados gravados via SOQL ou Data Cloud, ele perderá as informações vitais que estão apenas na memória do navegador.
Com o lightning/accApi, o LWC captura os valores do formulário via JavaScript e monta uma utterance rica que inclui esses dados no prompt antes de disparar a execução.
Exemplo Prático: Componente caseAgentAssistant
Vamos construir um componente LWC para páginas de Caso (Case) que permite ao operador redigir uma anotação rápida de suporte e clicar em um botão para que o Agentforce redija uma resposta formal ao cliente considerando tanto o histórico do caso quanto a anotação provisória.
1. Template HTML: caseAgentAssistant.html
HTML
<template>
<lightning-card title="Assistente Agêntico de Atendimento" icon-name="standard:agentforce">
<div class="slds-p-around_medium">
<div class="slds-m-bottom_small">
<p class="slds-text-body_small slds-text-color_weak">
Utilize o Agentforce para gerar uma minuta de resposta técnica baseada nas anotações da triagem atual.
</p>
</div>
<!-- Campo de entrada com valores voláteis (não salvos no banco) -->
<lightning-textarea
name="triageNotes"
label="Anotações de Triagem em Tempo Real"
placeholder="Ex: Cliente relatou falha no módulo de faturamento após a atualização 2.4..."
value={triageNotes}
onchange={handleNotesChange}
rows="3"
required>
</lightning-textarea>
<div class="slds-m-top_medium slds-grid slds-grid_align-spread">
<lightning-button
label="Abrir Painel"
icon-name="utility:chat"
onclick={handleOpenPanel}>
</lightning-button>
<lightning-button
variant="brand"
label="Gerar Resposta com Agentforce"
icon-name="utility:magicwand"
onclick={handleGenerateResponse}
disabled={isGenerateDisabled}>
</lightning-button>
</div>
</div>
</lightning-card>
</template>
2. Controlador JavaScript: caseAgentAssistant.js
JavaScript
import { LightningElement, api, track } from 'lwc';
import { open, execute } from 'lightning/accApi';
import { ShowToastEvent } from 'lightning/platformShowToastEvent';
export default class CaseAgentAssistant extends LightningElement {
@api recordId; // ID do Caso fornecido pelo contexto da página de registro
@track triageNotes = '';
// ID do agente especializado (pode ser configurado no Lightning App Builder)
@api targetAgentId = '';
get isGenerateDisabled() {
return !this.triageNotes || this.triageNotes.trim().length === 0;
}
handleNotesChange(event) {
this.triageNotes = event.target.value;
}
async handleOpenPanel() {
try {
await open(this.targetAgentId ? { agentId: this.targetAgentId } : {});
} catch (error) {
this.showToast('Erro', 'Não foi possível abrir o painel do Agentforce: ' + error.message, 'error');
}
}
async handleGenerateResponse() {
try {
// Monta a instrução incluindo o contexto do registro e os dados voláteis da tela
const promptText = `Atue como o especialista de suporte do Caso de ID ${this.recordId}. ` +
`O operador realizou as seguintes observações em tempo real: "${this.triageNotes}". ` +
`Por favor, consulte os manuais técnicos via Data Library e elabore uma minuta de resposta estruturada para o cliente.`;
const options = {
text: promptText
};
if (this.targetAgentId) {
options.agentId = this.targetAgentId;
}
// Dispara a ação no painel do Agentforce
await execute(options);
this.showToast('Sucesso', 'Instrução enviada ao Agentforce com sucesso.', 'success');
} catch (error) {
this.showToast('Falha na Execução', 'Erro ao enviar comando para o Agentforce: ' + error.message, 'error');
}
}
showToast(title, message, variant) {
this.dispatchEvent(new ShowToastEvent({ title, message, variant }));
}
}
3. Metadados de Configuração: caseAgentAssistant.js-meta.xml
XML
<?xml version="1.0" encoding="UTF-8"?>
<LightningComponentBundle xmlns="http://soap.sforce.com/2006/04/metadata">
<apiVersion>67.0</apiVersion>
<isExposed>true</isExposed>
<masterLabel>Case Agentforce Assistant</masterLabel>
<description>Componente LWC que controla o painel do Agentforce enviando anotações de triagem.</description>
<targets>
<target>lightning__RecordPage</target>
<target>lightning__AppPage</target>
</targets>
<targetConfigs>
<targetConfig targets="lightning__RecordPage">
<objects>
<object>Case</object>
</objects>
<property name="targetAgentId" type="String" label="ID do Agente Alvo" description="Identificador único (18 dígitos) do Agentforce Agent para este fluxo." />
</targetConfig>
</targetConfigs>
</LightningComponentBundle>
4. Boas Práticas e Tratamento de Exceções com lightning/accApi
Ao implementar componentes baseados na ACC API em ambientes corporativos, siga estas diretrizes essenciais:
- Tratamento Elegante de Erros (Try/Catch): Chamadas a
open()ouexecute()podem falhar caso o usuário não possua permissão de acesso ao Agentforce ou esteja utilizando um navegador incompatível. Sempre envolva as chamadas em blocostry/catche notifique o usuário viaShowToastEvent. - Evite Sobrecarga de Prompts: Mantenha as instruções objetivas. Em vez de enviar o dump completo do registro na utterance, passe o
recordIde apenas os dados novos digitados pelo usuário, deixando que o agente recupere os campos complementares via SOQL ou grounding do Atlas Engine. - Idempotência e Prevenção de Múltiplos Cliques: Desabilite temporariamente o botão de disparo enquanto a Promise de
execute()estiver pendente para evitar o envio duplicado de comandos ao agente.
Conclusão
A chegada do módulo lightning/accApi representa a evolução definitiva da experiência do desenvolvedor front-end na era dos agentes autônomos. Ao permitir que componentes Lightning Web Components controlem o painel nativo do Agentforce de maneira programática, a Salesforce entrega aos arquitetos a capacidade de desenhar jornadas de trabalho fluidas, onde cliques em botões especializados e dados digitados na tela tornam-se gatilhos instantâneos para a ação da inteligência artificial.
Sua equipe já começou a integrar componentes LWC com o Agentforce em suas páginas de registro? Deixe suas dúvidas e experiências nos comentários abaixo ou compartilhe suas implementações com nossa comunidade no LinkedIn.
Tableau
Tableau MCP: como agentes de IA se tornam especialistas em dados com Model Context Protocol
A Salesforce anunciou o Tableau MCP como parte da release Summer ’26, uma integração que utiliza o Model Context Protocol para permitir que agentes de IA acessem diretamente o motor de analítica do Tableau. Essa novidade representa um avanço significativo na forma como empresas conectam inteligência artificial aos seus dados de negócio, eliminando a barreira que historicamente separava LLMs de informações analíticas confiáveis.
Até pouco tempo atrás, modelos de linguagem generativos enfrentavam uma limitação fundamental: eles simplesmente não conseguiam acessar dados analíticos empresariais em tempo real. Essa desconexão resultava em respostas genéricas, superficiais e, em muitos casos, incorretas quando o assunto envolvia métricas específicas de negócio. Com o Tableau MCP, esse cenário muda radicalamente.
O problema que o Tableau MCP resolve
Imagine o seguinte cenário: você pergunta a um assistente de IA qual foi a receita da região Sudeste no último trimestre. Sem integração analítica, o modelo pode inventar números, fornecer dados desatualizados ou simplesmente informar que não possui essa informação. Nenhuma dessas opções é aceitável para um ambiente empresarial.
Segundo dados da própria Salesforce, cerca de 80% dos líderes seniores de TI acreditam que a inteligência artificial generativa ajudará suas organizações a fazerem melhor uso dos dados. Contudo, 41% desses profissionais relata que não conseguem compreender seus dados porque são complexos demais ou pouco acessíveis. Um terço aponta a incapacidade de gerar insights como um problema crítico.
O Tableau MCP ataca exatamente esse ponto de dor. Ele permite que agentes de IA consultem diretamente o motor de consulta do Tableau, obtendo respostas fundamentadas no contexto analítico real da empresa — e não em suposições ou dados treinados.
O que é Model Context Protocol (MCP)?
O Model Context Protocol é uma especificação aberta desenvolvida para padronizar a comunicação entre modelos de linguagem e fontes de dados externas. Pense nele como um tradutor universal que permite que qualquer LLM converse com qualquer sistema de dados de forma segura e estruturada.
No contexto do Tableau, o MCP funciona como uma ponte entre o agente de IA e o servidor analítico. Quando você faz uma pergunta em linguagem natural, o protocolo traduz essa consulta para o formato que o Tableau compreende, executa a análise nos dados reais e retorna a resposta fundamentada — tudo isso em segundos.
<span class="line"><span style="color: #676e95;"># Fluxo simplificado da consulta via Tableau MCP</span></span>
<span class="line"><span style="color: #f78c6c;">1.</span><span style="color: #babed8;"> Usuário pergunta: "Qual o ticket médio por região?"</span></span>
<span class="line"><span style="color: #f78c6c;">2.</span><span style="color: #babed8;"> Agente de IA envia consulta via MCP</span></span>
<span class="line"><span style="color: #f78c6c;">3.</span><span style="color: #babed8;"> Tableau processa nos dados reais</span></span>
<span class="line"><span style="color: #f78c6c;">4.</span><span style="color: #babed8;"> Resposta fundamentada retorna ao usuário</span></span>
<span class="line"><span style="color: #676e95;"># Sem inventar números. Sem adivinhação.</span></span>Code language: HTML, XML (xml)Arquitetura técnica: como funciona por dentro
A implementação do Tableau MCP segue uma arquitetura cuidadosamente projetada para manter a segurança dos dados como prioridade máxima. O fluxo funciona da seguinte forma:
1. Camada de Entrada
O agente de IA recebe uma consulta em linguagem natural do usuário. Essa entrada pode vir de qualquer interface: chatbot, Slack, portal do cliente ou até mesmo uma integração customizada via API.
2. Tradução MCP
O protocolo MCP traduz a consulta natural para uma chamada estruturada que o motor do Tableau compreende. Isso envolve mapear entidades, identificar métricas e definir dimensões de análise.
3. Processamento Analítico
O Tableau executa a consulta nos dados reais da empresa, aplicando todas as regras de segurança, filtros de linha e permissões de acesso configuradas. O agente de IA acessa apenas os dados que o usuário final teria permissão para visualizar.
4. Camada de Proteção
Todas as respostas passam pelo Agentforce Trust Layer, que aplica filtros de segurança adicionais, verifica a precisão das informações e garante que nenhum dado sensível vaze para contextos indevidos.
5. Resposta Contextualizada
O agente Formata a resposta final em linguagem natural, adicionando contexto relevante e, quando apropriado, sugestões de próximas análises ou ações recomendadas.
Casos de uso práticos
Vendas e Revenue Operations
Um diretor de vendas pode perguntar ao agente: “Quais foram as oportunidades perdidas na região Norte no último mês e qual o motivo principal?” O Tableau MCP consulta os dados reais do pipeline, cruza com informações de perda e retorna uma análise fundamentada — não apenas números soltos, mas insights com contexto.
Marketing e Performance de Campanhas
Em vez de esperar horas para um analista extrair dados e montar um relatório, o gestor de marketing pode consultar diretamente: “Como está o ROI da campanha de verão comparada com a do ano passado?” A resposta vem em segundos, fundamentada nos dados reais de performance.
Atendimento ao Cliente
Agentes de suporte podem obter respostas instantâneas sobre tendências de problemas: “Houve um aumento anormal de reclamações sobre o produto X na última semana?” Isso permite identificar crises antes que se espalhem.
Executivos e Board Meetings
Líderes podem ter acesso rápido a métricas críticas sem depender de relatórios preparados: “Qual a margem bruta consolidada deste trimestre comparada com as previsões?”
Diferenciais em relação a soluções concorrentes
O Tableau MCP se destaca por três fatores fundamentais:
Primeiro, a segurança integrada. Enquanto outras soluções exigem configurações adicionais de governança, o Tableau MCP herda nativamente todas as políticas de segurança do Salesforce e do Tableau, incluindo filtros de linha por usuário, permissões de campo e auditoria completa.
Segundo, a profundidade analítica. Diferente de connectors superficiais que apenas consultam bancos de dados, o Tableau MCP aproveita todo o poder do motor VizQL do Tableau, incluindo cálculos complexos, agregações pré-definidas e modelos analíticos já curados pelas equipes de BI.
Terceiro, a integração nativa. Não é uma conexão terceirizada ou um bridge improvisado. O Tableau MCP é uma feature first-party da Salesforce, com suporte completo, documentação oficial e roadmap integrado ao ecossistema Agentforce.
Impacto para desenvolvedores e administradores Salesforce
Para profissionais do ecossistema Salesforce, o Tableau MCP abre novas possibilidades de desenvolvimento:
Desenvolvedores podem construir agentes personalizados que consultam dados analíticos do Tableau diretamente em suas aplicações Lightning Web Components, usando MCP como protocolo de comunicação.
Administradores podem configurar quais datasets do Tableau serão expostos aos agentes de IA, mantendo controle granular sobre quais informações são acessíveis.
Arquitetos de solução podem projetar fluxos que combinam dados operacionais do CRM com insights analíticos do Tableau, criando experiências unificadas para usuários finais.
Como habilitar o Tableau MCP na sua organização
A implementação do Tableau MCP segue as melhores práticas de governança do Salesforce. De forma resumida, o processo envolve:
- Configurar a integração Tableau MCP no painel de administração do Agentforce
- Definir quais workbooks e data sources estarão disponíveis para consulta via MCP
- Configurar as políticas de segurança que controlam quais usuários podem acessar quais dados
- Testar em ambiente de sandbox antes de promover para produção
- Monitorar o uso e a precisão das respostas através dos logs de auditoria
O futuro dos agentes de IA fundamentados em dados
O Tableau MCP representa mais do que uma nova feature técnica. Ele sinaliza uma mudança de paradigma na forma como as empresas utilizam inteligência artificial. Em vez de assistentes que “acham” respostas baseadas em padrões estatísticos, estamos caminhando para agentes que “sabem” respostas porque consultam os dados reais do negócio.
Para o mercado brasileiro, onde a complexidade fiscal e a diversidade de sistemas legados criam desafios únicos, essa integração pode ser particularmente valiosa. A capacidade de询问 métricas de negócio em tempo real, fundamentadas em dados locais e em conformidade com regulamentações nacionais, representa um salto de produtividade significativo.
A Salesforce reforça que o Tableau MCP foi projetado com princípios de responsible AI. Todas as consultas são auditadas, as respostas passam por camadas de verificação e os dados permanecem protegidos pelo Agentforce Trust Layer.
A pergunta que fica é: sua empresa está pronta para ter agentes de IA que realmente compreendem seus dados?
