Comandos DOS – Avançados

Comandos e recursos úteis para uso mais avançado no prompt.

Atributos e cópia avançada

attrib

Mostra ou altera atributos de arquivos (R=somente leitura, H=oculto, S=sistema). Ex.: attrib +r arquivo.txt

xcopy origem destino /E /I

Copia pastas e subpastas. /E inclui vazias; /I assume que destino é pasta.

robocopy origem destino

Cópia robusta (Windows). Sincroniza pastas, retenta em falhas. Ex.: robocopy C:\fonte D:\backup /MIR

Variáveis de ambiente

set

Lista variáveis de ambiente. set VAR=valor define (só na sessão atual). Uso: %VAR%

echo texto

Exibe texto. echo %VAR% mostra o valor da variável.

Redirecionamento

comando > arquivo

Redireciona a saída para o arquivo (sobrescreve).

comando >> arquivo

Redireciona a saída anexando ao arquivo.

comando < arquivo

Lê a entrada do arquivo.

Arquivos .bat

Scripts em lote são arquivos .bat ou .cmd com um comando por linha. Execute com o nome do arquivo, ex.: meuscript.bat. Podem usar echo, set, if, for e chamadas a outros programas.

O que é um versionador e o que é Git

Controle de versão

Um versionador (sistema de controle de versão) guarda o histórico de alterações dos arquivos do projeto. Assim você pode ver quem mudou o quê, quando, e voltar a versões anteriores se precisar.

Principais ideias: histórico, diferenças entre versões, trabalho em equipe sem sobrescrever o trabalho dos outros.

O que é o Git

O Git é um sistema de controle de versão distribuído: cada desenvolvedor tem uma cópia completa do repositório (histórico e arquivos). O repositório pode estar só no seu computador (local) ou também em um servidor (remoto, ex.: GitHub, GitLab).

Instalar o Git no computador

Windows

Baixe o instalador em git-scm.com/download/win e execute. Ou use: winget install Git.Git ou choco install git (Chocolatey).

Mac

Instale as ferramentas de linha de comando do Xcode (já inclui Git) ou use Homebrew: brew install git.

Linux

Ubuntu/Debian: sudo apt update && sudo apt install git. Fedora: sudo dnf install git. Verifique depois com git --version.

Configurar um novo repositório

Identidade (uma vez por máquina)

git config --global user.name "Seu Nome"
git config --global user.email "seu@email.com"

Criar repositório novo (local)

cd pasta-do-projeto
git init

Isso cria a pasta .git e o repositório passa a ser versionado.

Clonar repositório existente

git clone https://github.com/usuario/repo.git
cd repo

Arquivo .gitignore

Liste arquivos e pastas que o Git deve ignorar (não versionar), um por linha. Exemplo:

node_modules/
.env
*.log
dist/

Comandos Git principais

git status

Mostra arquivos modificados, novos e em staging.

git add arquivo ou git add .

Adiciona alterações ao staging (prontas para commit).

git commit -m "mensagem"

Cria um commit com as alterações em staging.

git push

Envia commits locais para o repositório remoto.

git pull

Baixa e integra alterações do remoto no seu branch atual.

git branch

Lista branches. git branch nome cria um novo branch.

git checkout branch ou git switch branch

Muda para o branch indicado.

git merge branch

Integra o branch indicado no branch atual.

git log

Mostra o histórico de commits.

git remote -v

Lista os remotos configurados (ex.: origin).

git fetch remoto

Baixa referências e objetos do remoto sem integrar no branch atual.

Resolver problemas comuns no Git

Conflitos de merge

Quando duas alterações tocam a mesma parte do arquivo, o Git marca conflitos. Abra o arquivo, procure por <<<<<<<, =======, >>>>>>>, edite para ficar como deseja, depois:

git add arquivo
git commit -m "Resolve conflito em arquivo"

Desfazer o último commit (mantendo alterações)

git reset --soft HEAD~1

O commit some; as alterações continuam em staging.

Desfazer o último commit (descartando alterações)

git reset --hard HEAD~1

Cuidado: as alterações do último commit são perdidas.

Recuperar um arquivo de um commit anterior

git checkout COMMIT_HASH -- caminho/do/arquivo

Ou com Git mais recente: git restore --source=COMMIT_HASH -- caminho/do/arquivo

Descartar mudanças locais em um arquivo

git checkout -- arquivo
git restore arquivo

Revert vs Reset

revert: cria um novo commit que desfaz um commit anterior. Seguro para histórico já compartilhado (já enviado com push).

reset: reescreve o histórico local. Use apenas em branches que ainda não foram compartilhados ou quando souber o que está fazendo.

Git – Perguntas e respostas

Respostas diretas para as dúvidas mais comuns. Linguagem simples para você seguir passo a passo.

git clone https://github.com/usuario/nome-do-repo.git
cd nome-do-repo

git status
git add .
git commit -m "Descrição do que você fez"
git push

git add nome-do-arquivo
git commit -m "Resolvi o conflito em nome-do-arquivo"

Python – Introdução

Python é uma linguagem de programação que prioriza clareza e simplicidade. Você escreve menos código para fazer coisas úteis.

Onde instalar

Baixe em python.org/downloads. No instalador do Windows, marque “Add Python to PATH”. No Mac/Linux costuma vir instalado ou use: brew install python3 (Mac) ou sudo apt install python3 (Ubuntu).

Primeiro programa

Crie um arquivo ola.py com:

print("Olá, mundo!")

No terminal, na pasta do arquivo, rode:

python ola.py

(No Mac/Linux pode ser python3 ola.py.) A mensagem aparece na tela.

Python – Variáveis e tipos

Variáveis guardam valores. Você dá um nome e atribui com =. Python entende números, texto (entre aspas) e verdadeiro/falso (True/False).

idade = 15
nome = "Maria"
aprovado = True

Para pedir algo ao usuário, use input(). O que ele digitar volta como texto (string):

resposta = input("Qual sua idade? ")
print("Você tem", resposta, "anos.")

Se precisar do valor como número, converta: int(resposta) ou float(resposta).

Python – Operadores

Matemáticos: +, -, *, /, // (divisão inteira), % (resto), ** (potência).

Comparação: == (igual), != (diferente), <, >, <=, >=. O resultado é True ou False.

Lógica: and, or, not. Ex.: idade >= 18 and tem_carteira.

a = 10
b = 3
print(a // b)   # 3
print(a % b)   # 1
print(a == 10) # True

Python – Condicionais

Use if, elif e else para decidir o que o programa faz conforme uma condição.

nota = float(input("Sua nota: "))
if nota >= 7:
    print("Aprovado!")
elif nota >= 5:
    print("Recuperação.")
else:
    print("Reprovado.")

A indentação (espaços no início da linha) define o que pertence ao if. Use 4 espaços e seja consistente.

Python – Repetição (for e while)

for repete para cada item de uma sequência (lista, range, etc.):

for i in range(5):
    print(i)   # 0, 1, 2, 3, 4

nomes = ["Ana", "Bruno", "Carla"]
for nome in nomes:
    print("Olá,", nome)

while repete enquanto a condição for verdadeira:

contador = 0
while contador < 3:
    print(contador)
    contador += 1

Python – Listas

Lista é uma sequência ordenada de itens entre colchetes. O primeiro índice é 0.

frutas = ["maçã", "banana", "laranja"]
print(frutas[0])      # maçã
print(frutas[-1])     # último: laranja
frutas.append("uva")  # adiciona no fim
print(frutas[1:3])    # fatia: ["banana", "laranja"]

Outros métodos úteis: .insert(i, x), .remove(x), .pop(), len(lista).

Python – Strings

Strings são texto. Você pode concatenar com +, repetir com *, fatiar como lista e usar f-strings para formatar:

nome = "Python"
print(f"Olá, {nome}!")           # Olá, Python!
print("Oi " + nome)              # Oi Python
print(nome.upper())              # PYTHON
print("  texto  ".strip())       # texto
print("a,b,c".split(","))        # ["a", "b", "c"]

Python – Funções

Função é um bloco de código com nome que você pode chamar várias vezes. Defina com def, parâmetros entre parênteses e return para devolver um valor.

def saudar(nome):
    return "Olá, " + nome + "!"

print(saudar("Maria"))  # Olá, Maria!

def soma(a, b):
    return a + b
print(soma(3, 5))  # 8

Python – Dicionários e sets

Dicionário guarda pares chave–valor. Use quando precisar “procurar por nome”:

pessoa = {"nome": "Ana", "idade": 20, "cidade": "SP"}
print(pessoa["nome"])   # Ana
pessoa["idade"] = 21
pessoa["email"] = "ana@email.com"

Set é um conjunto de itens únicos, sem ordem. Útil para remover duplicatas ou testar “está dentro?”:

numeros = {1, 2, 2, 3, 3}
print(numeros)  # {1, 2, 3}

Python – Estruturas de dados

Tupla é como uma lista, mas imutável (não dá para alterar depois de criar). Use parênteses:

coordenadas = (10, 20)
print(coordenadas[0])  # 10

Lista de listas (matriz): cada elemento é outra lista:

matriz = [[1, 2], [3, 4]]
print(matriz[1][0])  # 3

Python – Módulos e import

Módulo é um arquivo com funções e variáveis que você pode reutilizar. Use import nome_do_arquivo (sem o .py) ou from nome import funcao.

import math
print(math.sqrt(16))  # 4.0

from math import pi
print(pi)

Para criar seu módulo: faça um arquivo meu_modulo.py com funções; no outro arquivo, import meu_modulo e use meu_modulo.minha_funcao().

Python – Arquivos

Abra arquivos com open(). Use with para fechar automaticamente ao terminar:

with open("arquivo.txt", "r", encoding="utf-8") as f:
    conteudo = f.read()
    print(conteudo)

with open("saida.txt", "w", encoding="utf-8") as f:
    f.write("Primeira linha\n")
    f.write("Segunda linha\n")

"r" = leitura, "w" = escrita (apaga o que tinha), "a" = anexar. f.readlines() devolve uma lista de linhas.

Python – Tratamento de erros

Use try e except para não deixar o programa “cair” quando acontecer um erro:

try:
    numero = int(input("Digite um número: "))
    print("O dobro é", numero * 2)
except ValueError:
    print("Isso não é um número válido.")

Assim, se o usuário digitar texto, você trata e mostra uma mensagem em vez de dar erro. Pode usar except Exception para pegar qualquer erro (use com cuidado).

Python – List comprehensions

É uma forma curta de criar uma lista a partir de outra (ou de um range), aplicando uma expressão e opcionalmente um filtro:

quadrados = [x**2 for x in range(1, 6)]
# [1, 4, 9, 16, 25]

pares = [n for n in range(10) if n % 2 == 0]
# [0, 2, 4, 6, 8]

Equivale a um for que append na lista, mas em uma linha. Use quando deixar o código mais legível.

Python – Orientação a objetos

Classe é um “molde” que agrupa dados (atributos) e ações (métodos). O __init__ é o construtor: roda quando você cria um objeto.

class Pessoa:
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade

    def apresentar(self):
        print(f"Sou {self.nome} e tenho {self.idade} anos.")

p = Pessoa("Ana", 20)
p.apresentar()  # Sou Ana e tenho 20 anos.

self representa a própria instância. Todo método de instância recebe self como primeiro parâmetro.

Python – Herança

Uma classe pode herdar de outra e reutilizar ou sobrescrever métodos:

class Animal:
    def __init__(self, nome):
        self.nome = nome
    def falar(self):
        print("...")

class Cachorro(Animal):
    def falar(self):
        print("Au au!")

Cachorro herda de Animal. O método falar foi sobrescrito. Você pode chamar o da classe pai com super().falar().

Python – Datas e tempo

Use o módulo datetime para trabalhar com data e hora:

from datetime import datetime, date, timedelta

hoje = date.today()
print(hoje)  # 2025-02-04

agora = datetime.now()
print(agora.strftime("%d/%m/%Y %H:%M"))

# Diferença de dias
daqui_uma_semana = hoje + timedelta(days=7)

strftime formata a data como string. strptime faz o contrário (string → data).

Python – Requisições HTTP

Para buscar dados de uma API ou site, use a biblioteca requests. Instale com pip install requests.

import requests
r = requests.get("https://api.github.com/users/octocat")
dados = r.json()
print(dados["name"])

r.json() converte a resposta em dicionário (se for JSON). r.status_code é o código HTTP (200 = OK). Sempre trate erros (conexão, 404, etc.) em programas reais.

Python – Ambiente virtual (venv)

Um ambiente virtual isola as bibliotecas do projeto para não misturar com outros. Crie na pasta do projeto:

python -m venv venv

Ative: no Windows venv\Scripts\activate, no Mac/Linux source venv/bin/activate. O prompt mostra (venv). Instale o que precisar: pip install requests. Para salvar as dependências:

pip freeze > requirements.txt

Em outro computador: pip install -r requirements.txt para instalar as mesmas versões.

Arquitetura de soluções – O que é arquitetura

No contexto de software, arquitetura é a forma como as partes do sistema se conectam e se organizam: quem fala com quem, onde ficam os dados, como o usuário acessa o sistema. Pensar em arquitetura ajuda a construir algo que funcione bem, escale e seja fácil de manter.

Cliente e servidor / Front-end e back-end

Cliente é quem pede (o navegador, o app no celular). Servidor é quem responde (o computador que guarda a lógica e os dados). A comunicação entre os dois segue regras (protocolos como HTTP).

Front-end é o que o usuário vê e interage (telas, botões, formulários). Back-end é a parte que roda no servidor: regras de negócio, banco de dados, APIs. Um site completo tem os dois.

O que é uma API

API (Application Programming Interface) é uma “porta” que um sistema expõe para outro sistema falar com ele. O site chama a API para buscar dados (ex.: lista de produtos, previsão do tempo) em vez de acessar o banco direto. A API devolve dados em formato padrão, em geral JSON.

Exemplo: o front-end do seu site faz uma requisição “GET /produtos” e o back-end responde com a lista em JSON. Assim o front só precisa saber a URL e o formato da resposta.

Banco de dados

Banco de dados serve para guardar dados de forma organizada e durável. Em um banco relacional, os dados ficam em tabelas (linhas e colunas). Você faz consultas (queries) para ler, inserir, atualizar ou apagar. Ex.: “todos os usuários com idade > 18”, “inserir um novo pedido”.

Em linguagem simples: é como uma planilha que vários programas podem usar ao mesmo tempo, com regras para não corromper os dados.

Escalabilidade

Escalabilidade é a capacidade do sistema de aguentar mais usuários ou mais carga sem quebrar. Escalar verticalmente = colocar mais CPU/RAM no mesmo servidor. Escalar horizontalmente = colocar mais servidores e dividir o trabalho entre eles. Horizontal costuma ser mais flexível a longo prazo.

Cache

Cache é uma cópia temporária de dados em um lugar mais rápido de acessar. Em vez de ir ao banco toda vez, o sistema guarda o resultado da primeira consulta (ex.: lista de produtos) na memória ou em um serviço de cache. As próximas requisições usam essa cópia até ela expirar ou ser atualizada.

Reduz idas ao banco e deixa a resposta mais rápida. O desafio é invalidar o cache quando os dados mudam.

Filas e mensageria

Quando uma tarefa é pesada ou demorada (ex.: enviar e-mail, gerar relatório), em vez de fazer na hora da requisição (e deixar o usuário esperando), o sistema coloca uma “mensagem” numa fila. Um worker (processo em segundo plano) pega as mensagens da fila e executa as tarefas. Assim o usuário recebe resposta rápida e o trabalho pesado roda em background.

Segurança básica

HTTPS: tráfego criptografado entre cliente e servidor para ninguém espionar no meio do caminho. Senhas: nunca guardar em texto puro; usar hash (ex.: bcrypt) e comparar o hash na hora do login. Autenticação = “quem é você?” (login). Autorização = “o que você pode fazer?” (permissões, roles).

Microsserviços vs monolito

Monolito: um único sistema (um deploy) com todas as funcionalidades. Mais simples de começar; pode ficar difícil de evoluir quando o time e o código crescem. Microsserviços: o sistema é dividido em vários serviços menores, cada um com uma responsabilidade (ex.: usuários, pedidos, pagamentos). Cada um pode ser desenvolvido e implantado de forma mais independente; a complexidade passa para a rede, monitoramento e consistência entre serviços.

Escolha conforme o tamanho do projeto e do time; não é obrigatório começar com microsserviços.

Resiliência e falhas

Resiliência é o sistema continuar funcionando (ou se recuperando) quando algo falha. Retry: tentar de novo após uma falha temporária. Circuit breaker: depois de muitas falhas seguidas, “abre o circuito” e para de chamar o serviço que está fora; depois de um tempo tenta de novo. Assim uma falha em cascata não derruba tudo.

Observabilidade

É conseguir entender o que está acontecendo no sistema em produção. Três pilares: logs (registro de eventos e erros), métricas (números: requisições por segundo, uso de CPU, latência) e rastreamento (seguir uma requisição por vários serviços). Com isso você descobre bugs, gargalos e comportamentos estranhos.

Cloud – O que é computação em nuvem

Computação em nuvem é usar serviços de computador pela internet: servidores, armazenamento, banco de dados, etc. Você não precisa comprar e manter máquinas; paga pelo que usar (ou um plano). Exemplos de provedores: AWS, Google Cloud, Azure, e serviços como Netflix e Spotify que rodam na nuvem.

Cloud – IaaS, PaaS e SaaS

IaaS (Infrastructure as a Service): você recebe máquinas virtuais, rede, disco; instala e gerencia o que quiser (OS, aplicação). Ex.: AWS EC2. PaaS (Platform as a Service): a plataforma já oferece ambiente para rodar sua aplicação (ex.: Heroku, App Engine); você sobe o código. SaaS (Software as a Service): o software pronto, usado pela internet (Gmail, Notion, Slack).

Cloud – Regiões e disponibilidade

Provedores têm regiões (datacenters em lugares do mundo, ex.: São Paulo, Virgínia). Onde os dados e as aplicações ficam importa: latência (usuário perto da região = mais rápido), leis de privacidade e custo. Disponibilidade é ter redundância (mais de um datacenter) para o serviço não cair se um falhar.

Cloud – Servidores virtuais

Um servidor virtual (ex.: EC2 na AWS) é uma “máquina” que você sobe na nuvem: escolhe o sistema operacional, CPU e memória, e instala sua aplicação. Use quando precisar de controle total ou rodar algo que não se encaixa em PaaS ou serverless. Você é responsável por atualizações e segurança do OS.

Cloud – Armazenamento

Objeto (ex.: S3): guarda arquivos (fotos, vídeos, backups) com um nome (chave) e metadados. Acesso por URL ou API. Disco: volume ligado à máquina virtual, como um HD. Banco gerenciado: serviço de banco de dados (relacional ou NoSQL) que o provedor opera; você só configura e usa. Escolha conforme: muitos arquivos soltos → objeto; disco da VM → volume; dados estruturados → banco gerenciado.

Cloud – Rede (VPC)

VPC (Virtual Private Cloud) é sua rede isolada na nuvem: você define sub-redes (blocos de IP), onde ficam as máquinas e como se comunicam. Grupos de segurança (firewall) controlam quem pode acessar o quê (portas, origens). Em linguagem simples: você desenha a “rua” e as “fechaduras” dos seus recursos para só o necessário ter acesso.

Cloud – Serverless

Serverless (funções como serviço, ex.: AWS Lambda) é rodar código em resposta a eventos (uma requisição HTTP, um arquivo que chegou, um horário) sem você gerenciar servidor. Você só escreve a função e define quando ela dispara; o provedor escala e cobra por execução. Bom para APIs leves, processamento sob demanda e automações.

Cloud – Containers

Container (ex.: Docker) é uma forma de empacotar sua aplicação com tudo que ela precisa (código, bibliotecas, config) em uma “caixa” que roda igual em qualquer lugar. Na nuvem, você pode rodar containers em serviços gerenciados (ex.: ECS, Kubernetes). Ideia: “empacote uma vez, rode em qualquer lugar”; facilita deploy e escalonamento.

Cloud – DevOps e CI/CD

DevOps na nuvem é usar ferramentas para integrar desenvolvimento e operação: código no repositório, testes e deploy automáticos. CI/CD: ao dar push, o pipeline (na nuvem ou em ferramentas como GitHub Actions) roda testes, faz o build e faz o deploy. Conecta com a ideia de “pipeline” do Git: commit → build → deploy em produção, tudo automatizado.

Cloud – Custos e boas práticas

Na nuvem você paga pelo que usa. Boas práticas: usar tags nos recursos para saber quanto cada projeto custa; configurar alertas quando o gasto passar de um limite; desligar ou redimensionar o que não está sendo usado; escolher o tipo certo de recurso (ex.: instâncias spot mais baratas para cargas que podem ser interrompidas). “Não deixar recurso ligado à toa” evita surpresas na fatura.

IA – O que é IA e o que é LLM

Inteligência artificial (IA) é a área que tenta fazer máquinas realizarem tarefas que normalmente exigiriam inteligência humana: entender texto, reconhecer imagens, responder perguntas, tomar decisões a partir de dados.

Um LLM (Large Language Model, modelo de linguagem grande) é um tipo de IA treinado em muito texto. Ele "prevê" a próxima palavra (ou pedaço de texto) a partir do contexto. Por isso consegue completar frases, responder perguntas, escrever código ou resumir um texto quando você dá um prompt (pergunta ou instrução). Ele não "sabe" como um humano; ele gera texto coerente com o que aprendeu.

IA – O que é um prompt

O prompt é o texto que você envia para o modelo: a pergunta, a instrução ou o contexto que você dá para ele gerar uma resposta. Pode ser curto ("O que é Python?") ou longo (um parágrafo explicando o problema e pedindo um código).

O modelo usa o prompt como entrada e "continua" o texto a partir dele. Por isso ser claro e específico no prompt faz toda a diferença: quanto melhor você descrever o que quer, melhor tende a ser a resposta.

IA – Como escrever bons prompts

Dicas:

• Contexto: Diga em poucas palavras o cenário (ex.: "Sou iniciante em Python", "É para um trabalho da escola").
• Tarefa clara: Uma instrução direta ("Escreva uma função que…", "Explique em 3 tópicos").
• Formato desejado: Liste, parágrafo, código, tabela. Ex.: "Responda em tópicos" ou "Devolva só o código, sem explicação".
• Exemplos (few-shot): Mostre um exemplo do que você quer. Ex.: "Traduza para inglês: [frase 1] → [tradução 1]. Agora traduza: [frase 2]".

Evite perguntas vagas ("fala sobre programação"). Se a resposta vier errada, refine: "Na verdade quero só a sintaxe em Python" ou "Explique sem usar jargão".

IA – Usar o GPT (ChatGPT) da melhor forma

Organize a conversa: Use threads separadas para assuntos diferentes; assim o modelo não mistura contexto.

Refine com follow-up: Se a resposta não for o que você queria, peça de novo de forma mais específica ("em português", "mais curto", "com um exemplo").

Busca vs modelo: Para fatos atuais, datas ou notícias, a busca na web (quando o ChatGPT tem essa opção) pode complementar; o modelo tem uma "data de corte" e não sabe tudo depois disso.

Limites: O modelo pode inventar detalhes (alucinar). Para coisas críticas, confira em outra fonte. Use para ideias, rascunhos e explicações, e ajuste o que fizer sentido.

IA – Cursor

Cursor é um editor de código (IDE) que integra IA no fluxo de programação. Você escreve código e usa a IA para completar, explicar, refatorar ou gerar trechos a partir de instruções em linguagem natural.

Uso no dia a dia: Completar linha ou bloco (autocomplete inteligente), abrir um chat para perguntar "o que faz essa função?" ou "refatore isso para usar async", pedir que a IA edite o arquivo seguindo suas instruções. Você pode selecionar trechos e pedir mudanças só naquela parte.

Boas práticas: Seja claro no que pede; use atalhos para aceitar sugestões ou abrir o chat; mantenha o projeto e os arquivos abertos com contexto relevante para a IA responder melhor.

IA – Claude

Claude é um assistente de IA (modelo de linguagem) criado pela Anthropic. Você pode usar no site claude.ai ou em integrações (APIs, apps, outras ferramentas).

Assim como outros LLMs, ele responde a prompts, explica conceitos, ajuda a escrever texto ou código. As diferenças estão no "estilo" da resposta, no tamanho do contexto (quantos tokens ele "enxerga" de uma vez) e em recursos específicos (ex.: análise de documentos longos). Vale testar e comparar com o GPT para ver qual se encaixa melhor no que você precisa.

IA – Outras ferramentas (Antigravity, etc.)

Além de Cursor e Claude, existem várias ferramentas que usam IA para automação, código e assistência. Antigravity e outras do tipo permitem automatizar tarefas ou conectar modelos a fluxos de trabalho.

O ecossistema muda rápido: assistentes de código (GitHub Copilot, Codeium), chatbots (ChatGPT, Claude, Gemini), ferramentas de voz (Whisper, Kokoro), e projetos open source para rodar modelos localmente (Ollama, LM Studio). O importante é saber o que você quer (escrever código, transcrever áudio, rodar um modelo na sua máquina) e escolher a ferramenta que atende. Mantenha-se curioso e acompanhe o que já é conhecido e útil na sua área.

IA – Por que rodar uma LLM local

Rodar um modelo na sua máquina (local) tem vantagens: privacidade (os dados não saem do seu PC), custo (depois de instalar, não paga por uso), uso offline e controle (você escolhe o modelo e a versão).

Faz sentido quando você não quer enviar código ou textos sensíveis para a nuvem, ou quando quer experimentar sem depender de internet ou de limite de requisições. O trade-off é que modelos grandes exigem bastante RAM (e, de preferência, GPU); para máquinas mais modestas, use modelos menores (ex.: 7B parâmetros).

IA – Como rodar uma LLM local (open source)

Opções populares:

• Ollama: Instale em ollama.com. No terminal: ollama run nome-do-modelo (ex.: llama3.2, mistral). Você conversa no terminal; também dá para usar via API local.
• LM Studio: Interface gráfica para baixar e rodar modelos. Bom para quem prefere não usar linha de comando.
• llama.cpp: Projeto que roda modelos no seu PC (CPU ou GPU). Mais técnico; usado por várias ferramentas por baixo dos panos.

Requisitos: RAM: 8 GB no mínimo para modelos pequenos; 16 GB ou mais para modelos maiores. GPU com bastante VRAM acelera. Comece com um modelo "7B" para testar.

# Exemplo com Ollama (após instalar)
ollama pull llama3.2
ollama run llama3.2

IA – Estruturas e projetos para sua própria LLM

Além do Ollama e do LM Studio, existem projetos open source que ajudam a servir ou integrar um modelo local: expor uma API na sua máquina (para um app ou script chamar), conectar a um front-end de chat, ou rodar em servidor. Exemplos: llama.cpp com bindings em Python, text-generation-webui (interface para conversar e baixar modelos), e documentação dos próprios repositórios (Ollama, LM Studio) para API local.

Vale explorar o GitHub em buscas como "local LLM API" ou "self-hosted LLM" e ler o README dos projetos para ver requisitos e como rodar.

IA – Whisper (voz para texto)

Whisper é um modelo open source da OpenAI para reconhecimento de fala: transforma áudio em texto (transcrição). Funciona offline e em vários idiomas.

Como usar: Instale (ex.: pip install openai-whisper ou use o repositório oficial no GitHub). Pela linha de comando você pode passar um arquivo de áudio e receber o texto. Em código, carregue o áudio, rode o modelo e leia a transcrição.

# Exemplo de uso via linha de comando (Whisper instalado)
# whisper audio.mp3 --model base

Use para: transcrever reuniões, legendas, ou como primeira etapa de um fluxo "voz → texto → LLM → resposta".

IA – Kokoro (texto para voz)

Kokoro é um projeto de síntese de fala (TTS – text-to-speech): transforma texto em áudio, ou seja, "a IA responde por voz". É open source e pode ser usado localmente.

Você passa um texto e o modelo gera um arquivo de áudio (ou stream) com a fala. Assim você monta um pipeline: a LLM gera a resposta em texto e o Kokoro (ou outro TTS) transforma em voz para tocar no alto-falante. Projetos que integram LLM + Whisper + Kokoro permitem "conversa por voz" totalmente local: você fala, o Whisper transcreve, a LLM responde, o Kokoro fala.

Procure no GitHub por "Kokoro TTS" ou "Kokoro speech" para instruções de instalação e uso.

IA – Montando um fluxo: LLM + voz

O fluxo completo de "conversa por voz" com IA local pode ser:

1. Microfone → áudio da sua fala.
2. Whisper → transcreve o áudio em texto.
3. LLM local (ex.: via Ollama) → recebe o texto, gera a resposta em texto.
4. Kokoro (ou outro TTS) → transforma o texto da resposta em áudio.
5. Alto-falante → toca o áudio.

Você pode implementar esse pipeline em um script (Python, por exemplo): capturar áudio, chamar Whisper, enviar o texto para a API da LLM local, pegar a resposta e enviar para o Kokoro, e reproduzir o áudio. Projetos open source já fazem isso; vale procurar "local voice assistant" ou "LLM + Whisper + TTS".