10 Dia 4: Integração do ChatGPT e Claude no RStudio

Objetivo do dia

Capacitar você a usar ChatGPT (OpenAI) e Claude (Anthropic) diretamente no RStudio para:

Explicar erros e fazer debug do código

Revisar e refatorar código

Gerar código e funções

Criar rascunhos de relatórios e documentação

Automatizar tarefas via API

Tempo previsto: 19h00–22h00 (intervalo 20h15–20h30)

10.0.1 Revisão Rápida dos Dias Anteriores (≈ 10 min)

library(tidyverse)

10.1 Conceitos e Modelos (19h00 - 19h30)

10.1.1 O que são LLMs (Large Language Models)?

LLM = Large Language Model (Modelo de Linguagem Grande)

O que são:

Modelos de inteligência artificial treinados em volumes massivos de texto
Aprendem padrões da linguagem, conceitos e relações
Capazes de gerar texto, código, explicações e muito mais

Como funcionam (simplificado):

Treinamento: Leem bilhões de páginas de texto da internet, livros, código
Aprendizado: Identificam padrões - como palavras se relacionam, estruturas de código
Geração: Preveem a próxima palavra/token mais provável dada uma entrada

Não são:

❌ Bancos de dados que “buscam” respostas
❌ Sistemas de busca como Google
❌ Calculadoras ou compiladores

São:

✅ Sistemas de reconhecimento de padrões estatísticos
✅ Geradores de texto coerente baseados em probabilidades
✅ Assistentes que “entendem” contexto

10.1.2 Modelos principais que usaremos

1. ChatGPT (OpenAI)

Família GPT-4:

gpt-4o: Mais rápido e barato, multimodal (texto + imagem)
gpt-4o-mini: Ainda mais rápido e barato, excelente custo-benefício
gpt-4-turbo: Balanceado entre velocidade e qualidade

Pontos fortes:

✅ Explicações didáticas e passo a passo
✅ Geração rápida de código
✅ Bom em tarefas criativas
✅ Interface conversacional natural
✅ Mais barato que Claude

Quando usar:

Explicar conceitos de forma simples
Gerar código rapidamente (protótipos)
Criar documentação básica
Responder dúvidas gerais

2. Claude (Anthropic)

Família Claude 3:

claude-3-5-sonnet-latest: Melhor modelo, mais inteligente
claude-3-opus: Mais preciso, melhor para análises complexas
claude-3-sonnet: Balanceado
claude-3-haiku: Mais rápido e barato

Pontos fortes:

✅ Análise profunda de código
✅ Respostas mais longas e detalhadas
✅ Melhor em raciocínio complexo
✅ Mais cuidadoso e preciso
✅ Melhor contexto (200k tokens vs 128k do GPT)

Quando usar:

Revisar código complexo
Análise e refatoração profunda
Explicações técnicas detalhadas
Debugging de problemas difíceis

10.1.3 Comparação prática

Critério	ChatGPT	Claude
Velocidade	Muito rápido ⚡⚡⚡	Rápido ⚡⚡
Custo	Mais barato 💰	Mais caro 💰💰
Explicações simples	Excelente ⭐⭐⭐	Muito bom ⭐⭐
Análise profunda	Bom ⭐⭐	Excelente ⭐⭐⭐
Código complexo	Bom ⭐⭐	Excelente ⭐⭐⭐
Contexto (tokens)	128k	200k
Criatividade	Alta ⭐⭐⭐	Moderada ⭐⭐
Precisão técnica	Boa ⭐⭐	Excelente ⭐⭐⭐

10.2 O que são APIs?

API = Application Programming Interface (Interface de Programação de Aplicações)

Analogia do restaurante:

Você = seu código R
Cozinha = servidor da OpenAI/Anthropic com o modelo de IA
Garçom = API que leva seu pedido e traz a resposta
Cardápio = documentação da API (o que você pode pedir)

Como funciona:

Você faz uma requisição (pergunta)

"Explique o que este código faz: x <- mean(1:10)"

API envia para o modelo de IA
- Viaja pela internet até os servidores
- Processa sua pergunta
Modelo gera resposta
- Analisa contexto
- Gera texto/código

API retorna resposta

"Este código calcula a média dos números de 1 a 10..."

Componentes de uma API:

Endpoint: URL para onde enviar requisições
- OpenAI: https://api.openai.com/v1/chat/completions
- Anthropic: https://api.anthropic.com/v1/messages
Método HTTP: Como enviar (GET, POST, etc.)
- Usaremos POST (enviar dados)
Headers: Informações sobre a requisição
- Authorization: sua chave API
- Content-Type: formato dos dados (JSON)
Body: Os dados da requisição
- Modelo a usar
- Sua pergunta/prompt
- Parâmetros (temperatura, max_tokens, etc.)
Response: A resposta do servidor
- Conteúdo gerado
- Metadados (tokens usados, etc.)

10.3 Limites e Custos

10.3.1 Custos por modelo

OpenAI (GPT-4o-mini) - mais barato: - Input: $0.150 / 1M tokens (~750k palavras) - Output: $0.600 / 1M tokens

Exemplo prático: - 1 conversa típica = ~1000 tokens = $0.0015 (menos de 1 centavo!) - 1000 conversas = ~$1.50

Anthropic (Claude 3.5 Sonnet) - mais caro mas melhor: - Input: $3.00 / 1M tokens - Output: $15.00 / 1M tokens

Exemplo prático: - 1 conversa típica = ~1000 tokens = $0.03 (3 centavos) - 1000 conversas = ~$30

O que é um token? - Token ≈ 0.75 palavras em inglês - Token ≈ 0.5 palavras em português (devido aos acentos) - “Olá, como você está?” ≈ 7-8 tokens

10.3.2 Rate Limits (Limites de taxa)

Por que existem: - Prevenir abuso e spam - Garantir disponibilidade para todos - Controlar custos

Limites típicos (conta gratuita/tier 1):

OpenAI: - ~10,000 tokens/minuto - ~3 requisições/minuto (com GPT-4) - ~200 requisições/dia

Anthropic: - ~10,000 tokens/minuto - ~5 requisições/minuto - ~1000 requisições/dia

O que acontece se exceder: - Erro HTTP 429: “Too Many Requests” - Precisa esperar (geralmente 1 minuto)

Como evitar: - Não faça loops rápidos com chamadas à API - Implemente delays entre requisições - Use um modelo mais barato para testes

10.4 Boas Práticas de Uso Responsável de IA

10.4.1 Privacidade e Dados Sensíveis

⚠️ NUNCA envie para APIs de IA:

❌ Senhas ou credenciais
❌ Dados pessoais identificáveis (CPF, RG, etc.)
❌ Informações médicas ou financeiras privadas
❌ Dados proprietários ou confidenciais da empresa
❌ Código com chaves de API ou tokens

O que é seguro enviar:

✅ Código genérico e exemplos
✅ Dados públicos ou sintéticos
✅ Perguntas conceituais
✅ Erros e stacktraces (sem informação sensível)

Lembre-se: Tudo que você envia pode ser usado para treinar modelos futuros!

10.4.2 Versionamento de Código Gerado por IA

Por que versionar:

Transparência sobre origem do código
Rastreabilidade de mudanças
Facilita debugging futuro
Ética e honestidade acadêmica/profissional

Como fazer:

# Bom: documenta que IA gerou
# Esta função foi gerada por ChatGPT em 2024-11-25
# Prompt: "Crie função para calcular z-score"
zscore <- function(x) {
  (x - mean(x, na.rm = TRUE)) / sd(x, na.rm = TRUE)
}

# Commits descritivos
git commit -m "feat: adiciona função zscore (gerada com ChatGPT)"

10.4.3 Validação e Teste

⚠️ CRÍTICO: NUNCA use código de IA sem entender e testar!

Processo recomendado:

Entenda o código gerado
- Leia linha por linha
- Pergunte à IA se não entender algo
- Pesquise funções desconhecidas

Teste extensivamente

# Sempre teste casos extremos
zscore(c(1, 2, 3))        # Normal
zscore(c(1, 1, 1))        # Todos iguais (sd = 0?)
zscore(c(1, NA, 3))       # Com NA
zscore(numeric(0))        # Vetor vazio

Valide resultados
- Compare com métodos conhecidos
- Verifique casos conhecidos
- Use diferentes inputs
Refatore se necessário
- Melhore legibilidade
- Adicione validações
- Otimize performance

10.4.4 Uso Ético

Faça: - ✅ Use IA como assistente, não substituto do aprendizado - ✅ Entenda o que a IA está fazendo - ✅ Cite quando código foi gerado por IA (contextos acadêmicos) - ✅ Revise e melhore código gerado - ✅ Use para aprender conceitos novos

Não faça: - ❌ Submeta código de IA sem entender (em trabalhos/provas) - ❌ Confie cegamente nas respostas - ❌ Use como substituto de documentação oficial - ❌ Compartilhe chaves de API - ❌ Use para gerar trabalhos acadêmicos inteiros sem transparência

10.5 Configuração de Chaves e Ambiente (19h30 - 20h15)

10.5.1 Variáveis de Ambiente no R

O que são variáveis de ambiente?

Variáveis de ambiente são configurações que ficam armazenadas fora do seu código, disponíveis para todos os programas no seu sistema operacional.

Por que usar para chaves de API?

Segurança:

✅ Chaves não ficam no código (evita commit acidental para GitHub)
✅ Diferentes chaves para diferentes ambientes (dev, prod)
✅ Fácil rotação de chaves sem mudar código

Como funcionam no R:

# Ler variável de ambiente
Sys.getenv("NOME_DA_VARIAVEL")

# Definir variável (apenas na sessão atual)
Sys.setenv(NOME_DA_VARIAVEL = "valor")

# Listar todas
Sys.getenv()

10.5.2 O arquivo .Renviron

O que é .Renviron:

Arquivo de texto simples que define variáveis de ambiente
Carregado automaticamente quando R inicia
Localização: diretório home do usuário (~/.Renviron)

Vantagens:

Variáveis persistem entre sessões
Não precisa redefinir toda vez
Fácil de gerenciar

Como criar/editar:

# Abrir .Renviron no RStudio (cria se não existir)
usethis::edit_r_environ()

# Ou manualmente encontrar localização
path.expand("~/.Renviron")

Formato do arquivo:

# Arquivo .Renviron
# Linhas começando com # são comentários
# Formato: VARIAVEL=valor (SEM espaços ao redor do =)

OPENAI_API_KEY=XXXXXX

ANTHROPIC_API_KEY=XXXXX

# ERRADO (com espaços):
# VARIAVEL = valor

# CERTO (sem espaços):
# VARIAVEL=valor

Depois de editar:

Salve o arquivo
Reinicie o R: Session → Restart R ou .rs.restartR()
Teste: Sys.getenv("OPENAI_API_KEY")

10.6 Criando Chaves de API

10.6.1 OpenAI (ChatGPT)

Passo 1: Criar conta

Acesse https://platform.openai.com/
Crie uma conta ou Login
Verifique email

Passo 2: Adicionar método de pagamento

Quickstart
Adicione método de pagamento
Importante: Configure um limite de gastos!
- Recomendado: $5-10/mês para aprendizado
- Evita surpresas na fatura

Passo 3: Criar API Key

Settings → API Keys
Create new secret key
Dê um nome descritivo: “RStudio - Curso R”
⚠️ COPIE A CHAVE AGORA! (só aparece uma vez)
- Formato: sk-proj-...
- Guarde em local seguro temporariamente

Passo 4: Configurar no R

usethis::edit_r_environ()
# Adicione: OPENAI_API_KEY=sk-proj-SUA_CHAVE_AQUI
# Salve e reinicie R

Passo 5: Testar

Sys.getenv("OPENAI_API_KEY")
# Deve mostrar: "sk-proj-..."

10.6.2 Anthropic (Claude)

Passo 1: Criar conta

Acesse https://console.anthropic.com/
Crie uma conta ou Login
Verifique email

Passo 2: Obter créditos

Contas novas ganham alguns créditos gratuitos ($5-10)
Depois precisa adicionar método de pagamento

Passo 3: Criar API Key

Settings → API Keys
Create Key
Nome: “RStudio - Curso R”
⚠️ COPIE A CHAVE! (só aparece uma vez)
- Formato: sk-ant-...

Passo 4: Configurar no R

usethis::edit_r_environ()
# Adicione: ANTHROPIC_API_KEY=
# Salve e reinicie R

Passo 5: Testar

Sys.getenv("ANTHROPIC_API_KEY")
# Deve mostrar: "sk-ant-..."

10.7 Instalação de Pacotes

# Pacotes necessários
install.packages(c(
  "gptstudio",    # Interface para ChatGPT no RStudio
  "chattr",       # Interface para múltiplos LLMs
  "httr2",        # Cliente HTTP moderno (para APIs)
  "jsonlite",      # Trabalhar com JSON
  "shiny"
))

# Verificar instalação
library(gptstudio)
library(chattr)
library(httr2)
library(jsonlite)
library(shiny)
library(tidyverse)

10.7.1 O que cada pacote faz

gptstudio:

Addins no RStudio para ChatGPT
Chat panel integrado
Seleção de código + análise
Geração de documentação
Correção de erros

chattr:

Interface unificada para múltiplos LLMs
Suporta OpenAI, Anthropic, Google, outros
Chat interativo no console
Configuração flexível de modelos

httr2:

Cliente HTTP moderno para R
Fazer requisições para APIs
Melhor que httr (versão anterior)
Pipe-friendly (|>)

jsonlite:

Converter entre R e JSON
APIs usam JSON para comunicação
Parse de respostas JSON

10.8 INTERVALO (20h15 - 20h30)

Aproveite para:

Verificar se suas chaves estão configuradas
Instalar os pacotes
Tomar água/café!

10.9 RStudio + chattr (20h30 - 21h00)

10.9.1 Conhecendo o chattr

chattr adiciona superpoderes de IA ao RStudio através de Addins.

Recursos principais:

ChatGPT Chat: Painel de chat lateral
Comment Code: Adiciona comentários ao código
Explain Code: Explica código selecionado
Write Code: Gera código a partir de descrição
Edit Code: Refatora/melhora código

10.9.2 Acessando os Addins

Menu: Addins → chattr → ...

Atalhos de teclado (configuráveis):

Tools → Modify Keyboard Shortcuts
Busque “chattr”
Configure atalhos personalizados

10.9.3 Definindo o modelo de IA para ser utilizado

Modelos disponíveis no ChatGPT (OpenAI)

models_openai()

Modelos disponíveis no Claude (Anthropic).

models_anthropic()

Escolhendo o modelo para uso:

my_chat <- ellmer::chat_anthropic()
my_chat <- ellmer::chat_anthropic(model = 'claude-opus-4-1-20250805')

my_chat <- ellmer::chat_openai()
my_chat <- ellmer::chat_openai(model = 'gpt-5.1-codex-mini')

chattr_use(my_chat)

10.9.4 Chat Integrado

Como abrir:

# Abre o chat no painel lateral do RStudio
chattr_app(as_job = TRUE)

Interface do Chat:

Painel lateral direito
Campo de input na parte inferior
Histórico de conversa acima
Botões para copiar/limpar

Uso básico:

# Criar um vetor numérico em R
chattr("Como criar um vetor em R?")

# Explicar conceitos
chattr("O que é um data.frame?")

# Gerar código
chattr("Crie uma função que calcule média e desvio padrão")

# Debugging
chattr("Por que este código dá erro: mean(NA)")

Dicas para bons prompts:

Seja específico
Dê contexto quando necessário
Peça explicações passo a passo
Solicite exemplos

10.9.5 Explicar Código Selecionado

Exemplo:

# Selecione este código e peça explicação
dados %>%
  filter(!is.na(valor)) %>%
  group_by(categoria) %>%
  summarize(
    n = n(),
    media = mean(valor),
    dp = sd(valor)
  ) %>%
  arrange(desc(media))

chattr("Explique este codigo: dados %>%
  filter(!is.na(valor)) %>%
  group_by(categoria) %>%
  summarize(
    n = n(),
    media = mean(valor),
    dp = sd(valor)
  ) %>%
  arrange(desc(media))")

O que o LLM explica:

O que cada linha faz
Ordem de execução
Funções usadas
Resultado esperado

10.9.6 Casos de Uso Práticos

10.9.6.1 Caso 1: Explicar um erro

# Código com erro
dados <- data.frame(x = 1:5, y = c(2, 4, NA, 8, 10))
mean(dados$y)  # Retorna NA

# Prompt para ChatGPT:
chattr("Por que mean(dados$y) retorna NA? Como corrigir?")

10.9.6.2 Caso 2: Refatorar função

# Função verbosa
calcular <- function(x, y) {
  resultado1 <- x + y
  resultado2 <- x * y
  resultado3 <- x / y
  output <- list()
  output$soma <- resultado1
  output$produto <- resultado2
  output$divisao <- resultado3
  return(output)
}

# Prompt:
# Armazene o código em uma variável primeiro
codigo <- 'calcular <- function(x, y) {{
  resultado1 <- x + y
  resultado2 <- x * y
  resultado3 <- x / y
  output <- list()
  output$soma <- resultado1
  output$produto <- resultado2
  output$divisao <- resultado3
  return(output)
}}'

chattr(paste("Refatore esta função para ser mais concisa e clara:\n\n", codigo))

10.9.6.3 Caso 3: Gerar testes unitários

# Sua função
codigo <- "zscore <- function(x) (x - mean(x, na.rm = TRUE)) / sd(x, na.rm = TRUE)"

# Prompt:
chattr(
  paste("Gere 3 testes unitários simples para validar esta função zscore:",codigo))

10.9.7 Chat Programático

# Fazer pergunta diretamente
resposta <- chattr("Como calcular média em R?")
cat(resposta)

# Com contexto/código
codigo <- "
dados <- data.frame(x = 1:5, y = c(2, 4, NA, 8, 10))
mean(dados$y)
"

resposta <- chattr(paste0(
  "Explique o que acontece neste código:\n",
  codigo
))
cat(resposta)

# Salvar histórico
historico <- chattr_history()
print(historico)

10.9.7.1 Caso 1: Análise profunda de código

pipeline_complexo <- "library(tidyverse) 
resultado <- mtcars %>%
  mutate(
    eficiencia = mpg / wt,
    categoria_cyl = case_when(
      cyl <= 4 ~ 'Pequeno',
      cyl <= 6 ~ 'Médio',
      TRUE ~ 'Grande'
    )
  ) %>%
  group_by(categoria_cyl, gear) %>%
  summarize(
    n = n(),
    media_ef = mean(eficiencia),
    dp_ef = sd(eficiencia),
    .groups = 'drop'
  ) %>%
  filter(n >= 3) %>%
  arrange(desc(media_ef))"

chattr(paste0("Faca uma analise profunda desse codigo:", pipeline_complexo))