Discord

Discord é uma plataforma de comunicação versátil inicialmente projetada para gamers, mas que desde então expandiu seu apelo para uma gama mais ampla de comunidades e grupos online. Ele oferece um rico conjunto de recursos destinados a promover a interação e construir comunidades através de comunicação por texto, voz e vídeo.

Principais Recursos do Discord:- Servidores e Canais:

Servidores: Os servidores do Discord são como centros comunitários individuais onde grupos de pessoas podem se reunir para se comunicar e compartilhar conteúdo. Cada servidor pode ser subdividido em vários canais.
Canais: Estas são áreas específicas dentro de um servidor designadas para tópicos ou tipos de interação específicos. Os canais podem ser baseados em texto ou voz, e os administradores do servidor podem criar vários canais para organizar as discussões de forma eficaz.
Comunicação por Voz e Vídeo:
Os usuários podem entrar em canais de voz onde podem falar com outros usando seu microfone, compartilhar sua tela ou até mesmo fazer videochamadas. Este recurso é particularmente popular entre os jogadores para coordenar atividades no jogo, mas também é usado para reuniões virtuais, aulas ao vivo e bate-papos de voz casuais.
Mensagens de Texto:
Canais de texto permitem que os usuários se comuniquem por meio de mensagens digitadas. Esses canais suportam formatação de texto rico, mensagens diretas, menções e mídia incorporada (imagens, vídeos e links).
Integração e Bots:
O Discord suporta integração com outros serviços como Spotify, Twitch e muitos serviços de jogos, aprimorando a experiência do usuário ao permitir atividades como streaming de música, compartilhamento de estatísticas de jogos ou transmissão de jogabilidade ao vivo.
Bots são outro recurso poderoso do Discord, que podem automatizar tarefas, gerenciar atividades do servidor ou até mesmo adicionar elementos interativos divertidos para os usuários.
Cargos e Permissões:
O Discord permite uma personalização extensiva de cargos e permissões de usuários dentro de um servidor. Administradores podem atribuir cargos com permissões específicas que controlam quem pode acessar certos canais, modificar configurações do servidor ou gerenciar outros usuários.
Segurança e Privacidade:
O Discord oferece controles de privacidade robustos e recursos de segurança, incluindo autenticação de dois fatores, ferramentas de moderação e a capacidade de controlar quem pode enviar mensagens diretas ou adicioná-lo como amigo.
Uso Multiplataforma:
O Discord é acessível através de aplicativos de desktop para Windows, macOS e Linux, aplicativos móveis para Android e iOS, e também pode ser executado diretamente em navegadores da web, tornando-o amplamente acessível.

OpenAI

OpenAI é uma organização de pesquisa em inteligência artificial que visa promover e desenvolver IA amigável de forma a beneficiar a humanidade como um todo. Fundada em dezembro de 2015 por Elon Musk, Sam Altman e outros, a OpenAI inicialmente começou como uma entidade sem fins lucrativos, mas depois formou um braço com fins lucrativos limitados para atrair investimento externo.

Aspectos chave da OpenAI incluem:

Pesquisa e Desenvolvimento: A OpenAI conduz pesquisa de ponta em IA e aprendizado de máquina, com foco no desenvolvimento de tecnologias e capacidades avançadas de IA.
Segurança e Ética: Uma parte central da missão da OpenAI é garantir que as tecnologias de IA sejam desenvolvidas de forma segura e ética, com os riscos potenciais gerenciados de forma responsável.
Modelos GPT: A OpenAI é bem conhecida por seus modelos Generative Pre-trained Transformer (GPT), que são capazes de uma ampla gama de tarefas de processamento de linguagem natural.
Colaboração e Licenciamento: A OpenAI colabora com várias organizações e empresas e oferece versões comerciais de seus modelos de IA, como o GPT-3, por meio de serviços de API.

Replit

Replit (anteriormente Repl.it) é um ambiente de desenvolvimento integrado (IDE) online que permite aos usuários escrever, executar e compartilhar código online. É uma ferramenta poderosa para desenvolvedores, educadores e estudantes, projetada para tornar a codificação mais acessível e colaborativa. O Replit suporta uma ampla gama de linguagens de programação, incluindo Python, JavaScript, Ruby, C++ e muitas outras.

Principais Recursos do Replit:- Configuração Instantânea do IDE:

Instalação Zero: O Replit funciona inteiramente no navegador, eliminando a necessidade de instalar software ou gerenciar dependências em sua máquina local.
Suporte para Muitas Linguagens: O Replit suporta mais de 50 linguagens de programação, permitindo que você alterne entre projetos e linguagens sem nenhuma configuração adicional.
Codificação Colaborativa:
Colaboração em Tempo Real: Semelhante ao Google Docs, o Replit permite que vários usuários codifiquem simultaneamente no mesmo ambiente. Este recurso é particularmente útil para programação em pares, ensino ou resolução colaborativa de problemas.
Modo Multijogador: Este modo permite a colaboração em tempo real com outros usuários, incluindo um recurso de chat para discutir o código diretamente dentro do IDE.
Hospedagem e Implantação:
Implantação Instantânea: O Replit oferece serviços de hospedagem, o que significa que você pode desenvolver e implantar aplicativos web diretamente da plataforma. Ele gera uma URL pública e ativa para cada projeto.
Repls Sempre Ativos: Para usuários pagantes, o Replit oferece a capacidade de manter os aplicativos sempre em execução, mesmo quando você fecha o navegador, o que é ótimo para bots, aplicativos web e outros serviços contínuos.
Controle de Versão:
Suporte Git Integrado: O Replit integra o Git, permitindo que os usuários enviem (push) e recebam (pull) de qualquer repositório Git externo. Essa integração facilita o controle de versão e o compartilhamento de código através de plataformas como o GitHub.
Ferramentas Educacionais:
Gestão de Sala de Aula: Educadores podem gerenciar tarefas de codificação, fornecer feedback e monitorar o progresso dos alunos diretamente no Replit. É amplamente utilizado em ambientes educacionais devido à sua facilidade de uso e configuração mínima.
Modelos e Exemplos: O Replit oferece uma variedade de modelos e projetos de exemplo que podem ajudar os usuários a começar rapidamente com novas linguagens ou frameworks.
Ambiente Nix:
Ambientes Personalizáveis: Usuários avançados podem personalizar seu ambiente de codificação usando Nix, uma poderosa ferramenta de gerenciamento de pacotes. Este recurso permite que os desenvolvedores definam ambientes de projeto precisos que incluem dependências de sistema específicas.
Suporte Integrado a Banco de Dados:
Banco de Dados Integrado: O Replit inclui um recurso de banco de dados integrado para armazenamento simples de chave-valor, o que é útil para aplicações que precisam persistir dados sem configurar um banco de dados externo.

Melhores Usos do Replit:- Prototipagem Rápida: Prototipagem rápida de aplicativos sem se preocupar com a configuração do ambiente.

Aprendizagem e Educação: Ideal para salas de aula e autoaprendizagem, graças à sua acessibilidade e facilidade de uso.
Entrevistas Técnicas: Conduza entrevistas e avaliações de codificação facilmente com sessões compartilhadas.
Hackathons *: Inicie projetos rapidamente durante hackathons sem perder tempo com a configuração.

Demonstração

Nota Lateral:

Async & await

Em Python,asynceawaitsão palavras-chave usadas para definir e manipular código assíncrono, que é um código que permite realizar operações de longa duração sem bloquear a execução do seu programa. Isso é particularmente útil para tarefas vinculadas a E/S (I/O-bound) e a rede (network-bound), como fazer requisições de rede, ler ou escrever em arquivos, etc., onde o programa passa a maior parte do tempo esperando por eventos externos.

Aqui está uma explicação detalhada de ambas as palavras-chave e como elas funcionam em Python:

A Palavra-chaveasync
Definindo Funções Assíncronas: A palavra-chaveasyncé usada para declarar uma função como uma "função assíncrona." Isso significa que a função não é bloqueante e retorna um objetoawaitable, especificamente um objetoasyncio.Future. Uma função assíncrona é definida usando a sintaxeasync def:

async def fetch_data():
       # function body

Ao declarar uma função comasync def, você está dizendo ao Python que esta função pode realizar operações assíncronas e pode ser pausada e retomada.

A palavra-chaveawait
Pausando e Retomando a Execução: A palavra-chaveawaité usada dentro de uma função assíncrona para pausar a execução da função até que o objetoawaitable (como aqueles retornados por outras funções assíncronas) seja resolvido. Isso permite que a função espere que um resultado se torne disponível enquanto permite que outras tarefas sejam executadas nesse meio tempo.

async def fetch_data():
       data = await some_async_function()
       return data

Neste exemplo,some_async_function() é outra função assíncrona, eawaitpausafetch_data()até quesome_async_function()finalize sua tarefa e retorne alguns dados.

ComoasynceawaitFuncionam Juntos
Concorrência: Juntos,asynceawaitfornecem uma maneira de escrever código concorrente em Python. Ao usar essas palavras-chave, você pode manter seu aplicativo responsivo, permitindo que o Python lide com outras tarefas enquanto aguarda a conclusão das operações de E/S. Isso não é execução paralela, mas execução concorrente (via multitarefa cooperativa).
Loop de Eventos: O conceito central por trás de async e await é o loop de eventos, que é fornecido pela biblioteca asyncio em Python. O loop de eventos gerencia e distribui a execução de diferentes tarefas. Ele acompanha todas as tarefas em execução e retoma as funções pausadas por await assim que suas operações aguardadas são concluídas.

Exemplo de Uso

Aqui está um exemplo simples usando asyncio para executar uma tarefa de forma assíncrona:

import asyncio

async def main():
    print("Hello")
    await asyncio.sleep(1)  # Suspensão assíncrona, não bloqueia o loop de eventos
    print("world")

# Executando a função principal assíncrona
asyncio.run(main())

Aplicações Práticas

Desenvolvimento Web: Em servidores web e aplicações web, async e await permitem lidar com múltiplas requisições web concorrentemente. Isso torna o tratamento de alta carga e a execução de múltiplas requisições de rede eficientes.
Coleta de Dados: São úteis em cenários onde dados precisam ser coletados de múltiplas fontes pela internet, como APIs ou bancos de dados, sem esperar que cada tarefa seja concluída sequencialmente.

Passo 0 Olá Bot!

Passo 1: Instalar discord.py

Primeiro, você precisa instalar a biblioteca discord.py. Você pode usar Rye como gerenciador de pacotes

Passo 2: Configurar Seu Bot do Discord

Vá para o Portal do Desenvolvedor do Discord (https://discord.com/developers/applications). Crie uma nova aplicação e dê um nome a ela. Vá para a aba Bot e clique em "Adicionar Bot". Copie o token que é gerado. Você precisará deste token para executar seu bot.

Passo 3: Escrever o Script Python

Crie um script Python que usa o token do bot para fazer login e responder a mensagens. Abaixo está um exemplo básico de um bot que responde a comandos simples:

Variáveis de ambiente

import discord
import os
from dotenv import load_dotenv

# Carrega variáveis de ambiente do arquivo .env
load_dotenv()

intents = discord.Intents.default()
intents.messages = True

client = discord.Client(intents=intents)

@client.event
async def on_ready():
    print(f'Logged in as {client.user}')

@c*lient.event
async def on_message(message):
    # não deixe o bot responder a si mesmo
    if message.author == client.user:
        return

elif message.content.startswith('!hello'):
        await message.channel.send('Olá!')

elif message.content.startswith('hi'):
        await message.channel.send('bem-vindo!')

elif message.content.startswith('what is the best meetup up there?'):
        await message.channel.send('O Ubuntu Tech Hive :)')

elif message.content.startswith('!bye'):
        await message.channel.send('Adeus!')

else:
        await message.channel.send("I did not understand your request!!")

client.run(os.environ ["DISCORD_TOKEN"])import math  # importing the math library

O que foi usado:

dotenv api
Disord token
Discord api bot
Python3

Limitações

O bot não pode interagir.
Responde apenas a prompts específicos com base em condições
Não é muito útil

Passo 1 Vamos tornar o bot mais útil

Ferramentas Necessárias: OpenAi api dotenv api Disord token Python3

import discord
import my_openai
import os
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

intents = discord.Intents.default()
intents.messages = True

client = discord.Client(intents=intents)

@client.event
async def on_ready():
    print(f'Logged in as {client.user}')

@client.event
async def on_message(message):
    # não deixe o bot responder a si mesmo
    if message.author == client.user:
        return

if message.content.startswith('$hello'):
        await message.channel.send('Olá, como posso ajudar?')

# Verifica se a mensagem começa com uma palavra-chave de pergunta
    if message.content.startswith('!ask'):
        # Remove a parte do comando e retira espaços em branco no início/fim
        user_question = message.content [len('!ask'):].strip()

if user_question:

try:
                response = my_openai.generate_answer(message.content)
                await message.channel.send("Aguarde! Procurando pela resposta...")
                await message.channel.send(response)

except Exception as e:
                await message.channel.send(f"Error processing your request: {str(e)}")
        else:
            await message.channel.send("Please provide a question after !ask")

if message.content.startswith('$question'):
        response = my_openai.generate_answer(message.content)
        await message.channel.send("looking for response")
        await message.channel.send(response)

# Substitua 'your_token_here' pelo token real do seu bot
client.run(os.environ ["DISCORD_TOKEN"])

from openai import OpenAI
import os

# Configure suas credenciais da API OpenAI
client = OpenAI(
    # Este é o padrão e pode ser omitido
    api_key=os.environ ["OPENAI_TOKEN"],
)

MODEL = "gpt-3.5-turbo"
# Define the function to generate answers
def generate_answer(question):
    response = client.chat.completions.create(
        model=MODEL,
        messages= [
            {"role": "system", "content": "You are a helpful assistant in a discord server answering question and being helpful."},
            {"role": "user", "content": question},
        ],
        temperature=0,
    )

return response.choices [0].message.content

Limitações

O bot ainda é local
Não é útil para o nosso ubuntu ou para qualquer outra pessoa
Sem estado para salvar

O que foi usado:

dotenv api
Disord token
Discord api bot
Python3
openai api key

Passo 2 Vamos implantar, Apresentando o Replit

import discord
import my_openai
import os
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

intents = discord.Intents.default()
intents.messages = True

client = discord.Client(intents=intents)

@client.event
async def on_ready():
    print(f'Conectado como {client.user}')

@client.event
async def on_message(message):
    # não deixe o bot responder a si mesmo
    if message.author == client.user:
        return

if message.content.startswith('$hello'):
        await message.channel.send('Olá, como posso ajudar?')

# Verifica se a mensagem começa com uma palavra-chave de pergunta
    if message.content.startswith('!ask'):
        # Remove a parte do comando e retira espaços em branco no início/fim
        user_question = message.content [len('!ask'):].strip()

if user_question:

try:
                response = my_openai.generate_answer(message.content)
                await message.channel.send("Aguarde! Procurando pela resposta...")
                await message.channel.send(response)

except Exception as e:
                await message.channel.send(f"Erro ao processar sua solicitação: {str(e)}")
        else:
            await message.channel.send("Por favor, forneça uma pergunta depois de !ask")

if message.content.startswith('$question'):
        response = my_openai.generate_answer(message.content)
        await message.channel.send("procurando resposta")
        await message.channel.send(response)

# Substitua 'your_token_here' pelo token real do seu bot
client.run(os.environ ["DISCORD_TOKEN"])

from replit import db

# URLs e suas chaves personalizadas correspondentes
urls = {
    "deep-dive-into-rag-with-langchain": "https://dev.ubuntuhive.tech/en-us/articles/deep-dive-into-rag-with-langchain/",
    "exploring-new-chatgpt-features": "https://dev.ubuntuhive.tech/en-us/articles/exploring-new-chatgpt-features-/",
    "build-small-apps-with-llms": "https://dev.ubuntuhive.tech/en-us/articles/build-small-apps-with-llms/",
    "docker-orchestra-swarm-k8s-kubernetes-for-beginners": "https://dev.ubuntuhive.tech/en-us/articles/docker-orchestra-swarm-k8s-kubernetes-for-beginners/",
    "devops-from-scratch-automated-basics": "https://dev.ubuntuhive.tech/en-us/articles/devops-from-scratch-automated-basics/",
    "from-networks-to-http-and-apis": "https://dev.ubuntuhive.tech/en-us/articles/from-networks-to-http-and-apis/",

"data-and-cloud-infrastructure-as-code": "https://dev.ubuntuhive.tech/en-us/articles/data-and-cloud-infrastructure-as-code/"
}

# Armazenar no banco de dados sob a chave 'articles'
db ["articles"] = urls

from openai import OpenAI
import os

# Configure suas credenciais da API OpenAI
# my_api_key = ''
client = OpenAI(
    # Este é o padrão e pode ser omitido
    api_key=os.environ ["OPENAI_TOKEN"],
)

MODEL = "gpt-3.5-turbo"
# Define a função para gerar respostas
def generate_answer(question):
# exemplo com uma mensagem de sistema
    response = client.chat.completions.create(
        model=MODEL,
        messages= [
            {"role": "system", "content": "Você é um assistente útil em um servidor do Discord, respondendo a perguntas e sendo prestativo."},
            {"role": "user", "content": question},
        ],
        temperature=0,
    )

return response.choices [0].message.content

O que foi usado:

API dotenv
Token do Discord
Bot da API do Discord
Python3
Chave da API OpenAI
replit

Passo 3 Boas-vindas aos novos membros

import discord
import my_openai as opai
import os
from discord.ext import commands
from replit import db
from dotenv import load_dotenv

# Carrega variáveis de ambiente do arquivo .env
load_dotenv()

intents = discord.Intents.default()
intents.message_content = True
# Inicializa o bot do Discord
bot = commands.Bot(command_prefix='!',intents=intents)

@bot.event
async def on_ready():
    print(f'Logged in as {bot.user}!')

@bot.command(help="Pergunte ao usuário que tipo de resumo ele está procurando.")
async def choose_article(ctx):
    # Recupera os artigos do banco de dados Replit
    articles = db ["articles"]
    # Cria uma mensagem com opções
    options = "\n".join([f"Send {idx+1} for {key.replace('-', ' ').title()}" for idx, key in enumerate(articles.keys())])
    prompt = "Por favor, escolha na lista abaixo:\n" + options
    await ctx.send(prompt)

# Função de verificação para validar a escolha do usuário
    def check(m):
        return m.author == ctx.author and m.content.isdigit() and 1 <= int(m.content) <= len(articles)

try:
        # Aguardar resposta do usuário
        msg = await bot.wait_for('message', check=check, timeout=60.0)  # 60 segundos para responder
        choice = int(msg.content) - 1
        selected_key = list(articles.keys()) [choice]
        selected_article = articles [selected_key]
        # Você pode adicionar funcionalidades adicionais aqui para resumir o artigo
        await ctx.send(f"Você selecionou: {selected_key.replace('-', ' ').title()}\nURL: {selected_article}")
        await ctx.send("Por favor, aguarde enquanto eu obtenho o resumo...")
        await ctx.send(opai.generate_summary(selected_article))

except Exception as e:
        await ctx.send('Nenhuma entrada válida recebida ou tempo limite atingido. Por favor, tente novamente.')

@bot.command(help="Sends a welcome message with useful resources.")
async def new_member(ctx):
    articles = db ["articles"]
    most_recent_article_key = list(articles.keys()) [-1]  # Getting the most recent article key
    most_recent_article_url = articles [most_recent_article_key]  # Getting the URL

# Welcome message and resources
    welcome_message = (
        f"Bem-vindo(a) ao servidor, {ctx.author.mention}! 🎉 Aqui estão alguns recursos que você pode achar úteis:\n"
        f"1. Confira nosso artigo mais recente: {most_recent_article_url}\n"
        f"2. Visite nosso site Ubuntu Hive para mais informações: https://dev.ubuntuhive.tech/en-us/\n"
        f"3. Saiba mais sobre tecnologia com este tutorial abrangente: [Insira Seu Link de Tutorial Aqui]\n"
        f"4. Outros recursos e informações diversas: [Insira Mais Links ou Informações Aqui]\n"
    )

await ctx.send(welcome_message)

# Executar o bot
token = os.getenv("DISCORD_TOKEN")
if token:
  bot.run(token)
else:
  print("Erro: Token do Discord não encontrado nas variáveis de ambiente. Certifique-se de que DISCORD_TOKEN esteja definido.")

from replit import db

# URLs e suas chaves personalizadas correspondentes
urls = {
    "deep-dive-into-rag-with-langchain": "https://dev.ubuntuhive.tech/en-us/articles/deep-dive-into-rag-with-langchain/",
    "exploring-new-chatgpt-features": "https://dev.ubuntuhive.tech/en-us/articles/exploring-new-chatgpt-features-/",
    "build-small-apps-with-llms": "https://dev.ubuntuhive.tech/en-us/articles/build-small-apps-with-llms/",
    "docker-orchestra-swarm-k8s-kubernetes-for-beginners": "https://dev.ubuntuhive.tech/en-us/articles/docker-orchestra-swarm-k8s-kubernetes-for-beginners/",
    "devops-from-scratch-automated-basics": "https://dev.ubuntuhive.tech/en-us/articles/devops-from-scratch-automated-basics/",
    "from-networks-to-http-and-apis": "https://dev.ubuntuhive.tech/en-us/articles/from-networks-to-http-and-apis/",

"data-and-cloud-infrastructure-as-code": "https://dev.ubuntuhive.tech/en-us/articles/data-and-cloud-infrastructure-as-code/"
}

# Armazenar no banco de dados sob a chave 'articles'
db ["articles"] = urls

from openai import OpenAI
import os

# Configure suas credenciais da API OpenAI
# my_api_key = ''
client = OpenAI(
    # Este é o padrão e pode ser omitido
    api_key=os.environ ["OPENAI_TOKEN"],
)

MODEL = "gpt-3.5-turbo"
# Define a função para gerar respostas
def generate_answer(question):
# exemplo com uma mensagem de sistema
    response = client.chat.completions.create(
        model=MODEL,
        messages= [
            {"role": "system", "content": "Você é um assistente útil em um servidor do Discord, respondendo a perguntas e sendo prestativo."},
            {"role": "user", "content": question},
        ],
        temperature=0,
    )

return response.choices [0].message.content

def generate_summary(articles):
  response = client.chat.completions.create(
    model=MODEL,
    messages= [
        {"role": "system", "content": "You are a helpful assistant in a discord server. You are great as providing summaries of text when given an article link. when prompted, provide a max of 200 words summary of the provided link"},
        {"role": "user", "content": articles},
    ],
    temperature=0,
  )

return response.choices [0].message.content

Links Importantes

Discord: Portal do Desenvolvedor
Discord: discord.py
OpenAi: openai
OpenAi: cookbook openai
Replit: Documentação da API Replit
Replit: Replit

Ubuntu TechHive

Building a Discord Bot Using Open AI and python

Discord

OpenAI

Replit

Demonstração

Async & await

Passo 0 Olá Bot!

Limitações

Passo 1 Vamos tornar o bot mais útil

Limitações

Passo 2 Vamos implantar, Apresentando o Replit

Passo 3 Boas-vindas aos novos membros

Links Importantes