Folha IA
Folha IA
Início/Zé Mané — Prompts Mestre
Zé Mané — Prompts Mestre

Prompts Mestre: AI Guard Pro – IA Local com Privacidade e Controle Total para Empresas

(há 8 dias)
Prompts Mestre: AI Guard Pro – IA Local com Privacidade e Controle Total para Empresas

E aí, galera da engenharia e da gambiarra bem-feita! Zé Mané na área, e hoje a gente vai desmistificar a construção de um SaaS que é puro ouro: o AI Guard Pro. O Alfredo, nosso CEO visionário, jogou a ideia no ar, e o Zé aqui já traduziu tudo em prompts cirúrgicos e uma arquitetura de respeito. Preparem-se para o banho de loja técnico!

1. O Projeto em 30 Segundos

O AI Guard Pro é a solução definitiva para empresas que precisam da inteligência do Llama 3 (e outros LLMs) localmente, com privacidade inabalável e controle total dos dados. Esqueça a paranoia da nuvem e a complexidade de configurar infraestrutura de ML. Nosso SaaS oferece uma interface simplificada para gerenciar e interagir com LLMs rodando no hardware do cliente, garantindo soberania de dados para setores como jurídico, saúde e financeiro. É a IA poderosa, segura e na sua casa, sem a necessidade de um PhD em Machine Learning.

2. Arquitetura Recomendada

A arquitetura do AI Guard Pro é um balé entre o cliente (browser), o backend da plataforma SaaS (nuvem) e o AI Local Agent (no hardware do cliente). O segredo é manter os dados sensíveis no cliente, enquanto a plataforma SaaS gerencia licenças, atualizações e a interface de usuário.

Mermaid Error: Parse error on line 2: ... subgraph Cliente (Browser) A[ -----------------------^ Expecting 'SEMI', 'NEWLINE', 'SPACE', 'EOF', 'GRAPH', 'DIR', 'subgraph', 'SQS', 'end', 'AMP', 'COLON', 'START_LINK', 'STYLE', 'LINKSTYLE', 'CLASSDEF', 'CLASS', 'CLICK', 'DOWN', 'UP', 'NUM', 'NODE_STRING', 'BRKT', 'MINUS', 'MULT', 'UNICODE_TEXT', got 'PS'

Show Code
graph TD
    subgraph Cliente (Browser)
        A[Next.js/Remix App]
        B[Interface de Usuário]
        C[Comunicação Segura (WebSocket/tRPC)]
    end

    subgraph Plataforma SaaS (Vercel/Cloudflare)
        D[Edge Functions/API Gateway]
        E[tRPC Backend]
        F[Auth (Clerk/Auth.js)]
        G[Database (Supabase/PlanetScale)]
        H[Storage (R2/S3)]
        I[Licenciamento & Atualizações]
    end

    subgraph Hardware do Cliente (Rede Local)
        J[AI Local Agent (Docker/Binário)]
        K[LocalAI/Ollama]
        L[Modelos LLM (Llama 3)]
        M[Dados Sensíveis da Empresa]
        N[API Local Segura (gRPC/REST)]
    end

    A -- Requisições UI --> B
    B -- Chamadas tRPC/API --> D
    D -- Autenticação/Autorização --> F
    D -- Acesso a Dados --> G
    D -- Gerenciamento de Agentes --> I
    A -- WebSocket/Polling Seguro --> N
    N -- Gerencia --> K
    K -- Carrega --> L
    K -- Processa --> M
    J -- Orquestra --> K
    J -- Comunicação Segura --> C
    I -- Distribui Configs/Updates --> J

Explicação da Arquitetura:

  • Cliente (Browser): Uma aplicação web moderna (Next.js/Remix) que serve como a interface principal. Ela se comunica com o backend SaaS para gerenciamento de conta e com o AI Local Agent via conexão segura (WebSockets ou polling) para interações com o LLM.
  • Plataforma SaaS (Vercel/Cloudflare): O coração da gestão. Um backend robusto (tRPC, Drizzle ORM, Supabase/PlanetScale) hospedado em infraestrutura serverless/edge. Ele cuida de autenticação (Clerk/Auth.js), licenciamento, provisionamento de configurações para o AI Local Agent e monitoramento de status (sem acessar dados sensíveis).
  • Hardware do Cliente (Rede Local): Aqui reside o segredo da privacidade. O AI Local Agent é um serviço (Docker container ou binário) que roda no servidor ou máquina do cliente. Ele orquestra a execução de LLMs (via LocalAI, Ollama ou similar) e expõe uma API local segura. Os modelos (Llama 3, etc.) e, crucialmente, os dados sensíveis da empresa, nunca saem deste ambiente. A comunicação entre o browser do cliente e o AI Local Agent é direta e segura, sem passar pela nuvem da plataforma SaaS para o tráfego de dados sensíveis.

3. Prompts Mestre por Categoria

Aqui a mágica acontece. Cada prompt é uma receita de bolo para a IA, com todos os ingredientes e passos detalhados.

🏗️ Prompts de Arquitetura & Backend

Estes prompts focam na espinha dorsal do nosso SaaS e na orquestração do AI Local Agent.

prompt
## Prompt para Claude/GPT-4/Gemini

**Contexto:** Estamos construindo o backend da plataforma SaaS "AI Guard Pro" usando Next.js 14 (App Router), tRPC, Drizzle ORM com PlanetScale (MySQL) e Vercel Edge Functions. O objetivo é gerenciar usuários, assinaturas, licenças para o AI Local Agent e configurações de deployment, sem tocar nos dados sensíveis dos clientes.

**Papel:** Arquiteto de Backend Sênior.

**Tarefa:** Projete o esquema do banco de dados e as definições de API tRPC para os módulos de autenticação, gerenciamento de usuários, assinaturas e licenças do AI Local Agent.

**Formato de Saída:**
1.  **Esquema Drizzle ORM (TypeScript):** Definição de tabelas `users`, `subscriptions`, `agent_licenses` e `agent_deployments`. Inclua campos como `id`, `email`, `stripeCustomerId`, `status`, `licenseKey`, `agentVersion`, `deploymentConfig`.
2.  **Definições de API tRPC (TypeScript):** Crie um `appRouter.ts` com procedures para:
    *   `auth.signup`: Registro de novo usuário.
    *   `auth.login`: Login de usuário.
    *   `user.getProfile`: Obter dados do perfil do usuário.
    *   `subscription.createCheckoutSession`: Criar sessão de checkout Stripe.
    *   `subscription.getSubscriptionStatus`: Verificar status da assinatura.
    *   `agent.generateLicenseKey`: Gerar uma nova chave de licença para um agente.
    *   `agent.getDeploymentConfig`: Obter a configuração de deployment para um agente específico (dado a licenseKey).
    *   `agent.reportStatus`: Endpoint para o AI Local Agent reportar seu status (online, versão, etc.).
3.  **Explicação:** Breve justificativa das escolhas de design e considerações de segurança.

**Restrições:**
*   Use `drizzle-orm` e `drizzle-kit` para o esquema.
*   As APIs devem ser type-safe com tRPC.
*   Considere o uso de `next-auth` ou `clerk` para autenticação (mas o esquema Drizzle deve ser compatível).
*   Não inclua lógica de negócio complexa, apenas as definições.
*   A chave de licença deve ser um UUID v4.
*   O `deploymentConfig` deve ser um JSONB (ou equivalente MySQL) para flexibilidade.
prompt
## Prompt para Cursor AI/GPT-4

**Contexto:** Precisamos de um esqueleto de um "AI Local Agent" que rodará no hardware do cliente. Ele deve ser capaz de: 1. Receber uma chave de licença para ativação. 2. Baixar e gerenciar modelos LLM (e.g., Llama 3) usando Ollama ou LocalAI. 3. Expor uma API local segura (gRPC ou REST) para o frontend do cliente interagir com os LLMs. 4. Reportar seu status periodicamente ao backend SaaS.

**Papel:** Engenheiro de Software Sênior (Go/Rust/Python).

**Tarefa:** Crie a estrutura de um projeto para o AI Local Agent.

**Formato de Saída:**
1.  **Estrutura de Diretórios:** Proponha uma estrutura de pastas para um projeto Go (ou Rust/Python, sua escolha).
2.  **Arquivos Chave (com snippets):**
    *   `main.go` (ou equivalente): Ponto de entrada, inicialização do servidor local, carregamento de configuração.
    *   `config.go`: Carregamento e validação da chave de licença e outras configurações.
    *   `llm_manager.go`: Interface para interagir com Ollama/LocalAI (baixar modelos, carregar, inferir). Inclua um método `LoadModel(modelName string)` e `GenerateResponse(prompt string) string`.
    *   `api_server.go`: Implementação da API local (gRPC ou REST) para o frontend. Inclua um endpoint `/chat` para inferência LLM e `/status` para o status do agente.
    *   `saas_reporter.go`: Lógica para reportar o status ao backend SaaS (HTTP POST para `/api/agent/reportStatus`).
3.  **Docker Compose (opcional):** Um `docker-compose.yml` para rodar o agente com Ollama/LocalAI.

**Restrições:**
*   Foque na estrutura e nas interfaces, não na implementação completa da lógica de inferência.
*   A API local deve ser protegida por uma chave de API ou token local.
*   A comunicação com o backend SaaS deve usar HTTPS.
*   Priorize a simplicidade e a segurança.

🎨 Prompts de Frontend & Design

Aqui vamos dar vida à interface do usuário, garantindo uma experiência minimalista, dark e altamente funcional.

prompt
## Prompt para v0.dev/Bolt.new/GPT-4 (para componentes)

**Contexto:** Estamos desenvolvendo a interface do "AI Guard Pro" usando Next.js 14, React 19, Tailwind CSS v4 e shadcn/ui. O estilo é minimalista dark.

**Papel:** Designer/Desenvolvedor Frontend.

**Tarefa:** Crie um componente `ChatInterface` que será o principal ponto de interação do usuário com o LLM local.

**Formato de Saída:**
1.  **Código React (TypeScript/TSX):** Um componente `ChatInterface` que inclui:
    *   Um `div` principal com fundo escuro e bordas arredondadas.
    *   Uma área de exibição de mensagens (scrollable), com balões de chat distintos para o usuário e para o LLM.
    *   Um `textarea` na parte inferior para entrada do usuário, com um botão "Enviar" (ou ícone de avião de papel).
    *   Um indicador de "digitando..." ou "gerando resposta..." quando o LLM estiver processando.
    *   Um seletor de modelo (dropdown) para escolher entre os LLMs disponíveis localmente.
    *   Um botão para "Limpar Conversa".
2.  **Estilização Tailwind CSS v4:** Classes Tailwind para implementar o estilo minimalista dark.
3.  **Uso de shadcn/ui:** Integre componentes como `Button`, `Input`, `Textarea`, `DropdownMenu` e `ScrollArea`.

**Restrições:**
*   Não inclua lógica de backend ou conexão real com o LLM, apenas o frontend estático.
*   Foco na responsividade e acessibilidade básica.
*   Use ícones da Lucide React.
*   O design deve ser "dark mode first".
prompt
## Prompt para Claude/GPT-4/Gemini

**Contexto:** A aplicação "AI Guard Pro" precisa de um layout de dashboard principal para gerenciar os AI Local Agents e as configurações da conta.

**Papel:** Arquiteto de Frontend.

**Tarefa:** Projete a estrutura de layout do dashboard principal.

**Formato de Saída:**
1.  **Código React (TypeScript/TSX):** Um componente `DashboardLayout` que inclui:
    *   Um `Sidebar` (menu lateral esquerdo) com links de navegação (e.g., "Meus Agentes", "Modelos LLM", "Configurações", "Assinatura").
    *   Um `Header` (barra superior) com o nome do aplicativo, um seletor de conta/usuário e talvez um botão de notificação.
    *   Uma área de conteúdo principal (`main` tag) onde as rotas aninhadas serão renderizadas.
2.  **Estilização Tailwind CSS v4:** Classes Tailwind para um layout flexível e responsivo.
3.  **Uso de shadcn/ui/Radix UI:** Utilize componentes para o menu, botões e dropdowns.

**Restrições:**
*   O layout deve ser responsivo para desktop e mobile (com sidebar recolhível no mobile).
*   A navegação deve ser simulada com `<Link>` do Next.js (sem lógica de roteamento real).
*   O design deve ser consistente com o tema dark minimalista.
*   Inclua um exemplo de `DashboardPage` que usa este layout.

🔍 Prompts de SEO & Schema.org

Para garantir que o AI Guard Pro seja encontrado pelas empresas certas, precisamos de um SEO técnico impecável.

prompt
## Prompt para GPT-4/Claude

**Contexto:** O site público do "AI Guard Pro" (landing page, blog, docs) precisa de otimização SEO para ranquear para termos como "LLM local", "Llama 3 privacidade", "IA dados sensíveis empresa".

**Papel:** Especialista em SEO Técnico e Marketing de Conteúdo.

**Tarefa:** Crie um conjunto de meta tags e dados estruturados Schema.org para a landing page principal do AI Guard Pro.

**Formato de Saída:**
1.  **Meta Tags Essenciais (HTML):**
    *   `<title>` otimizado.
    *   `<meta name="description">` persuasiva e rica em palavras-chave.
    *   `<meta name="keywords">` (opcional, mas bom para contexto).
    *   Open Graph (`og:title`, `og:description`, `og:image`, `og:url`, `og:type`) para compartilhamento social.
    *   Twitter Card (`twitter:card`, `twitter:site`, `twitter:title`, `twitter:description`, `twitter:image`).
    *   `<link rel="canonical">`.
2.  **Dados Estruturados Schema.org (JSON-LD):**
    *   `Organization` com `name`, `url`, `logo`, `sameAs` (redes sociais).
    *   `Product` para o "AI Guard Pro" com `name`, `description`, `sku`, `brand`, `offers` (simulando um plano básico), `aggregateRating` (simulado).
    *   `WebSite` com `name`, `url`, `potentialAction` (para Sitelinks Search Box).
3.  **Explicação:** Breve justificativa para cada escolha de tag e propriedade Schema.org, focando em como elas contribuem para E-E-A-T e rich snippets.

**Restrições:**
*   As palavras-chave devem ser relevantes para "LLM local", "privacidade de dados", "IA empresarial".
*   As descrições devem ser concisas e atraentes.
*   O JSON-LD deve ser válido e testável com o Rich Results Test do Google.
*   Assuma que a URL principal é `https://aiguardpro.com.br`.
prompt
## Prompt para GPT-4/Claude

**Contexto:** O AI Guard Pro terá um blog com artigos técnicos sobre privacidade de LLMs, deployment local, casos de uso para indústrias reguladas.

**Papel:** Especialista em SEO Técnico.

**Tarefa:** Defina a estratégia de sitemaps XML e `robots.txt` para o site do AI Guard Pro, incluindo o blog.

**Formato de Saída:**
1.  **Conteúdo do `robots.txt`:** Regras para permitir/disallow, `Sitemap` directive.
2.  **Estrutura de Sitemaps XML:**
    *   `sitemap_index.xml`: Índice principal.
    *   `sitemap_pages.xml`: Para páginas estáticas (home, sobre, contato, planos).
    *   `sitemap_blog.xml`: Para posts do blog.
    *   `sitemap_docs.xml`: Para a documentação técnica.
    *   Exemplo de entrada para cada tipo de sitemap.
3.  **Explicação:** Justifique a estrutura, como ela ajuda na crawlability e indexação, e como lidar com conteúdo dinâmico (se houver).

**Restrições:**
*   As URLs devem ser fictícias, mas representativas (e.g., `/blog/post-exemplo`).
*   O `robots.txt` deve ser permissivo para o conteúdo público e restritivo para áreas de admin.
*   Considere a frequência de atualização para cada sitemap.

⚡ Prompts de Performance & Core Web Vitals

Performance é crucial para a experiência do usuário e para o ranqueamento. Vamos otimizar cada milissegundo.

prompt
## Prompt para GPT-4/Claude

**Contexto:** A landing page e o dashboard do AI Guard Pro precisam atingir pontuações perfeitas no Lighthouse (90+ em Performance, Acessibilidade, Melhores Práticas, SEO).

**Papel:** Engenheiro de Performance Frontend.

**Tarefa:** Liste as otimizações de performance e Core Web Vitals (LCP, INP, CLS) mais críticas para uma aplicação Next.js 14 com Tailwind e shadcn/ui.

**Formato de Saída:**
1.  **Lista de Otimizações (com exemplos de código/config):**
    *   **LCP (Largest Contentful Paint):** Priorização de recursos (fontes, imagens hero), pré-carregamento, otimização de imagens (Next/Image, WebP/AVIF).
    *   **INP (Interaction to Next Paint):** Redução de JavaScript no thread principal, lazy loading de componentes e scripts, uso de `useTransition` e `useDeferredValue` do React.
    *   **CLS (Cumulative Layout Shift):** Dimensões explícitas para imagens/vídeos, carregamento de fontes com `font-display: optional` ou `swap`, pré-alocação de espaço para conteúdo dinâmico.
    *   **Geral:** Bundle splitting, critical CSS, edge caching (Vercel/Cloudflare), Service Workers para PWA.
2.  **Configuração `next.config.js`:** Exemplos de otimizações no arquivo de configuração do Next.js.
3.  **Explicação:** Detalhe como cada otimização afeta as métricas e a percepção do usuário.

**Restrições:**
*   Foque em técnicas aplicáveis a Next.js 14 e as tecnologias especificadas.
*   Não inclua otimizações de backend, apenas frontend.
*   Priorize o impacto nas Core Web Vitals.

🚀 Prompts de Deploy & DevOps

Automatizar o deployment e garantir a resiliência é essencial para um SaaS.

prompt
## Prompt para GPT-4/Claude

**Contexto:** O AI Guard Pro será implantado na Vercel para o frontend/backend SaaS e usará Cloudflare Workers/R2 para assets estáticos e funções de borda adicionais. O AI Local Agent será distribuído via Docker ou como binário.

**Papel:** Engenheiro de DevOps.

**Tarefa:** Crie um pipeline CI/CD simplificado para o frontend/backend SaaS e descreva o processo de distribuição e atualização do AI Local Agent.

**Formato de Saída:**
1.  **GitHub Actions Workflow (YAML):** Um arquivo `main.yml` para o pipeline CI/CD do monorepo (se houver) ou do projeto Next.js. Deve incluir:
    *   Trigger em `push` para `main` e `pull_request`.
    *   Instalação de dependências.
    *   Linting (ESLint).
    *   Testes (Jest/Vitest).
    *   Build da aplicação Next.js.
    *   Deploy para Vercel (com preview em PRs).
2.  **Estratégia de Distribuição do AI Local Agent:**
    *   Como o binário/imagem Docker será empacotado e versionado.
    *   Canais de distribuição (ex: Docker Hub privado, S3/R2 para binários).
    *   Mecanismo de atualização (ex: agente checa por nova versão no backend SaaS, download e reinício).
3.  **Monitoramento Básico:** Sugestões de ferramentas de monitoramento para a Vercel e para os agentes locais (ex: Sentry, Prometheus/Grafana para o agente).

**Restrições:**
*   Foque na automação e na segurança.
*   O pipeline CI/CD deve ser robusto, mas conciso.
*   A estratégia do AI Local Agent deve considerar a natureza "on-premise" e a necessidade de controle do cliente.

4. Prompt Único Completo

Este é o prompt nuclear, para quando você quer a IA trabalhando no modo "gênio da lâmpada".

prompt
## Prompt para GPT-4-Turbo/Claude 3 Opus/Gemini 1.5 Pro

**Contexto:** Construa o SaaS "AI Guard Pro".
**Problema:** Empresas precisam usar LLMs como Llama 3 localmente com privacidade, segurança e controle total dos dados, simplificando a complexidade técnica.
**Público-alvo:** Escritórios de advocacia, clínicas médicas, consultorias financeiras, PMEs com P&D.
**Stack:** Next.js 14 (App Router), React 19, tRPC, Drizzle ORM, PlanetScale (MySQL), Vercel, Cloudflare Workers/R2, Tailwind CSS v4, shadcn/ui, Radix UI. Para o agente local: Go/Rust com Ollama/LocalAI.
**Estilo de Design:** Minimalista Dark Mode First.
**Features Core:** Execução local de LLMs, Interface simplificada, Privacidade e segurança de dados, Controle total sobre modelos e dados, Solução para empresas sem equipe de ML.

**Papel:** Arquiteto de Soluções Full-Stack, Engenheiro de DevOps, Especialista em SEO e UX.

**Tarefa:** Gere um plano de projeto completo, incluindo:
1.  **Arquitetura Detalhada:** Diagrama Mermaid e explicação da comunicação entre Frontend (Next.js), Backend SaaS (tRPC/Drizzle/Vercel) e AI Local Agent (Go/Ollama no cliente). Descreva como a privacidade dos dados é mantida.
2.  **Esquema de Banco de Dados (Drizzle ORM TypeScript):** Para usuários, assinaturas, licenças de agente, e logs de status de agente.
3.  **Definições de API tRPC (TypeScript):** Para autenticação, gerenciamento de usuário/assinatura, e APIs de gerenciamento de agente (geração de licença, obtenção de configuração, reporte de status).
4.  **Componentes Frontend Chave (React/Tailwind/shadcn/ui):**
    *   `ChatInterface` para interação com LLM local.
    *   `AgentDashboard` para monitorar e configurar agentes locais.
    *   `SubscriptionManager` para gerenciar planos.
    *   Layout principal (dark mode, responsivo).
5.  **Esqueleto do AI Local Agent (Go):** Estrutura de diretórios e snippets para `main.go`, `llm_manager.go` (integração Ollama/LocalAI), `api_server.go` (API local segura), `saas_reporter.go`.
6.  **Estratégia de SEO Técnico:** Meta tags essenciais, JSON-LD (`Organization`, `Product`, `WebSite`), estrutura de sitemaps XML e `robots.txt` para a landing page e blog.
7.  **Plano de Performance:** Lista de otimizações para Core Web Vitals (LCP, INP, CLS) para Next.js.
8.  **Pipeline CI/CD (GitHub Actions YAML):** Para o frontend/backend SaaS.
9.  **Estratégia de Distribuição e Atualização do AI Local Agent:** Empacotamento, canais, e mecanismo de atualização.

**Formato de Saída:** Um documento Markdown bem estruturado com todos os itens acima, incluindo snippets de código onde apropriado.

**Restrições:**
*   Todos os snippets de código devem ser funcionais e seguir as melhores práticas das tecnologias especificadas.
*   A comunicação entre o frontend e o AI Local Agent deve ser direta e segura, sem passar dados sensíveis pela nuvem SaaS.
*   Priorize a segurança e a privacidade em todas as camadas.
*   O design deve ser minimalista e dark mode.
*   Explique as decisões técnicas e as justificativas por trás delas.
*   Assuma que a autenticação será gerenciada por uma solução como Clerk ou NextAuth.

5. Stack Mínima Viável (para lançar em 48h)

Se o Alfredo disser "Zé, preciso disso no ar em dois dias!", essa é a receita:

Por que essa stack? Velocidade de desenvolvimento, DX (Developer Experience) excelente, escalabilidade "out-of-the-box" para o SaaS e flexibilidade para o agente local.

6. Checklist de Lançamento

Antes de apertar o botão "Go Live", o Zé Mané sempre confere esses 10 itens:

  1. Core Web Vitals Verificadas: Pontuação 90+ no Lighthouse para LCP, INP, CLS na landing page e nas principais rotas do dashboard.
  2. SEO Técnico Auditado: robots.txt configurado, sitemaps XML submetidos ao Google Search Console, Schema.org válido e testado, meta tags otimizadas.
  3. Segurança da Aplicação: Testes de penetração básicos (OWASP Top 10), proteção contra XSS/CSRF, validação de inputs, headers de segurança (CSP, HSTS).
  4. Segurança do AI Local Agent: Comunicação local criptografada (HTTPS/gRPC-TLS), autenticação de API local, isolamento de processo.
  5. Testes de Carga (SaaS Backend): Garantir que o backend aguenta o volume esperado de usuários e chamadas de status dos agentes.
  6. Monitoramento & Logs: Sentry/Datadog configurados para erros, logs centralizados (Vercel Analytics, Cloudflare Logs), alertas para anomalias.
  7. Acessibilidade (WCAG 2.2 AA): Navegação por teclado, compatibilidade com leitores de tela, contraste de cores adequado no tema dark.
  8. Backups de Banco de Dados: Estratégia de backup e recuperação de desastres para Supabase/PlanetScale implementada e testada.
  9. Documentação Mínima: Guia de instalação para o AI Local Agent, FAQ para usuários, documentação básica da API para desenvolvedores (se aplicável).
  10. Plano de Rollback: Em caso de desastre, como reverter para a versão anterior de forma rápida e segura.

É isso aí, pessoal! Com esse guia do Zé Mané, o AI Guard Pro não é só uma ideia, é um projeto com um roadmap claro, prompts prontos para a IA e uma base sólida para o sucesso. Agora, mãos à obra!

Compartilhar