AUTORPONDER AI: A maneira inteligente de gerenciar sua caixa de entrada do Gmail

Com o trabalho e a vida privada se misturando mais do que nunca, o gerenciamento de uma caixa de entrada transbordante pode ser esmagador. Mas e se uma ferramenta pudesse redigir respostas para você, precisando apenas da sua revisão? Conheça a AURESPONDER AI: Um assistente de email sem servidor na AWS que usa a IA para otimizar a comunicação. Este artigo será dividido em que funciona e como pode facilitar o manuseio de e -mails.

O que é o AutorPonder AI?

O AutorPonder AI é um complemento inteligente do Gmail que pode ajudá-lo a gerenciar e-mails e impedir a sobrecarga da caixa de entrada. Ele digitaliza e -mails não lidos, detecta sentimentos e respostas para aqueles que precisam de uma resposta, salvando -os para sua revisão. Depois que os rascunhos estiverem prontos, ele o notifica por e -mail ou SMS, mantendo você atualizado. Construído em um sistema sem servidor seguro e econômico, é ideal para profissionais ocupados, equipes de atendimento ao cliente ou qualquer pessoa que queira permanecer responsiva com menos aborrecimentos.

Por que o automóvel da IA?

• Aumenta a produtividade – automatiza respostas para e -mails não lidos, economizando tempo e esforço.
• Otimiza o gerenciamento de tempo -usa a IA para priorizar e gerar respostas com reconhecimento de contexto.
• Garante segurança – Protege credenciais com gerente de segredos da AWS.
• Melhora a comunicação -Crafts Profissionais e respostas bem estruturadas adaptadas a cada destinatário.

A IA de resposta automática é útil para profissionais de negócios, executivos, equipes de vendas e departamentos de atendimento ao cliente, porque traz o poder da automação orientada à IA ao seu esforço de gerenciamento de caixas de entrada.

Guia passo a passo para desenvolver e implantar a AIPOUNDER AI

#STEP 1: Obtenha credenciais do Gmail OAuth do Google Console

Para acessar o Gmail via API, você precisa de credenciais OAuth do Google Cloud Console.

1. Crie um projeto do Google Cloud

   1. Abra o site do Google Cloud Console -> Selecione Novo Projeto -> Você pode nomeá -lo Gmailautoreply ou o que você escolher -> Clique em Criar.

2. Ativar API do Gmail

   1. Vá para APIs & Services.

   2. Habilite APIs e serviços, procure a API do Gmail e ative -a.

3. Crie credenciais do OAuth

   1. Navegue para APIs & Services -> Credenciais -> Crie credenciais -> ID do cliente OAuth.

   2. Escolha o tipo de aplicativo: aplicativo de desktop e nomeie -o Cliente Lambda Gmail.

   3. Clique em Criar e Download client_secret_xxx.json arquivo.

4. Gerar tokens de acesso e atualização:

   1. Certifique -se de ter as bibliotecas Python corretas instaladas em sua máquina local ::

      pip install google-auth-oauthlib google-api-python-client
      

   2. Use o seguinte script python para gerar tokens (substitua ‘caminho/para/your/client_secret.json’ pelo caminho para o seu arquivo JSON baixado):

   3. Execute este script Python para gerar acesso e atualizar tokens:

      de google_auth_oauthlib.flow importar installedappflow scopes = ['
      
      flow = InstalledAppFlow.from_client_secrets_file(
      
          'path/to/your/client_secret.json', scopes)
      
      credentials = flow.run_local_server(port=0)
      
      print(f"Access Token: {credentials.token}")
      
      print(f"Refresh Token: {credentials.refresh_token}")
      
          
      

   4. When you run the script, It will ask you to log in to your Gmail account and authorize the app in a browser window after  running the script.

   5. Copy the access_token and refresh_token for later use.

   

Step 2: Store Gmail OAuth Credentials in AWS Secrets Manager

To store Gmail credentials securely, use AWS Secrets Manager. To do this, follow these steps:

1. Go to AWS Console and select Secrets Manager.

2. Click on Store a new secret and select Choose  Other Type of secret.

3. Copy and paste the following key-value pairs:

   1. gmail_client_id (from client_secret.json)
   2. gmail_client_secret (from client_secret.json)
   3. access_token (from the Python script)
   4. refresh_token (from the Python script)

4. Click Next, enter the secret  name as GmailOAuthSecrets and click on Store.

5. Remember the Secret ARN which will be used  in Lambda.

Step 3: Create an SNS Topic for Notifications

To notify users when email drafts are created, set up Amazon SNS. To do this, follow these steps:

1. Go to AWS Console and select SNS from the search bar.
2. Choose Standard and then click Create topic.
3. The name of the new topic is EmailDraftsCreated and click Create topic.
4. The Topic ARN is copied for later use.
5. Click Create Subscription, select Protocol and then select Email, and then enter your email and confirm.

Step 4:

Create an IAM Role for Lambda For Lambda to work, it requires permission to work with other AWS services.

1. Go to AWS Console and select IAM from the search.

2. Click on Roles and select Create role, then choose AWS Service and then Lambda.

3. Attach the following policies:

   1. AWSLambdaBasicExecutionRole (for logging)
   2. AmazonSNSFullAccess (for notifications)
   3. SecretsManagerReadWrite (for storing Gmail credentials)
   4. AmazonComprehendFullAccess (for sentiment analysis)
   5. AmazonBedrockFullAccess (For AI generated replies)

4. The role is named as LambdaEmailProcessor and then click create role.

Step 5: Prepare Amazon Amazon Bedrock for the AI Response

First check that Amazon Bedrock is turned on in us-east-1 region.

1. Go to Amazon Bedrock in the AWS Console.

2. In Model Access, enable Amazon Titan Text G1 – Premier or any other model you prefer.

3. Accept the access request.

Step 6: Create and Deploy the AWS Lambda Function

This Lambda function will process emails,  analyze sentiment, generate replies, and save drafts.

1. Navigate to AWS Console; select Lambda from search and Create Function.
2. Choose Author from Scratch, name it “EmailAutoReplyProcessor” and select Python  3.9.
3. Assign the IAM role “LambdaEmailProcessor”.
4. Install required dependencies:

pip install boto3 google-auth-oauthlib google-auth-httplib2 google-api-python-client -t lambda_package/

5. Save the Lambda  code (provided below) as lambda_package/lambda_function.py.

   import json
   import os
   import boto3
   from google.oauth2.credentials import Credentials
   from googleapiclient.discovery import build
   from google.auth.transport.requests import Request
   import base64
   import re
   from googleapiclient.errors import HttpError
   
   # AWS Clients
   secrets_manager = boto3.client('secretsmanager')
   comprehend = boto3.client('comprehend')
   bedrock = boto3.client('bedrock-runtime')
   sns = boto3.client('sns')
   
   def extract_sender_name(sender_email):
       """
       Extracts the sender's name from the email 'From' field.
       Example:
       - 'John Doe <[email protected]> '→' John Doe ' -'[email protected]'→' John '"" "Match = re.match (r' (.+?) \ S*<.*? 'Else: retornar sender_email.split ('@')[0].CAPITILE () # Fallback: Extrair nome de '[email protected]'Def Lambda_Handler (Evento, Contexto): Tente: # Recupere as credenciais do OAuth do AWS Secrets Manager Secret_arn = Os.environ['SECRET_ARN']
           secret = secrets_manager.get_secret_value (secretid = secret_arn) secret_json = json.loads (secreto['SecretString']) creds = credenciais (token = secret_json.get ('access_token'), refresh_token = secret_json['refresh_token']client_id = secret_json['gmail_client_id']client_secret = secret_json['gmail_client_secret'].['access_token'] = creds.token secrets_manager.put_secret_value (secretId = secret_arn, secretString = json.dumps (secret_json)) print ("token atualizado") # build gmail api Service cliente = build ('gmail', v1 ', credents = creds) imprimido ("GMAIL (GMAIL API (' gmail ',' v1 ',) # credes = creds) (" Gmail Service.Users (). Mensagens (). List (UserID = 'Me', LABELIDS =['UNREAD']) .Execute () Mensagens = Results.get ('Mensagens', []) print (f "encontrado {len (mensagens)} e -mails não lidos") se não mensagens: print ("nenhum e -mail não lido encontrado.") Retornar {'statusCode': 200, 'body': 'sem e -mails não lidos'} Drafts_created = 0 para msg em mensagens: message.users (). ().['id']formato = 'completo'). Execute () cabeçalhos = {h['name']: h['value'] para h em mensagem['payload']['headers']} sujeito = headers.get ('sujeito', 'sem sujeito') remetente = headers.get ('de', 'remetente desconhecido') # Extrair nome do remetente sender_name = extract_sender_name (remetente) print (f "Nome do remetente extraído: {sester_name}) body_data =['payload'].get('body', {}).get('data', '') text = base64.urlsafe_b64decode(body_data).decode('utf-8', errors='ignore') if body_data else message.get('snippet', '') print(f"Processing email from {sender}: {subject}") print(f"Email content: ware[:5000]LanguageCode = 'EN') sentimento = Sentiment_Response['Sentiment']
               print (f "Sentimento: {sentimento}") se sentimento em ['POSITIVE', 'NEGATIVE']: # Prompt de AI aprimorado para o modelo titan prompt = f "" "Você é um assistente de e -mail da IA, elaborando uma resposta profissional a um email não lido recebido pelo usuário. Você está respondendo como o destinatário do email para o remetente, cujo nome é '{sester_name}'. ** Regras: ** - Manter um **, formal e profissional **. (Por exemplo, 'Dear {Sender_name}') ou fechamento (por exemplo, 'Atenciosamente') - Focalize apenas o corpo da resposta. {sujeito} conteúdo: --- {texto[:1000]} --- ** Rascunhe o corpo da resposta: ** "" "Tente: # Invoque a Amazon Bedrock Bedrock_Response = Bedrock.invoke_model (modelId = 'Amazon.titan-text-lite-V1', Body = JSON.DUMPS (" InputText ": Pott," TextGeNconfig " "Topp": 0.9}})) Responder_body = json.loads (Bedrock_Response['body'].ler())['results'][0]['outputText'].strip () imprimir (f "gerado ai Responder: {reply_body}"), exceto exceção como e: print (f "error de cama: {str (e)}") Aumente # Verifique qualquer saudação ou fechamento na resposta da AI (insensível com o caso) [f"dear {sender_name.lower()}", f"hello {sender_name.lower()}", f"hi {sender_name.lower()}", "dear", "hello", "hi"]
                   Closing_patterns = ["best regards", "sincerely", "kind regards", "thank you", "regards"]
                   Responder_has_greeting = qualquer (padrão em Responder_body_lower para o padrão em greeting_patterns) Responder_has_closing = qualquer (padrão em Responder_body_lower para padrão em fechamento_patterns) # Adicione a saudação e fechamento apenas se não estiver em falta, se não responde_has_greet: ic \ \ {{severy apenas {sever Responder_has_closing: Responder_body += "\ n \ nBest Atenciosamente, \ nyour Name" Tente: # Crie um rascunho de email draft_message = f "para: {remetente} \ nsubject: re: {sujeito} \ n \ n {reply_body}" draft = {'' ': {{{' ': base64.urlsafe_b64Encode (draft_message.encode ('utf-8')). decode ('utf-8')}} print (f "criando draft: {draft_message}") service.Users (). Httperror como e: print (f "Criação do rascunho falhou: {e}") # Envie a notificação do SNS se Drafts_created> 0: ss.publish (tópica = os.environ['SNS_TOPIC_ARN']Message = f "{Drafts_created} novos rascunhos de e -mail criados. Revise no Gmail." Print ("SNS Notification enviado") retornar {'StatusCode': 200, 'Body': f'proceded {len (mensagens)} emails, criado {drafts_created} rascunhos '} exceto httperror como erro: imprimir (f "gmail API Error: {Error}) Return {' status 'Satadico' ': 5: 5: {error} '}, exceto exceção como e: print (f "error: {str (e)}") return {' statusCode ': 500,' body ': f'an Erro ocorreu: {str (e)}'}
   

6. Implante o código:

   1. Compactar/zip a pasta Lambda_package:

      cd lambda_package
      zip -r ../lambda_function.zip .
      

   2. No console Lambda, selecione a guia Código, clique no upload e selecione Arquivo .zip e faça o upload lambda_function.zip.

7. Definir variáveis ​​de ambiente:

   1. Vá para a configuração; Selecione variáveis ​​de ambiente e clique em Editar.

   2. Adicione os seguintes valores:
      Secret_arn: seu gerente de segredos Arn (da etapa 2)

      SNS_TOPIC_ARN: seu tópico SNS ARN (da etapa 3)

   3. Clique no botão Salvar.

8. Defina o tempo limite:
   Em Configuração, selecione a configuração geral e clique no botão Editar, em seguida, defina o tempo limite para 5 minutos para acomodar o processamento de vários e -mails.

Etapa 7: Aprenda a executar a execução do fluxo de trabalho usando a Amazon Eventbridge

1. Vá para o AWS Console e selecione EventBridge e crie a regra.
2. Nomeie-o como cocô de Gmail-Autoreply.
3. Para expressão de cronograma, coloque: taxa (2 horas)
4. Para alvos, escolha Função Lambda e selecione emailAutoreplyProcessor.
5. Clique em Criar regra.

Etapa 8: revise o rascunho e envie e -mails no Gmail

Revise as saídas finais da AI AutoPonder AI em sua conta do Gmail no final do processo.

• Faça login na sua conta do Gmail.
• Vá para a pasta dos rascunhos.
• Leia cada um dos rascunhos gerados pela IA, faça as alterações necessárias e envie cada um quando terminar.

O que você construiu

Essas etapas foram verificadas e você criou com sucesso o AutorPonder AI, um assistente de email baseado em IA que:

• Ele verifica sua caixa de entrada do Gmail a cada duas horas para novas mensagens que não são lidas.
• Utiliza a Amazon compreende determinar o sentimento desses e -mails.
• Para editar e -mails que precisam de sua atenção, ele prepara respostas profissionais com a ajuda da Amazon Bedrock.
• Ele também organiza os rascunhos para você no Gmail.
• Ele informa você através do Amazon SNS quando há novos rascunhos.

Esta é uma solução sem servidor segura, econômica e totalmente personalizável. Obtenha uma maneira melhor e mais eficiente de trabalhar com e -mails com a AUTRESPONDER AI!

Aproveitar!