Como usar Slack Incoming e Outgoing Webhooks para agentes de IA em tempo real

Agora o nosso É e pronto para implantação, vamos expandir suas capacidades, integrando uma nova fonte de entrada. Aplicação Containerização Aplicação Containerização Integração do Slack para comunicações em tempo real Imagine um cenário em que queremos receber notificações em tempo real para novas mensagens em canais específicos do Slack. (LLMs) para gerar resumos ou projetos de respostas. Esta nova funcionalidade funcionará em conjunto com a nossa O que continua a fazer as caixas de correio. Grandes modelos de linguagem O agente Grandes modelos de linguagem O agente Esta integração será uma pedra angular do nosso sistema de agente proativo. Ao monitorar simultaneamente Slack e e-mail, nosso aplicativo se torna um hub centralizado para comunicações, garantindo que nenhuma mensagem é perdida e cada consulta é tratada prontamente.Esta abordagem de dupla fonte demonstra o poder e a flexibilidade de um sistema bem arquitetado, combinando plataformas de comunicação tradicionais e modernas para uma solução abrangente. Para receber notificações sobre novas mensagens do Slack, podemos usar o Um Webhook é um callback HTTP definido pelo usuário que é desencadeado por um evento em um sistema de origem.Quando o evento ocorre, o sistema de origem faz uma solicitação HTTP/HTTPS para o URL configurado no . Webhooks Webhook Como funciona o Slack Webhooks No contexto do Slack, um Webhook de saída é configurado para um canal ou espaço de trabalho específico. Quando uma mensagem é postada ou um evento é alcançado que atende a certos critérios (por exemplo, uma palavra-chave específica, padrão), o Slack envia uma solicitação HTTP POST para um URL designado. , que então processa os dados de entrada. Aplicação Aplicação Este método é muito eficaz, pois é Em vez de nosso aplicativo constantemente sondando Slack para novas mensagens (o que é intensivo em recursos e ineficiente), Slack proativamente “push” as informações para nós assim que um evento acontece. Eventos movidos Eventos movidos Por que escolher Webhooks? Receba mensagens como elas acontecem, permitindo ação imediata. Real-time updates: Nosso aplicativo não precisa pesquisar Slack, economizando chamadas de API e recursos de servidor. Reduced resource usage: Webhooks são uma maneira padrão e simples de conectar diferentes serviços. Simple integration: Esta abordagem é fundamental para a construção de uma que responde instantaneamente a novas comunicações, sejam elas provenientes do Slack ou de outras fontes, como e-mail. Proactive Agent Webhooks de entrada e saída Sim, o Slack tem webhooks de entrada e saída. Estes são dois mecanismos distintos que servem a diferentes propósitos em um fluxo de trabalho de comunicação. Início Webhooks O que eles são: Este é o tipo mais comum de webhook no Slack. Eles permitem que aplicativos externos enviem (push) mensagens em um canal Slack. Seu aplicativo faz uma solicitação HTTP POST para esse URL, enviando uma carga útil JSON com o texto da mensagem e formatação. Webhooks de entrada usados para notificações, alertas e mensagens automatizadas. por exemplo, para enviar notificações sobre novos compromissos do GitHub, estados de implantação ou mensagens do nosso site. Voltar para Slack. Proactive O agente O agente O agente Exposição Webhooks Este é um mecanismo legado que permite que o Slack envie (push) dados para um aplicativo externo quando um evento específico ocorre em um canal. Você configura um webhook de saída especificando o URL do seu aplicativo e desencadeando palavras ou eventos.Quando um usuário em um canal Slack publica uma mensagem contendo uma dessas palavras, o Slack faz uma solicitação HTTP POST para o URL do seu aplicativo. Outgoing Webhooks usados para criar e automatizações que reagem a comandos ou palavras-chave específicas. Bots interativos Bots interativos Em nosso cenário, configuramos um webhook de saída com um gatilho como resumo para que nosso agente possa receber e processar a mensagem para gerar um resumo. Diferença chave Webhooks de entrada são usados para enviar mensagens para o Slack (de uma fonte externa). Outgoing Webhooks são usados para receber mensagens do Slack (para uma fonte externa), mas apenas com base em um gatilho específico. No contexto do nosso artigo sobre a , usamos um webhook de saída para receber mensagens do Slack para processamento e um webhook de entrada para enviar respostas de volta ao Slack. “Proactive Agent” Guia passo a passo para criar um aplicativo Slack Para permitir que o Slack nos envie eventos de webhook, devemos primeiro criar um aplicativo no portal do desenvolvedor e instalá-lo no espaço de trabalho do Slack ou em um canal específico do qual queremos receber notificações. Acesse o site da API do Slack: Navegue para . https://api.slack.com/apps https://api.slack.com/apps https://api.slack.com/apps Clique em “Criar um aplicativo” e escolha para construí-lo “Do zero”.Dê ao seu aplicativo um nome descritivo e selecione o espaço de trabalho Slack onde você vai desenvolvê-lo e testá-lo. Ativar Assinaturas de Eventos: Nas configurações do seu aplicativo, navegue para a seção “Assinaturas de Eventos” e ative “Ativar Eventos”. Fornecer um URL de solicitação: Você deve fornecer um URL publicamente acessível para o seu aplicativo. Este é o ponto final onde o Slack enviará cargas de pagamento de eventos. O Slack realizará uma verificação de verificação de URL única, onde o seu aplicativo deve responder com o valor de desafio do pedido do Slack. Criaremos este ponto final no nosso aplicativo Symfony. Subscribe to Bot Events: Desloque-se para a seção "Subscribe to bot events".Clique em "Add Bot User Event" e selecione o evento message.channels. Isso diz a Slack para enviar seu aplicativo uma carga útil para cada mensagem postada em um canal público. Request Scopes: Para receber esses eventos, seu bot precisará das permissões apropriadas. Na seção “OAuth & Permissions”, adicione o escopo channels:history ao token do bot. Isso concede à sua aplicação a capacidade de visualizar mensagens em canais públicos. Reinstalar o seu aplicativo: Depois de adicionar novos âmbitos, você tem que reinstalar o seu aplicativo no espaço de trabalho para que as alterações entrem em vigor. Seguindo estes passos, a nossa receberá uma carga útil completa de JSON para cada nova mensagem nos canais assinados, proporcionando mais contexto e flexibilidade do que o método de palavra-chave legado. . proactive agent Aplicações AI-powered Aplicações AI-powered Aplicações AI-powered Validação Webhook É hora de criar um endpoint para lidar com a resposta para a nossa solicitação de validação de endpoint.Temos duas opções para trabalhar com webhooks no lado da Symfony: podemos lidar com ele no nível do controlador ou usar o Componente. Neste artigo, vamos nos concentrar em trabalhar no nível do controlador. Em um post futuro, mostrarei como fazer isso usando o . symfony/webhook Symfony Webhook Component Quando você configura o URL do endpoint no Slack Event Subscriptions, o Slack envia um pedido de verificação inicial para confirmar que o URL é válido e pertence ao seu aplicativo. Nosso ponto final deve responder com o valor de desafio exato do corpo da solicitação. challenge Para lidar com a solicitação de webhook corretamente, precisamos não apenas receber a carga útil, mas também validar sua exatidão. (DTOs) e instalar dois componentes-chave da Symfony: e . Transferência de dados Objetos symfony/validator symfony/serializer-pack Transferência de dados Objetos Transferência de dados Objetos Por que esses componentes são essenciais Este componente fornece uma estrutura robusta para validar dados contra um conjunto de regras.Em vez de escrever manualmente declarações if-else para verificar cada campo, podemos definir restrições de validação (por exemplo, NotBlank, Type, Length) diretamente em nossas propriedades DTO. symfony/validator: Este pacote de componentes fornece tudo o que precisamos para serializar (transformar objetos em matrizes/JSON) e deserializar (transformar JSON/arrays em objetos) dados. Usaremos o deserializador para converter automaticamente a carga útil JSON de entrada do Slack em um objeto DTO validado. symfony/serializer-pack: E agora estamos prontos para usar as coleções mais avançadas que a Doutrina oferece. componente ainda; em vez disso, instalaremos apenas o pacote para trabalhar com . Doctrine collections Enquanto as matrizes PHP são versáteis, elas carecem de alguns recursos avançados, como sugestão de tipo, imutabilidade e métodos especializados para filtragem ou mapeamento. fornecer um envolvimento poderoso e orientado a objetos em torno de matrizes, dando-nos uma maneira mais robusta e previsível de gerenciar dados. sistema, onde estaremos lidando com listas de mensagens, usuários ou outras cargas de dados. Doctrine Collections Proactive Agent Essas pequenas, mas impactantes mudanças melhorarão significativamente a forma como gerenciamos os dados dentro de nós. , tornando a lógica do nosso agente mais robusta e mais fácil de manter. Nossa Aplicação Nossa Aplicação Para instalar os componentes necessários, basta executar o seguinte comando no seu terminal: composer require doctrine/collections composer require symfony/validator composer require symfony/serializer-pack O fluxo de trabalho para validar uma carga de pagamento do Webhook Receber a solicitação: Nosso controlador Symfony recebe a solicitação HTTP POST do Slack. Deserialize para DTO: Usamos o serializador para transformar a carga útil JSON em nosso objeto DTO predefinido. Validar o DTO: O componente validador verifica as propriedades do DTO contra as restrições definidas. Gerenciar Erros: Se a validação falhar, devolveremos uma resposta de erro (por exemplo, um pedido de erro 400) para o Slack. Dados válidos de processamento: Se a validação for bem-sucedida, nosso aplicativo pode proceder com segurança ao processamento dos dados do webhook, sabendo que eles estão no formato correto. Esta abordagem estruturada garante que a nossa aplicação é resiliente e apenas processa dados que atendam ao nosso formato esperado, o que é um passo crítico na construção de um sistema confiável e seguro. Manipulação de várias cargas de pagamento dentro de um único controlador Devemos também considerar que o nosso controlador e uma única rota devem lidar corretamente , da validação de URL para as cargas de pagamento de eventos de trabalho que assinamos. different types of payloads Este é um requisito-chave para um endpoint de webhook robusto. Um único caminho deve ser inteligente o suficiente para diferenciar entre uma solicitação de verificação de URL única e uma notificação de evento ao vivo. Como discutido anteriormente, a carga útil de verificação de URL inicial do Slack contém um Todas as cargas de pagamento de eventos subsequentes contêm uma chave de evento que detém os dados da mensagem real.Nosso controlador deve verificar a presença dessas chaves para determinar a natureza da solicitação. challenge Solicitação de validação de URL Slack Ok, vamos criar um DTO para validar a solicitação de verificação de URL do Slack. Primeiro, aqui está o que uma carga útil típica de solicitação de validação de URL do Slack parece. Quando você habilita Assinaturas de Eventos, o Slack envia uma solicitação POST ao seu endpoint com uma carga útil JSON que contém três campos-chave: token, desafio e tipo. { "token": "Jhj5...z412", "challenge": "3eZbr...", "type": "url_verification" } Um token único para o seu aplicativo. Você pode usar isso para verificar que o pedido é do seu aplicativo. token: Uma cadeia gerada aleatoriamente.Você deve devolver essa cadeia exata em sua resposta JSON para provar que você possui o URL. challenge: O tipo de evento. Para validação, isso será sempre url_verification. type: Criação do DTO Agora, vamos criar um DTO que reflita essa estrutura e inclui restrições de validação usando o componente de validação da Symfony. namespace App\DTO\Slack; use Symfony\Component\Validator\Constraints as Assert; class SlackUrlValidationRequest { #[Assert\NotBlank] #[Assert\Type('string')] public string $token; #[Assert\NotBlank] #[Assert\Type('string')] public string $challenge; #[Assert\NotBlank] #[Assert\Type('string')] #[Assert\EqualTo("url_verification")] public string $type; public function getToken(): string { return $this->token; } public function getChallenge(): string { return $this->challenge; } public function getType(): string { return $this->type; } } Este DTO simplifica a validação: Assegura que os campos token, desafio e tipo estejam presentes na solicitação. Assert\NotBlank: Confirma que o valor de cada campo é uma cadeia, evitando tipos de dados inesperados. Assert\Type(“string”): Verifica especificamente que o campo de tipo corresponde à cadeia necessária, para que saibamos que estamos lidando com um pedido de verificação de URL e não com outro tipo de evento. Assert\EqualTo(“url_verification”): Usando este DTO, podemos deserializar a carga útil de JSON de entrada e validar automaticamente sua estrutura com código mínimo em nosso controlador. Criando um controlador para a validação do Slack Webhook Perfeito, vamos criar um controlador que utilize um DTO para validar a solicitação do Slack. Este controlador verificará se a solicitação recebida é uma solicitação de verificação de URL e a processará corretamente, devolvendo o código de desafio. SlackUrlValidationRequest Vamos injetar o para deserializar a carga útil do JSON em nosso DTO e o Esta abordagem torna o código limpo, confiável e compatível com os padrões da Symfony. SerializerInterface ValidatorInterface namespace App\Controller; use App\DTO\Slack\SlackUrlValidationRequest; use Symfony\Component\HttpFoundation\JsonResponse; use Symfony\Component\HttpFoundation\Request; use Symfony\Component\HttpFoundation\Response; use Symfony\Component\HttpKernel\Exception\BadRequestHttpException; use Symfony\Component\Messenger\Envelope; use Symfony\Component\Messenger\MessageBusInterface; use Symfony\Component\Routing\Attribute\Route; use Symfony\Component\Serializer\SerializerInterface; use Symfony\Component\Validator\Validator\ValidatorInterface; class WebhookController { #[Route('/webhook/slack', name: 'webhookSlack')] public function __invoke(Request $request, ValidatorInterface $validator, SerializerInterface $serializer ): JsonResponse { $data = json_decode($request->getContent(), true); if ($data === null) { throw new BadRequestHttpException('Invalid JSON.'); } $dtoClass = SlackUrlValidationRequest::class; $dto = $serializer->denormalize($data, $dtoClass); $errors = $validator->validate($dto); if (count($errors) > 0) { $errorMessages = []; foreach ($errors as $error) { $errorMessages[] = $error->getPropertyPath() . ': ' . $error->getMessage(); } return new JsonResponse(['errors' => $errorMessages], Response::HTTP_BAD_REQUEST); } switch (get_class($dto)) { case SlackUrlValidationRequest::class: return new JsonResponse($dto->getChallenge()); } return new JsonResponse(['status' => 'ok'], Response::HTTP_OK); } } Este controlador agora lida com solicitações de verificação de forma confiável e segura, que é a base para a nossa “ .” Agente Proativo Agente Proativo Agente Proativo Agora podemos testar como nosso controlador funciona enviando uma mensagem de validação de URL de um servidor, simulando o comportamento do Slack. Criar um DTO para mensagens de eventos Slack Agora, vamos criar um DTO para processar e validar as mensagens que o Slack nos enviará quando os eventos ocorrerem. Ao contrário da simples solicitação de validação de URL, a carga útil do evento contém muito mais dados, então vamos criar vários DTOs para validação mais eficaz e modular. Estrutura típica de solicitação de evento Uma solicitação de evento contém os campos token, team_id, api_app_id e, mais importante, um objeto de evento.Dentro do objeto de evento, você encontrará informações sobre o tipo de evento (mensagem, app_mention, etc.), o texto da mensagem, dados do usuário e informações do canal. { "token": "Jhj5...z412", "team_id": "T061...R6", "api_app_id": "A0PN...2", "event": { "client_msg_id": "92f...d56", "type": "message", "text": "Hey bot, summarize this article for me.", "user": "U214...97", "ts": "167...97", "team": "T061...R6", "channel": "C0PN...L", "event_ts": "167...97", "channel_type": "channel" }, "type": "event_callback", "event_id": "Ev08...6", "event_time": 167...97, "authorizations": [ ... ] } Criação de DTOs para Gestão de Eventos Criaremos uma hierarquia de objetos DTO para separar a validação da estrutura global da solicitação das especificidades do próprio evento. (O envelope DTO para todo o pedido) Este DTO contém os campos gerais para todos os eventos. SlackEvent.php namespace App\DTO\Slack; use Doctrine\Common\Collections\ArrayCollection; use Symfony\Component\Validator\Constraints as Assert; class SlackEvent { #[Assert\NotBlank] #[Assert\Type('string')] public string $token; #[Assert\NotBlank] #[Assert\Type('string')] public string $team_id; #[Assert\Type('string')] #[Assert\Nullable] public ?string $context_team_id; #[Assert\Type('string')] #[Assert\Nullable] public ?string $context_enterprise_id; #[Assert\NotBlank] #[Assert\Type('string')] public string $api_app_id; #[Assert\NotBlank] public SlackEventData $event; #[Assert\NotBlank] #[Assert\Type('string')] public string $type; #[Assert\NotBlank] #[Assert\Type('string')] public string $event_id; #[Assert\NotBlank] #[Assert\Type('integer')] public int $event_time; public ArrayCollection $authorizations; #[Assert\Type('bool')] public bool $is_ext_shared_channel; #[Assert\NotBlank] #[Assert\Type('string')] public string $event_context; public function __construct(){ $this->authorizations = new ArrayCollection(); } public function getToken(): string { return $this->token; } public function getTeamId(): string { return $this->team_id; } public function getContextTeamId(): ?string { return $this->context_team_id; } public function getContextEnterpriseId(): ?string { return $this->context_enterprise_id; } public function getApiAppId(): string { return $this->api_app_id; } public function getEvent(): SlackEventData { return $this->event; } public function getType(): string { return $this->type; } public function getEventId(): string { return $this->event_id; } public function getEventTime(): int { return $this->event_time; } public function getAuthorizations(): ArrayCollection { return $this->authorizations; } public function isIsExtSharedChannel(): bool { return $this->is_ext_shared_channel; } public function getEventContext(): string { return $this->event_context; } } (O DTO para o objeto do evento) Este DTO irá conter os dados específicos para o próprio evento. SlackEventData.php namespace App\DTO\Slack; use Symfony\Component\Validator\Constraints as Assert; class SlackEventData { #[Assert\NotBlank] #[Assert\Type("string")] public string $user; #[Assert\NotBlank] #[Assert\Type("string")] public string $type; #[Assert\NotBlank] #[Assert\Type("string")] public string $ts; #[Assert\NotBlank] #[Assert\Type("string")] public string $client_msg_id; #[Assert\NotBlank] #[Assert\Type("string")] public string $text; #[Assert\NotBlank] #[Assert\Type("string")] public string $team; #[Assert\NotBlank] #[Assert\Type("array")] #[Assert\All([ new Assert\Type("array"), new Assert\Collection([ 'fields' => [ 'type' => [ 'constraints' => [ new Assert\NotBlank(), new Assert\Type("string") ], ], 'block_id' => [ 'constraints' => [ new Assert\NotBlank(), new Assert\Type("string") ], ], 'elements' => [ 'constraints' => [ new Assert\Type("array") ], ], ], ]), ])] public array $blocks; #[Assert\NotBlank] #[Assert\Type("string")] public string $channel; #[Assert\NotBlank] #[Assert\Type("string")] public string $event_ts; #[Assert\NotBlank] #[Assert\Type("string")] public string $channel_type; public function getUser(): string { return $this->user; } public function getType(): string { return $this->type; } public function getTs(): string { return $this->ts; } public function getClientMsgId(): string { return $this->client_msg_id; } public function getText(): string { return $this->text; } public function getTeam(): string { return $this->team; } public function getBlocks(): array { return $this->blocks; } public function getChannel(): string { return $this->channel; } public function getEventTs(): string { return $this->event_ts; } public function getChannelType(): string { return $this->channel_type; } public function getTsDateTime(): \DateTimeImmutable{ // Separate seconds and microseconds list($seconds, $microseconds) = explode('.', $this->getTs()); // Convert to DateTime with microseconds $dateTime = (new \DateTime())->setTimestamp($seconds); $dateTime->modify("+$microseconds microseconds"); return \DateTimeImmutable::createFromMutable($dateTime); } } (O DTO para a recolha de autorizações) Este DTO conterá os dados específicos para a recolha de autorizações. SlackEventAuthorization.php namespace App\DTO\Slack; use Symfony\Component\Validator\Constraints as Assert; class SlackEventAuthorization { #[Assert\Type('string')] #[Assert\Nullable] public ?string $enterprise_id; #[Assert\NotBlank] #[Assert\Type('string')] public string $team_id; #[Assert\NotBlank] #[Assert\Type('string')] public string $user_id; #[Assert\NotBlank] #[Assert\Type('bool')] public bool $is_bot; #[Assert\NotBlank] #[Assert\Type('bool')] public bool $is_enterprise_install; public function getEnterpriseId(): ?string { return $this->enterprise_id; } public function getTeamId(): string { return $this->team_id; } public function getUserId(): string { return $this->user_id; } public function isIsBot(): bool { return $this->is_bot; } public function isIsEnterpriseInstall(): bool { return $this->is_enterprise_install; } } Utilizamos três DTOs para separar a validação. Valida a estrutura geral da solicitação, enquanto Valida o conteúdo do objeto de evento e Validação da autorização de coleta. SlackEvent SlackEventData SlackEventAuthorization Se no futuro quisermos lidar com outro tipo de evento (por exemplo, app_mention ou reaction_added), simplesmente criamos um novo DTO para esse tipo de evento e o usamos para validação. Com esses DTOs, nosso controlador será capaz de receber e validar mensagens de forma confiável do Slack, o que é um passo crítico na construção da nossa empresa. “ .” Agente Proativo Agente Proativo Agente Proativo Criando um Custom Denormalizer Na sua configuração padrão, o Symfony Serializer não pode deserializar automaticamente objetos complexos, Para mapear corretamente a matriz de objetos de autorização da carga útil do Slack em nosso DTO, precisamos de um desnormalizador personalizado. SlackEventAuthorization Um denormalizador é um componente que converte dados estruturados (como uma matriz ou um objeto JSON) em um objeto PHP. O serializador padrão pode lidar com propriedades simples, mas não sabe como lidar com estruturas complexas como uma matriz de DTOs personalizados aninhados dentro de outro DTO. Ao criar um denormalizador personalizado, dizemos explicitamente ao serializador como mapear os dados de entrada para o nosso objeto específico. namespace App\Serializer\Denormalizer; use App\DTO\Slack\SlackEvent; use App\DTO\Slack\SlackEventAuthorization; use Symfony\Component\Serializer\Normalizer\DenormalizerInterface; use Symfony\Component\Serializer\Normalizer\ObjectNormalizer; class SlackEventDenormalizer implements DenormalizerInterface { private ObjectNormalizer $normalizer; public function __construct(ObjectNormalizer $normalizer) { $this->normalizer = $normalizer; } public function denormalize($data, string $type, string $format = null, array $context = []): mixed { $entity = $this->normalizer->denormalize($data, SlackEvent::class, $format, $context); if (isset($data['authorizations']) && is_array($data['authorizations'])) { foreach ($data['authorizations'] as $authorizationData) { $authorization = $this->normalizer->denormalize($authorizationData, SlackEventAuthorization::class, $format, $context); $entity->getAuthorizations()->add($authorization); } } return $entity; } public function supportsDenormalization($data, string $type, string $format = null, array $context = []): bool { return $type === SlackEvent::class; } public function getSupportedTypes(?string $format): array { return [SlackEvent::class => true]; } } Controlador atualizado para vários tipos de eventos Agora estamos prontos para modificar nosso controlador de webhook para lidar com dois tipos de eventos: url_verification e notificações de eventos. vamos atualizar o controlador para usar uma declaração de switch para rotear as solicitações com base no campo de tipo na carga útil, tornando nosso único ponto final flexível e robusto. O controlador atualizado verificará o tipo da carga útil JSON de entrada. Se for um pedido de verificação de URL, ele executará a validação que já configuramos. Se for um event_callback, ele começará o processo de processamento do evento Slack real. namespace App\DTO; class SlackMessage extends MailMessage implements DataCollectionItemInterface { } namespace App\Controller; use App\DTO\DataCollection; use App\DTO\Slack\SlackEvent; use App\DTO\Slack\SlackUrlValidationRequest; use App\DTO\SlackMessage; use App\Message\Command\AIAgentSummarizeMessage; use Symfony\Component\HttpFoundation\JsonResponse; use Symfony\Component\HttpFoundation\Request; use Symfony\Component\HttpFoundation\Response; use Symfony\Component\HttpKernel\Exception\BadRequestHttpException; use Symfony\Component\Messenger\Envelope; use Symfony\Component\Messenger\MessageBusInterface; use Symfony\Component\Routing\Attribute\Route; use Symfony\Component\Serializer\SerializerInterface; use Symfony\Component\Validator\Validator\ValidatorInterface; class WebhookController { #[Route('/webhook/slack', name: 'webhookSlack')] public function __invoke(Request $request, ValidatorInterface $validator, SerializerInterface $serializer, MessageBusInterface $messageBus ): JsonResponse { $data = json_decode($request->getContent(), true); if ($data === null) { throw new BadRequestHttpException('Invalid JSON.'); } $dtoClass = SlackUrlValidationRequest::class; if (array_key_exists('type', $data) && $data['type'] === 'event_callback') { $dtoClass = SlackEvent::class; } $dto = $serializer->denormalize($data, $dtoClass); $errors = $validator->validate($dto); if (count($errors) > 0) { $errorMessages = []; foreach ($errors as $error) { $errorMessages[] = $error->getPropertyPath() . ': ' . $error->getMessage(); } return new JsonResponse(['errors' => $errorMessages], Response::HTTP_BAD_REQUEST); } switch (get_class($dto)) { case SlackUrlValidationRequest::class: return new JsonResponse($dto->getChallenge()); case SlackEvent::class : $emailCollection = new DataCollection( new SlackMessage( 'New Slack message', $dto->getEvent()->getUser(), $dto->getEvent()->getTeam(), $dto->getEvent()->getText(), $dto->getEvent()->getTs(), $dto->getEvent()->getClientMsgId() ) ); $messageBus->dispatch( new Envelope( new AIAgentSummarizeMessage( $emailCollection, 'I have slack message. Please summarize it into a concise overview (100-150 words) focusing on key decisions, action items, and deadlines. Here’s the slack message content:' ) ) ); break; } return new JsonResponse(['status' => 'ok'], Response::HTTP_OK); } } Aproveitando a herança para um fluxo de trabalho unificado Criamos uma nova A família que herdou de Esta é uma decisão de design significativa que nos permite enviar mensagens Slack para o nosso bus de mensagens para processamento assíncrono padrão pelo nosso Usando o fluxo de trabalho existente. SlackMessage mensagem O agente mensagem mensagem O agente O agente Por extensão , a classe SlackMessage se conforma automaticamente ao mesmo contrato de mensagens exigido pelo nosso bus de mensagens e Isso significa que não precisamos construir um novo tubo de processamento separado para o Slack. Em vez disso, podemos simplesmente passar uma instância do SlackMessage para o bus, e o sistema irá tratá-lo como um e-mail normal. mensagem O agente mensagem O agente Agora que nosso código está completo, estamos prontos para implantar e executar nosso aplicativo. Para isso, utilizamos uma abordagem containerizada. , que simplifica o processo de gerenciamento tanto do nosso aplicativo Symfony quanto de suas dependências, como um banco de dados ou corretor de mensagens. Agente Proativo Docker Composição Agente Proativo Docker Composição CONCLUSÃO O A classe contém dados específicos do Slack, mas herda as propriedades principais necessárias para o nosso agente, como o conteúdo da mensagem. SlackMessage Agora podemos enviar um objeto de SlackMessage para o Symfony Message Bus em um transporte assínctico padrão. O agente de IA, que já está configurado para consumir mensagens do ônibus e processo objetos, pode lidar sem problemas com objetos do SlackMessage sem alterações na sua lógica central. Você pode então usar o conteúdo da mensagem para executar suas tarefas, como resumir ou gerar uma resposta. MailMessage Agente mensagem Agente Esta abordagem é altamente eficiente porque evita a duplicação de código e mantém a arquitetura do nosso sistema limpa e escalável. Pode integrar facilmente novos canais de comunicação, garantindo que todas as mensagens – seja de e-mail ou Slack – sejam processadas através de um único fluxo de trabalho inteligente. Agente Proativo Agente Proativo Em nossos próximos artigos, vamos explorar como simplificar nosso código usando o Esta poderosa ferramenta fornece uma abstração de nível superior para lidar com solicitações de webhook, eliminando a necessidade de alguns dos controladores manuais e lógica de validação que construímos até agora. symfony/webhook Em seguida, vamos mergulhar na criação de um fluxo de trabalho separado e dedicado para gerar respostas automáticas para mensagens Slack. Isso envolverá: Com base em nossa arquitetura existente, vamos projetar um sistema que possa identificar mensagens que exigem uma resposta. Advanced Message Processing: Vamos mostrar como usar um formular respostas inteligentes e contextualmente conscientes. Integrating an LLM: Large Language Model Modelo de Linguagem Grande Finalmente, usaremos um cliente Slack API para enviar a resposta gerada de volta ao usuário, fechando o loop de comunicação e completando nosso ** • Sistema. Sending a Reply: Agente Proativo Agente Proativo Fique atento enquanto continuamos a construir esta poderosa plataforma de comunicação em tempo real.