Why?

Temos dois motivos: O primeiro é que esse é parte dos meus estudo para implementação do bot para criação e correção de códigos maliciosos, dá uma olhada aqui

A segunda surgiu porque tenho TDAH e volta e meia acabo esquecendo alguns comandos específicos que preciso usar no terminal, além de precisar fazer algumas pesquisas, o que seria muito legal de ser feito sem precisar sair do terminal.

Um script em python seria muito fácil e eu gosto de um pouco de desafio, além de ver que algumas pessoas aqui já perguntaram e comentaram sobre Rust, que tal mostrar o poder de rust então para gerar o nosso assistente virtual?

Iniciando o projeto

Este tutorial leva em cosideração que você tenha um conhecimento mínimo de rust e do gerenciador de projetos cargo!

Precisamos iniciar um novo projeto para começarmos:

cargo new assistente_virtual --bin

Iniciamos um projeto de rust, assistente virtual é um nome qualquer, eu por exemplo escolhi o nome Robert para meu assistente virtual.

--bin

O --bin é para indicar que queremos um projeto binário, ou seja, um projeto que será executado no terminal.

Entre na pasta do projeto e abra o Cargo.toml, ele é o arquivo que contém as dependências do projeto, vamos adicionar as dependências que vamos usar:

[dependencies]
hyper = { version = "^0.14", features = ["full"]}
hyper-tls = "^0.5"
tokio = {version = "1", features = ["full"]}
serde = "^1"
serde_derive = "^1"
serde_json = "^1"

A primeira dependência é o hyper, que é um framework para construir servidores http, vamos usar ele para criar um servidor http que vai receber as requisições do nosso assistente virtual.

A segunda dependência é o hyper-tls, que é um wrapper para o hyper que vai nos permitir usar https.

A terceira dependência é o tokio, que é um framework para construir aplicações assíncronas, vamos usar ele para criar um servidor http assíncrono.

A quarta dependência é o serde, que é um framework para serialização e desserialização de dados, vamos usar ele para serializar e desserializar os dados que vamos receber e enviar.

Após adicionar todas as dependências vamos começar o desenvolvimento do nosso assistente virtual.

Abra o arquivo main.rs e vamos começar a escrever o código:

use hyper::body::Buf;
use hyper::{header, Body, Client, Request};
use hyper_tls::HttpsConnector;
use serde_derive::{Deserialize, Serialize};
use std::io::{stdin, stdout, Write};

Não entratei em muitos detalhes para não ser um tutorial maçante mas basicamente nós importamos todas as dependências que vamos usar.

O nosso projeto se baseia em usar o GPT-3 para nos gerar repostas para nossas perguntas, a API do GPT-3 é uma API REST, então vamos usar o hyper para criar um servidor http que vai receber as requisições e enviar as respostas.

Precisamos criar os structs que são responsáveis por serializar e desserializar os dados que vamos receber e enviar. A serialização é o processo de converter dados em uma forma que possa ser armazenada ou transmitida de uma maneira eficiente.

#[derive(Deserialize, Debug)]
struct OAIChoises {
 text: String,
}

O struct OAIChoises é responsável por desserializar os dados que vamos receber da API do GPT-3, ele é responsável por desserializar o campo text que é o campo que contém a resposta que o GPT-3 gerou para a nossa pergunta.

#[derive(Deserialize, Debug)]
struct OAIResponse {
 choices: Vec<OAIChoises>,
}

O struct OAIResponse é responsável por desserializar os dados que vamos receber da API do GPT-3, existem outros campos que são retornados na requisição mas não vamos usar eles, então optei por não usar pois o compilador iria ficar brigando com a gente por criar um campo que não usamos

#[derive(Serialize, Debug)]
struct OAIRequest {
 prompt: String,
 model: String,
 max_tokens: u32,
 temperature: u32,
}

O struct OAIRequest é responsável por serializar os dados que vamos enviar para a API do GPT-3, ele é responsável por serializar os campos prompt, model, max_tokens e temperature. Que representam, respectivamente, a pergunta que vamos fazer, o modelo que vamos usar, a quantidade máxima de tokens que o GPT-3 vai gerar e a temperatura que o GPT-3 vai usar para gerar a resposta. PS: Eu não cheguei a buscar mais informaçõe sobre essa tal "temperatura" mas acredito que seja algo relacionado a assertividade do texto.

As próximas partes serão um pouco mais complicadas, colocarei snippets do código e o código final para caso você se perca.

Vamos iniciar o nosso main

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {

}

Nosso método main será um método async, para isso usamos o tokio::main, que é um macro que transforma o método main em um método async.

let https = HttpsConnector::new();
 let client = Client::builder().build(https);
 let uri = "https://api.openai.com/v1/completions";
 
 let preamble = "Eu sou um robô de pesquisa";

 let oai_token: String = String::from("SEU-TOKEN-AQUI");
 let auth_header_val = format!("Bearer {}", oai_token);

Criamos uma requisição Http e criamos os parâmetros que usaremos na construção da nossa requisição.

O parâmetro preamble é o texto que vem antes da pergunta, ela será usada para que o GPT-3 entenda a melhor abordagem para responder a nossa pergunta, você pode alterar isso para criar um chatbot meio sarcástico, por exemplo.

oai_token e auth_header_val são o token da API do GPT-3 e o valor do header de autenticação que vamos usar na requisição.

println!("{esc}c", esc = 27 as char);
loop {
  print!("> "); // Será usado para representar nosso input
  stdout().flush().unwrap(); // Limpa o buffer do stdout
  let mut user_text = String::new();

  stdin().read_line(&mut user_text).expect("Failed to read line"); // Pega o input do usuário e coloca na variável user_text
  println!("");

  let oai_request = OAIRequest {
   prompt: format!("{}{}", preamble, user_text),
   model: String::from("text-curie-001"),
   max_tokens: 60,
   temperature: 0,
  };

O parâmetro oai_request é o objeto que vamos usar para serializar os dados que vamos enviar para a API do GPT-3, observe as opções que foram selecionadas, o text-curie não é tão poderoo quanto o DaVinci mas é mais rápido e mais barato, então é uma boa opção para testes.

Caso queira brincar um pouco com o DaVinci altera o model para text-davinci-002, ele é realmente mais divertido porém consome bastante dos tokens, tome cuidado!

PS: Usando bastante por 1 dia eu obtive o uso total de 0.4 cents!

let body = Body::from(serde_json::to_vec(&oai_request)?);
  
  let req = Request::post(uri)
   .header(header::CONTENT_TYPE, "application/json")
   .header("Authorization", &auth_header_val)
   .body(body)
   .unwrap();
  
  let res = client.request(req).await?;

  let body = hyper::body::aggregate(res).await?;

  let json: OAIResponse = serde_json::from_reader(body.reader())?;

  // Print the json
  println!("🤖: {}", json.choices[0].text);

Essa parte é a mais complicada, mas vamos por partes. O req é a requisição em si, ele é construído a partir do objeto body e dos parâmetros que criamos anteriormente. Res é a resposta da requisição, ela é construída a partir do objeto req. body é o corpo da resposta, ele é construído a partir do objeto res. json é o objeto que vamos usar para desserializar os dados que recebemos da API do GPT-3, ele é construído a partir do objeto body. E a partir do json nós imprimimos na tela a reposta do bot!

Código inteiro:

use hyper::body::Buf;
use hyper::{header, Body, Client, Request};
use hyper_tls::HttpsConnector;
use serde_derive::{Deserialize, Serialize};
use std::io::{stdin, stdout, Write};

#[derive(Deserialize, Debug)]
struct OAIChoises {
 text: String,
}

#[derive(Deserialize, Debug)]
struct OAIResponse {

 choices: Vec<OAIChoises>,
}

#[derive(Serialize, Debug)]
struct OAIRequest {
 prompt: String,
 model: String,
 max_tokens: u32,
 temperature: u32,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let https = HttpsConnector::new();
 let client = Client::builder().build(https);
 let uri = "https://api.openai.com/v1/completions";
 
 let preamble = "Eu sou um robô de pesquisa";

 let oai_token: String = String::from("SEU-TOKEN-AQUI");
 let auth_header_val = format!("Bearer {}", oai_token);

 println!("{esc}c", esc = 27 as char);
 loop {
  print!("> ");
  stdout().flush().unwrap();
  let mut user_text = String::new();

  stdin().read_line(&mut user_text).expect("Failed to read line");
  println!("");

  let oai_request = OAIRequest {
   prompt: format!("{}{}", preamble, user_text),
   model: String::from("text-curie-001"),
   max_tokens: 60,
   temperature: 0,
  };

  let body = Body::from(serde_json::to_vec(&oai_request)?);
  
  let req = Request::post(uri)
   .header(header::CONTENT_TYPE, "application/json")
   .header("Authorization", &auth_header_val)
   .body(body)
   .unwrap();
  
  let res = client.request(req).await?;

  let body = hyper::body::aggregate(res).await?;

  let json: OAIResponse = serde_json::from_reader(body.reader())?;

  // Print the json
  println!("🤖: {}", json.choices[0].text);
  
 }
}

Buildando e rodando

Para vermos o resultado no terminal basta rodar cargo run no terminal.

> como faço para mudar de diretório no linux?

🤖: Para mudar de diretório no Linux, você precisa utilizar o comando cd (comando de diretório) para ir ao diretório que deseja mudar

> poderia me mostar um exemplo do comando ssh para me conectar a um servidor remoto?

🤖: ssh -L 8888@localhost remotepassword

Show de bola! Agora vamos gerar um binário para usarmos o bot quando precisarmos sem compilar o código toda vez.

cargo build --release

Após compilar observe que foi criada uma pasta chamada target e dentro dela uma pasta chamada release e dentro dela um arquivo chamado *robert_ai.*Nesse caso vai ser o nome do seu projetinho.

Precisamos agora adicionar o arquivo ao PATH!

sudo mv target/release/robert_ai /usr/local/bin
source ~/.bashrc *
ource ~/.zshrc *

O comando source é para atualizar o PATH do seu terminal, caso você esteja usando o bash ou o zsh, use de acordo com o seu terminal.

Após isso você pode rodar o comando robert_ai e ver o bot funcionar! Maravillha o/

Conclusão

Esse foi um tutorial bem simples, mas que mostra como é fácil criar um bot de pesquisa usando a API do GPT-3. O código fonte do projeto não etá disponível no Github ainda porque sou preguiçoso.

O tutorial está propositalmente incompleto, pois a ideia é que vocês pesquisem e aprendam mais sobre o assunto. Alguns desafios para vocês:

• Colocar a pergunta como parâmetro para o programa Ex: robert_ai "como faço para mudar de diretório no linux?"
• Adicionar cores no terminal
• Testar outros modelos disponíveis
• Criar um bot que responde perguntas de forma mais inteligente
• Criar um bot que não seja de pesquisa

PS: Fui brincar um pouco de madrugada e se liga nessa resposta:

./robert_ai

> oi?

🤖: Não, sou um humano.

Eu gelei e fui dormir 😂