Desenvolvimento de modelo grande (quatorze): use o modelo OpenAI Chat + API do Google para implementar um aplicativo de IA para envio e recebimento inteligente de e-mails

O texto completo tem um total de mais de 1,2w palavras, e o tempo de leitura esperado é de cerca de 24 a 40 minutos | Cheio de produtos secos (com código), recomenda-se coletar!

O objetivo deste artigo: conectar a API do Gmail ao modelo de bate-papo e escrever um aplicativo de IA que envie e receba e-mails de forma inteligente

Baixe o código clique aqui

1. Fundo

O desenvolvimento de aplicativos de modelo em larga escala começa com o Google Cloud para aprendizagem e desenvolvimento de aplicativos de IA, que é o método com o limite mais baixo e a maior eficiência . O Google Cloud não só possui centenas de APIs para vários aplicativos, mas também possui um sistema de API unificado e um método de gerenciamento de autoridade. O processo de chamada é muito conveniente. Uma conta pode usar um grande número de APIs por meio de autenticação de um projeto, além de desenvolvimento detalhado e completo A documentação do desenvolvedor reduz bastante o limite de uso da API.

Ao mesmo tempo, o Google Cloud é uma plataforma de desenvolvimento de aplicativos com todos os recursos. Se você não apenas tenta usar APIs para exploração inicial, mas deseja concluir o desenvolvimento de aplicativos de nível empresarial no verdadeiro sentido, também pode fazê-lo no Google Cloud . O Google Cloud não apenas fornece um processo completo de desenvolvimento e lançamento de aplicativos on-line, mas também fornece serviços em nuvem (relativamente) baratos e estáveis. Os aplicativos desenvolvidos pelos desenvolvedores podem ser executados diretamente na nuvem e desfrutar de um conjunto completo de emergência e manutenção fornecido pelo Google Cloud Página de monitoramento visual do processo e em tempo real.

Mas um problema real é: ainda existem restrições de acesso na China e é preciso usar magia.O objetivo deste artigo é conectar a API do Gmail ao modelo de bate-papo e escrever um aplicativo de IA que envie e receba e-mails de maneira inteligente.

2. Autorização OAuth da API do Gmail

Primeiramente, o primeiro passo é chamar a API do Google, que deve ser autorizada. A introdução específica do Google Cloud e da biblioteca da API do Google Cloud e como concluir o processo de autorização OAuth da API do Gmail, se você entender, pode pular esta etapa e inserir diretamente o seguinte conteúdo de código. Se você não sabe como operar , veja o link abaixo:

A implementação bem-sucedida do processo de autorização OAuth da API do Gmail é muito importante. Use outras APIs do Google Cloud para criar aplicativos de IA mais complexos, a maioria dos quais requer autorização OAuth. Se a autorização for concluída, as credenciais também poderão ser aplicadas a outros Para chamadas de API, a autorização também é um pré-requisito para o desenvolvimento de aplicativos de IA.

Desenvolvimento de aplicativos de IA: como a API do Gmail implementa a autorização OAuth

3. Crie um aplicativo inteligente de envio e recebimento de e-mail com a ajuda da API do Gmail

3.1 Adicionar a função de verificação de e-mails no modelo Chat

Primeiro tente conectar a API do Gmail ao modelo Chat . Nestes três artigos:

Desenvolvimento de modelo grande (11): explicação detalhada da função de chamada de função do modelo Chat Completions

Desenvolvimento de modelo grande (12): Otimização do processo de chamada de função e realização de múltiplas rodadas de tarefas de diálogo

Desenvolvimento de modelo grande (treze): Chamada de função chama API de ferramenta externa para realizar consultas meteorológicas em tempo real

O processo otimizado de execução da função de chamada de função foi executado. Para o desenvolvimento de uma aplicação de IA, após determinar o objetivo de realizar as funções básicas, ele é dividido em quatro etapas:

1. Teste se a funcionalidade da função externa é viável
2. Verifique se o modelo de linguagem grande tem a capacidade de interpretar os resultados de funções externas e traduzir com precisão os parâmetros de funções externas
3. Com base nisso, crie funções externas que possam chamar APIs de ferramentas externas e escreva descrições de funções muito detalhadas
4. Traga a função externa definida para a função run_conversation ou função chat_with_model para testar o efeito do diálogo.

Então, primeiro tente dotar o modelo de Chat com a função de visualizar o último e-mail por meio de uma função externa. O processo de implementação específico é o seguinte:

• Etapa 1: testar a viabilidade de funções externas

Primeiro teste se você pode verificar as informações mais recentes do e-mail chamando a API do Gmail, incluindo o remetente, a data e o conteúdo do e-mail. O código é o seguinte:

# 从本地文件中加载凭据
creds = Credentials.from_authorized_user_file('token.json')

# 创建 Gmail API 客户端
service = build('gmail', 'v1', credentials=creds)

# 列出用户的一封最新邮件
results = service.users().messages().list(userId='me', maxResults=1).execute()
messages = results.get('messages', [])

# 遍历邮件
for message in messages:
    # 获取邮件的详细信息
    msg = service.users().messages().get(userId='me', id=message['id']).execute()

    # 获取邮件头部信息
    headers = msg['payload']['headers']

    # 提取发件人、发件时间
    From, Date = "", ""
    for h in headers:
        name = h['name']
        if name.lower() == 'from':
            From = h['value']
        if name.lower() == 'date':
            Date = h['value']

    # 提取邮件正文
    if 'parts' in msg['payload']:
        part = msg['payload']['parts'][0]
        if part['mimeType'] == 'text/plain':
            data = part['body']["data"]
        else:
            data = msg['payload']['body']["data"]
    else:
        data = msg['payload']['body']["data"]
        
    data = data.replace("-","+").replace("_","/")
    decoded_data = base64.b64decode(data)
    str_text = str(decoded_data, "utf-8")
    msg_str = email.message_from_string(str_text)

    if msg_str.is_multipart():
        text = msg_str.get_payload()[0]  
    else:
        text = msg_str.get_payload()
    
    print('From: {}'.format(From[:8]))
    print('Date: {}'.format(Date))
    print('Content: {}'.format(text))

Veja a saída:

Verifique o status do seu e-mail:

O processo principal do código acima é obter as informações do e-mail mais recente por meio de service.users().messages().list(userId='me', maxResults=1).execute() e, finalmente, mantê-las em msg .

Para obter mais informações sobre os resultados retornados pela API do Gmail, consulte a introdução da função no site oficial da API do Gmail: https://developers.google.com/gmail/api/guides

• Etapa 2: verifique se o modelo pode interpretar os resultados retornados pela API do Gmail

Quando a API do Gmail não processa, o resultado retornado é o seguinte:

Incluindo várias informações detalhadas, como informações do remetente, horário de recebimento e informações de texto de e-mail. Para satisfazer mais respostas a diferentes perguntas, deixe o modelo de bate-papo interpretar os resultados da mensagem diretamente e teste se o modelo de bate-papo está familiarizado com a API do Gmail. através do seguinte processo A interpretação da função e seu resultado de retorno, o código é o seguinte:

import os
import openai
openai.api_key = os.getenv("OPENAI_API_KEY")

response = openai.ChatCompletion.create(
  model="gpt-4-0613",
  messages=[
    {
    
    "role": "system", "content": "这是我的Gmail邮箱最近一封邮件的内容：%s" % msg},
    {
    
    "role": "system", "content": "邮件内容是由Gmail API获取"},
    {
    
    "role": "user", "content": "请问我的Gmail最近一封邮件是谁发送的，具体内容是什么？"}
  ]
)
response.choices[0].message['content']

Veja a saída:

O modelo Chat consegue entender muito bem as informações contidas na mensagem. Então, ao projetar o processo de comunicação entre a função externa e o modelo de bate-papo, a função externa pode enviar diretamente o resultado da mensagem para o modelo de linguagem grande.

• Etapa 3: crie uma função externa

De acordo com o fluxo de código na Etapa 1, crie um objeto msg que possa retornar as informações de e-mail mais recentes e produza-as no formato JSON:

def get_latest_email(userId):
    """
    查询Gmail邮箱中最后一封邮件信息
    :param userId: 必要参数，字符串类型，用于表示需要查询的邮箱ID，\
    注意，当查询我的邮箱时，userId需要输入'me'；
    :return：包含最后一封邮件全部信息的对象，该对象由Gmail API创建得到
    """
    # 从本地文件中加载凭据
    creds = Credentials.from_authorized_user_file('token.json')
    
    # 创建 Gmail API 客户端
    service = build('gmail', 'v1', credentials=creds)
    
    # 列出用户的一封最新邮件
    results = service.users().messages().list(userId=userId, maxResults=1).execute()
    messages = results.get('messages', [])

    # 遍历邮件
    for message in messages:
        # 获取邮件的详细信息
        msg = service.users().messages().get(userId='me', id=message['id']).execute()
        
    return json.dumps(msg)

functions_list = [get_latest_email]

Depois de escrever a função, para garantir que a função de diálogo final possa funcionar sem problemas, primeiro teste manualmente se auto_functions pode escrever corretamente o parâmetro de funções de acordo com a descrição da função e teste se o modelo de bate-papo pode reconhecer corretamente os requisitos de formato das funções parâmetro e interpretar as necessidades do usuário sem problemas. E traduzido na forma de parâmetro que a função pode aceitar, primeiro introduza o parâmetro de funções para escrever automaticamente a função:

def auto_functions(functions_list):
    """
    Chat模型的functions参数编写函数
    :param functions_list: 包含一个或者多个函数对象的列表；
    :return：满足Chat模型functions参数要求的functions对象
    """
    def functions_generate(functions_list):
        # 创建空列表，用于保存每个函数的描述字典
        functions = []
        
        def chen_ming_algorithm(data):
            """
            陈明算法函数，该函数定义了一种特殊的数据集计算过程
            :param data: 必要参数，表示带入计算的数据表，用字符串进行表示
            :return：陈明函数计算后的结果，返回结果为表示为JSON格式的Dataframe类型对象
            """
            df_new = pd.read_json(data)
            res = np.sum(df_new, axis=1) - 1
            return res.to_json(orient='records')
        
        chen_ming_function_description = inspect.getdoc(chen_ming_algorithm)
        
        chen_ming_function_name = chen_ming_algorithm.__name__
        
        chen_ming_function = {
    
    "name": "chen_ming_algorithm",
                              "description": "用于执行陈明算法的函数，定义了一种特殊的数据集计算过程",
                              "parameters": {
    
    "type": "object",
                                             "properties": {
    
    "data": {
    
    "type": "string",
                                                                     "description": "执行陈明算法的数据集"},
                                                           },
                                             "required": ["data"],
                                            },
                             }

        
        # 对每个外部函数进行循环
        for function in functions_list:
            # 读取函数对象的函数说明
            function_description = inspect.getdoc(function)
            # 读取函数的函数名字符串
            function_name = function.__name__

            user_message1 = '以下是某函数说明：%s。' % chen_ming_function_description +\
                            '根据这个函数的函数说明，请帮我创建一个function对象，用于描述这个函数的基本情况。这个function对象是一个JSON格式的字典，\
                            这个字典有如下5点要求：\
                            1.字典总共有三个键值对；\
                            2.第一个键值对的Key是字符串name，value是该函数的名字：%s，也是字符串；\
                            3.第二个键值对的Key是字符串description，value是该函数的函数的功能说明，也是字符串；\
                            4.第三个键值对的Key是字符串parameters，value是一个JSON Schema对象，用于说明该函数的参数输入规范。\
                            5.输出结果必须是一个JSON格式的字典，只输出这个字典即可，前后不需要任何前后修饰或说明的语句' % chen_ming_function_name
            
            
            assistant_message1 = json.dumps(chen_ming_function)
            
            user_prompt = '现在有另一个函数，函数名为：%s；函数说明为：%s；\
                          请帮我仿造类似的格式为当前函数创建一个function对象。' % (function_name, function_description)

            response = openai.ChatCompletion.create(
                              model="gpt-4-0613",
                              messages=[
                                {
    
    "role": "user", "name":"example_user", "content": user_message1},
                                {
    
    "role": "assistant", "name":"example_assistant", "content": assistant_message1},
                                {
    
    "role": "user", "name":"example_user", "content": user_prompt}]
                            )
            functions.append(json.loads(response.choices[0].message['content']))
        return functions
    
    max_attempts = 3
    attempts = 0

    while attempts < max_attempts:
        try:
            functions = functions_generate(functions_list)
            break  # 如果代码成功执行，跳出循环
        except Exception as e:
            attempts += 1  # 增加尝试次数
            print("发生错误：", e)
            if attempts == max_attempts:
                print("已达到最大尝试次数，程序终止。")
                raise  # 重新引发最后一个异常
            else:
                print("正在重新运行...")
    return functions

Dê uma olhada nos resultados da execução:

Não há problema em escrever o parâmetro de funções. Em seguida, teste se o modelo de Chat pode criar parâmetros que atendam ao formato com êxito:

response = openai.ChatCompletion.create(
        model="gpt-4-0613",
        messages=[{
    
    "role": "user", "content": '请帮我查下我Gmail邮箱中最后一封邮件信息'}],
        functions=functions,
        function_call="auto",  
    )

Veja os resultados:

• Passo 4: Verifique o efeito do diálogo

Finalmente, para testar o efeito do diálogo, ainda importe a função do modelo de diálogo de bate-papo e a função de diálogo multi-round escrita antes que execute automaticamente chamadas de função externa :

def run_conversation(messages, functions_list=None, model="gpt-4-0613"):
    """
    能够自动执行外部函数调用的Chat对话模型
    :param messages: 必要参数，字典类型，输入到Chat模型的messages参数对象
    :param functions_list: 可选参数，默认为None，可以设置为包含全部外部函数的列表对象
    :param model: Chat模型，可选参数，默认模型为gpt-4
    :return：Chat模型输出结果
    """
    # 如果没有外部函数库，则执行普通的对话任务
    if functions_list == None:
        response = openai.ChatCompletion.create(
                        model=model,
                        messages=messages,
                        )
        response_message = response["choices"][0]["message"]
        final_response = response_message["content"]
        
    # 若存在外部函数库，则需要灵活选取外部函数并进行回答
    else:
        # 创建functions对象
        functions = auto_functions(functions_list)
        # 创建外部函数库字典
        available_functions = {
    
    func.__name__: func for func in functions_list}

        # first response
        response = openai.ChatCompletion.create(
                        model=model,
                        messages=messages,
                        functions=functions,
                        function_call="auto")
        response_message = response["choices"][0]["message"]

        # 判断返回结果是否存在function_call，即判断是否需要调用外部函数来回答问题
        if response_message.get("function_call"):
            # 需要调用外部函数
            # 获取函数名
            function_name = response_message["function_call"]["name"]
            # 获取函数对象
            fuction_to_call = available_functions[function_name]
            # 获取函数参数
            function_args = json.loads(response_message["function_call"]["arguments"])
            # 将函数参数输入到函数中，获取函数计算结果
            function_response = fuction_to_call(**function_args)

            # messages中拼接first response消息
            messages.append(response_message)  
            # messages中拼接函数输出结果
            messages.append(
                {
    
    
                    "role": "function",
                    "name": function_name,
                    "content": function_response,
                }
            )  
            # 第二次调用模型
            second_response = openai.ChatCompletion.create(
                model=model,
                messages=messages,
            )  
            # 获取最终结果
            final_response = second_response["choices"][0]["message"]["content"]
        else:
            final_response = response_message["content"]
    
    return final_response

def chat_with_model(functions_list=None, 
                    prompt="你好呀", 
                    model="gpt-4-0613", 
                    system_message=[{
    
    "role": "system", "content": "你是以为乐于助人的助手。"}]):
    
    messages = system_message
    messages.append({
    
    "role": "user", "content": prompt})
    
    while True:           
        answer = run_conversation(messages=messages, 
                                    functions_list=functions_list, 
                                    model=model)
        
        
        print(f"模型回答: {
      
      answer}")

        # 询问用户是否还有其他问题
        user_input = input("您还有其他问题吗？(输入退出以结束对话): ")
        if user_input == "退出":
            break

        # 记录用户回答
        messages.append({
    
    "role": "user", "content": user_input})

Primeiro teste quando a função externa get_latest_email não é ativada:

Ao testar a função externa get_latest_email:

3.2 Adicionar a função de envio de e-mail no modelo Chat

• Etapa 1: readquirir autorização

O token criado acima, na verdade, inclui apenas a autorização da API para leitura de e-mails, não a autorização da API para envio de e-mails . Portanto, primeiro é necessário modificar as permissões da API, ou seja, solicitar novamente a autorização da API para envio de e-mails do Gmail. Use a parte de autorização anterior do código para executar e salve o arquivo de autorização da permissão de envio no arquivo token_send.json local, o código é o seguinte:

SCOPES = ['https://www.googleapis.com/auth/gmail.send']

flow = InstalledAppFlow.from_client_secrets_file(
                'credentials-web.json', SCOPES)
creds = flow.run_local_server(port=8000, access_type='offline', prompt='consent')

with open('token_send.json', 'w') as token:
    token.write(creds.to_json())

Se você não sabe como autorizar aqui, consulte a parte de autorização OAuth da API do Gmail

**Uma API (classe) na API do Google Cloud será dividida em múltiplas autorizações de acordo com diferentes funções da API quando usada. **A diferença está na configuração da variável SCOPES. SCOPES é uma lista contendo vários endereços, e cada endereço representa o endereço de envio de diferentes solicitações. Em outras palavras, representa diferentes permissões de API. A cauda do endereço é gmail. send indica a API para envio de e-mails e gmail.readonly no final indica que apenas e-mails podem ser lidos. Para funções específicas da API, consulte a descrição oficial: https://developers.google.com/gmail/api/auth/scopes?hl=zh_CN

Também é possível obter um arquivo de autorização contendo múltiplas permissões ao mesmo tempo. Neste momento, o SCOPES pode ser definido da seguinte forma. Neste momento, o arquivo de autorização pode permitir que arquivos de execução sejam lidos e enviados ao mesmo tempo:

SCOPES = ['https://www.googleapis.com/auth/gmail.send','https://www.googleapis.com/auth/gmail.readonly']

• Etapa 2: testar a função de envio

Depois de concluir a autorização, você pode usar a função de envio do Gmail. Altere o arquivo de autorização para token_send.json. O processo específico de implementação do código é o seguinte:

from googleapiclient.discovery import build
from google.oauth2.credentials import Credentials
from email.mime.text import MIMEText
import base64

# 从本地文件中加载凭据
creds = Credentials.from_authorized_user_file('token_send.json')

# 创建 Gmail API 客户端
service = build('gmail', 'v1', credentials=creds)

def create_message(sender, to, subject, message_text):
    """创建一个MIME邮件"""
    message = MIMEText(message_text)
    message['to'] = to
    message['from'] = sender
    message['subject'] = subject
    raw_message = base64.urlsafe_b64encode(message.as_string().encode('utf-8')).decode('utf-8')
    return {
    
    
        'raw': raw_message
    }

def send_message(service, user_id, message):
    """发送邮件"""
    try:
        sent_message = service.users().messages().send(userId=user_id, body=message).execute()
        print(f'Message Id: {
      
      sent_message["id"]}')
        return sent_message
    except Exception as e:
        print(f'An error occurred: {
      
      e}')
        return None

# 创建邮件，发件人、收件邮箱、邮件主题和邮件内容
message = create_message('me', '[email protected]', '测试', '测试Gmail API 的邮件发送功能')

# 发送邮件
send_message(service, 'me', message)

Veja os resultados:

MIME (Multipurpose Internet Mail Extensions, Multipurpose Internet Mail Extensions) é um padrão da Internet que estende a especificação de e-mail original (que só pode lidar com texto ASCII) para permitir que o e-mail suporte outros tipos de dados, como texto (incluindo caracteres não ASCII) , imagens, áudio, vídeo e dados de aplicativos .

Em Python, o módulo email.mime fornece classes para criar e modificar mensagens MIME. Essas classes permitem a criação de mensagens de correio complexas contendo vários tipos de dados, incluindo texto, HTML, anexos, imagens incorporadas e muito mais. Você pode visualizar o objeto de mensagem criado:

Você também pode chamar a API do Gmail enviando_message = service.users().messages().send(userId=user_id, body=message).execute().

Verifique seu e-mail para recebimento:

• Etapa 3: Encapsular funções externas que podem ser chamadas pelo modelo Chat

def send_email(to, subject, message_text):
    """
    借助Gmail API创建并发送邮件函数
    :param to: 必要参数，字符串类型，用于表示邮件发送的目标邮箱地址；
    :param subject: 必要参数，字符串类型，表示邮件主题；
    :param message_text: 必要参数，字符串类型，表示邮件全部正文；
    :return：返回发送结果字典，若成功发送，则返回包含邮件ID和发送状态的字典。
    """
    
    creds_file='token_send.json'
    
    def create_message(to, subject, message_text):
        """创建一个MIME邮件"""
        message = MIMEText(message_text)
        message['to'] = to
        message['from'] = 'me'
        message['subject'] = subject
        raw_message = base64.urlsafe_b64encode(message.as_string().encode('utf-8')).decode('utf-8')
        return {
    
    
            'raw': raw_message
        }

    def send_message(service, user_id, message):
        """发送邮件"""
        try:
            sent_message = service.users().messages().send(userId=user_id, body=message).execute()
            print(f'Message Id: {
      
      sent_message["id"]}')
            return sent_message
        except Exception as e:
            print(f'An error occurred: {
      
      e}')
            return None

    # 从本地文件中加载凭据
    creds = Credentials.from_authorized_user_file(creds_file)

    # 创建 Gmail API 客户端
    service = build('gmail', 'v1', credentials=creds)

    message = create_message(to, subject, message_text)
    res = send_message(service, 'me', message)

    return json.dumps(res)

• Etapa 3: teste o parâmetro de funções

functions = auto_functions(functions_list)
functions

Não há problema com a criação do parâmetro de funções. Teste ainda mais se o modelo de Chat pode criar com êxito os parâmetros necessários da função:

response = openai.ChatCompletion.create(
        model="gpt-4-0613",
        messages=[{
    
    "role": "user", "content": '我想发送一个Gmail邮件，主要内容是：让小陈明天早上9点半来我办公室开会，商量一下我的100亿该怎么花'}],
        functions=functions,
        function_call="auto"
    )

response

Veja os resultados retornados:

O modelo cria o assunto e o conteúdo do email semanticamente

• Etapa 4: verificação de diálogo multi-rodada

Observe o processamento do modelo sem chamar a função externa send_email e ao chamar send_email:

Em seguida, verifique o e-mail recebido na caixa de correio:

Até o momento, a função de envio de e-mail está totalmente integrada ao modelo Chat.

3.3 Chamar simultaneamente as funções de envio de e-mail e consulta no modelo Chat

Depois de executar a função de envio de e-mail separadamente, você pode tentar chamar essas duas funções ao mesmo tempo em uma caixa de diálogo . Afinal, a maioria dos aplicativos de IA são coleções multifuncionais em torno de um determinado aspecto do aplicativo. Por exemplo, para um aplicativo de IA de um assistente de e-mail inteligente, receber e enviar e-mails devem ser os requisitos funcionais mais básicos.

Para integrar as funções de recebimento e envio em um modelo de Chat, você só precisa adicionar get_latest_email e send_email ao function_list ao mesmo tempo , o código é o seguinte:

functions_list = [get_latest_email, send_email]

chat_with_model(functions_list=functions_list,
                system_message=[{
    
    "role": "system", "content": "小陈的邮箱地址是：[email protected]"}]

Veja os resultados:

Até o momento, as funções de envio e recebimento foram chamadas simultaneamente em uma conversa de Chat.

Quatro. Resumo

Através da prática acima, pode-se descobrir que à medida que mais e mais APIs de ferramentas externas são integradas no modelo de Chat, todo o aplicativo parecerá mais inteligente. Na verdade, este é realmente o caso: no processo de desenvolvimento de aplicativos de IA com a ajuda da chamada de função, o escopo funcional da biblioteca de funções externas é a chave para determinar se o aplicativo de IA atual é "inteligente".

Mas, na verdade, você precisa pensar em um problema: o processo de criação de uma função externa que inclui uma API de ferramenta externa não é simples . Por um lado, são necessárias repetidas tentativas para obter as permissões de API correspondentes. Por outro lado, também precisa ter um certo conhecimento de chamadas de API para escrever sem problemas.Código de função externa. Apenas para criar um aplicativo para enviar e receber e-mails inteligentes, muito tempo é gasto em métodos de aquisição de API e métodos de escrita de funções.

Mas, na verdade, esse processo de desenvolvimento pode ser simplificado até certo ponto: a ideia central da simplificação é usar IA (modelo de bate-papo) para auxiliar no desenvolvimento de aplicativos de IA .

Finalmente, obrigado por ler este artigo! Se você sente que ganhou algo, não esqueça de curtir, marcar e me seguir, essa é a motivação para minha criação contínua. Se você tiver alguma dúvida ou sugestão, pode deixar uma mensagem na área de comentários, farei o possível para responder e aceitar seus comentários. Se houver um tópico específico que você gostaria de saber, por favor me avise e ficarei feliz em escrever um artigo sobre ele. Obrigado pelo seu apoio e espero crescer com você!