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

Prompts Mestre: MemóriaIA Pro – A Arquitetura de Memória de Longo Prazo para Agentes de IA

(há 8 dias)
Prompts Mestre: MemóriaIA Pro – A Arquitetura de Memória de Longo Prazo para Agentes de IA

E aí, galera da engenharia! Zé Mané na área, e hoje a gente vai desmistificar a construção de um SaaS que vai virar o jogo para quem trabalha com IA: o MemóriaIA Pro. O Alfredo, nosso CEO visionário, já sacou a parada: agentes de IA com Alzheimer digital são coisa do passado. A gente vai dar a eles uma memória de elefante, e de quebra, monetizar essa inteligência.

Preparem-se para um mergulho profundo em prompts cirúrgicos, arquitetura de ponta e um design que faria o Batman chorar de inveja (de tão dark e funcional).

1. O Projeto em 30 Segundos

O MemóriaIA Pro é um SaaS plug-and-play que resolve o problema crônico de memória de curto prazo em agentes de IA. Ele fornece uma camada de memória de longo prazo e contextual, permitindo que chatbots, tutores virtuais e assistentes lembrem-se de interações passadas, preferências do usuário e conhecimento semântico. Integrável com frameworks como LangChain e CrewAI, ele transforma agentes burros em verdadeiros aprendizes, personalizando experiências e abrindo novas avenidas de monetização. A stack é Next.js com React, tRPC, Drizzle ORM, Supabase, Vercel, LangChain, e um vetor database como Pinecone/Weaviate/Qdrant, tudo monetizado via Stripe. O design é minimalista e dark-first.

2. Arquitetura Recomendada

A arquitetura do MemóriaIA Pro é pensada para escalabilidade, performance e uma experiência de desenvolvimento fluida. Usamos uma abordagem "full-stack" com Next.js, aproveitando as Edge Functions da Vercel e a robustez do Supabase para banco de dados e autenticação, e um banco de dados vetorial dedicado para a magia da memória semântica.

Mermaid Error: Lexical error on line 19. Unrecognized text. ...orDB SupabaseDB --|Storage| Supabase ----------------------^

Show Code
graph TD
    User[Usuário Final] -->|Requisição HTTP| VercelCDN(Vercel CDN)
    VercelCDN -->|Static Assets / Edge Functions| NextJSApp(Next.js App)
    NextJSApp -->|tRPC API Calls| NextJSApi(Next.js API Routes / Edge Functions)

    subgraph Backend Services
        NextJSApi --> SupabaseAuth(Supabase Auth)
        NextJSApi --> SupabaseDB(Supabase PostgreSQL DB - Drizzle ORM)
        NextJSApi -->|Embeddings / Retrieval| VectorDB(Pinecone/Weaviate/Qdrant)
        NextJSApi -->|Payment Processing| Stripe(Stripe API)
        NextJSApi -->|AI Agent Integration| LangChain(LangChain/CrewAI)
    end

    subgraph External Integrations
        LangChain --> LLM(OpenAI/Anthropic/Google LLM)
    end

    SupabaseDB --|Webhooks| VectorDB
    SupabaseDB --|Storage| SupabaseStorage(Supabase Storage)

    style User fill:#f9f,stroke:#333,stroke-width:2px
    style VercelCDN fill:#bbf,stroke:#333,stroke-width:2px
    style NextJSApp fill:#dfd,stroke:#333,stroke-width:2px
    style NextJSApi fill:#dfd,stroke:#333,stroke-width:2px
    style SupabaseAuth fill:#ccf,stroke:#333,stroke-width:2px
    style SupabaseDB fill:#ccf,stroke:#333,stroke-width:2px
    style VectorDB fill:#ffc,stroke:#333,stroke-width:2px
    style Stripe fill:#fcf,stroke:#333,stroke-width:2px
    style LangChain fill:#ddf,stroke:#333,stroke-width:2px
    style LLM fill:#eef,stroke:#333,stroke-width:2px
    style SupabaseStorage fill:#ccf,stroke:#333,stroke-width:2px

3. Prompts Mestre por Categoria

Aqui é onde a mágica acontece. Prompts cirúrgicos para cada pedaço do nosso SaaS, prontos para serem jogados em qualquer IA de código.

🏗️ Prompts de Arquitetura & Backend

Estes prompts focam na espinha dorsal do MemóriaIA Pro: banco de dados, APIs, autenticação e a integração com os bancos de dados vetoriais.

Prompt 1: Esquema do Banco de Dados com Drizzle ORM

prompt
Você é um engenheiro de backend sênior com expertise em Drizzle ORM e Supabase.
**Contexto:** Estamos construindo o MemóriaIA Pro, um SaaS para memória de longo prazo de agentes de IA. Precisamos modelar usuários, workspaces (para isolar dados de diferentes agentes/empresas), agentes (as IAs que usarão a memória), e os "memories" (os dados contextuais armazenados).
**Tarefa:** Crie o esquema completo do banco de dados usando Drizzle ORM para PostgreSQL, incluindo as definições de tabelas, colunas, tipos de dados, relacionamentos (foreign keys) e índices essenciais para performance.
**Requisitos:**
1.  Tabelas: `users`, `workspaces`, `agents`, `memories`.
2.  `users`: ID (UUID), email (único), nome, avatar_url, created_at, updated_at. Integrar com Supabase Auth.
3.  `workspaces`: ID (UUID), nome, slug (único, gerado do nome), user_id (FK para users), created_at, updated_at.
4.  `agents`: ID (UUID), nome, description, workspace_id (FK para workspaces), api_key (única, para autenticação do agente), created_at, updated_at.
5.  `memories`: ID (UUID), agent_id (FK para agents), content (TEXT, o texto original da memória), embedding_id (UUID, referência ao ID no banco vetorial), metadata (JSONB, para dados adicionais como timestamp, source, etc.), created_at.
6.  Todos os IDs devem ser UUIDs gerados por padrão.
7.  `created_at` e `updated_at` devem ter timestamps padrão e serem atualizados automaticamente.
8.  Inclua índices para `email` em `users`, `slug` em `workspaces`, `api_key` em `agents`, e `agent_id` em `memories` para otimização de consultas.
**Formato de Saída:** Código TypeScript para o `schema.ts` do Drizzle ORM.

Prompt 2: API de Autenticação e Gerenciamento de Agentes (tRPC)

prompt
Você é um desenvolvedor full-stack expert em Next.js e tRPC.
**Contexto:** O MemóriaIA Pro precisa de endpoints para autenticação de usuários (via Supabase Auth) e para que os usuários possam criar e gerenciar seus agentes de IA.
**Tarefa:** Implemente um router tRPC para gerenciamento de agentes.
**Funcionalidades:**
1.  `createAgent`: Cria um novo agente associado ao workspace do usuário autenticado. Deve gerar uma `api_key` única e segura (ex: UUID v4 + token aleatório).
2.  `getAgents`: Retorna todos os agentes de um workspace específico do usuário autenticado.
3.  `getAgentById`: Retorna detalhes de um agente específico.
4.  `updateAgent`: Atualiza nome/descrição de um agente.
5.  `deleteAgent`: Deleta um agente e, crucialmente, deve disparar um evento para limpar as memórias associadas no banco vetorial.
**Restrições:**
-   Todos os endpoints devem ser protegidos por autenticação de usuário (via Supabase Auth).
-   A `api_key` deve ser gerada no backend e retornada APENAS na criação do agente (para segurança).
-   Use o esquema Drizzle definido anteriormente.
**Formato de Saída:** Código TypeScript para um arquivo `agent.ts` dentro do diretório `server/routers` do tRPC, incluindo os tipos de input e output.

Prompt 3: Serviço de Memória para Agentes (API Externa)

prompt
Você é um engenheiro de backend com experiência em APIs RESTful e bancos de dados vetoriais.
**Contexto:** Agentes de IA externos (via LangChain/CrewAI) precisarão interagir com o MemóriaIA Pro para armazenar e recuperar memórias. Esta API precisa ser robusta e segura.
**Tarefa:** Crie um router tRPC (ou um conjunto de Edge Functions RESTful) para o serviço de memória.
**Funcionalidades:**
1.  `addMemory`: Recebe `agent_id`, `content` (texto da memória) e `metadata`. Gera o embedding do `content`, armazena no banco vetorial (Pinecone/Weaviate/Qdrant) e salva a referência (`embedding_id`) no Supabase.
2.  `retrieveMemories`: Recebe `agent_id`, `query` (texto da consulta) e `k` (número de resultados). Gera o embedding da `query`, consulta o banco vetorial para os `k` vizinhos mais próximos, e retorna o `content` original e `metadata` do Supabase.
3.  `deleteAgentMemories`: Deleta todas as memórias associadas a um `agent_id` tanto no Supabase quanto no banco vetorial.
**Restrições:**
-   Todos os endpoints devem ser autenticados usando a `api_key` do agente (header `Authorization: Bearer <api_key>`).
-   A integração com o banco vetorial deve ser abstrata (ex: interface `VectorDBService`).
-   Use um modelo de embeddings (ex: OpenAI `text-embedding-ada-002`) para gerar os vetores.
**Formato de Saída:** Código TypeScript para um arquivo `memory.ts` dentro do diretório `server/routers` do tRPC, incluindo uma interface `VectorDBService` e a implementação dos endpoints.

🎨 Prompts de Frontend & Design

Aqui, a gente foca na experiência do usuário: componentes reutilizáveis, layouts responsivos e um design minimalista dark que é a cara do Zé Mané.

Prompt 1: Componente AgentCard com shadcn/ui

prompt
Você é um engenheiro de frontend com maestria em React, Next.js, Tailwind CSS e shadcn/ui.
**Contexto:** No dashboard do MemóriaIA Pro, os usuários precisam visualizar e interagir com seus agentes de IA.
**Tarefa:** Crie um componente React `AgentCard` que exiba as informações de um agente.
**Requisitos:**
-   Utilize componentes do shadcn/ui (Card, Button, Badge, DropdownMenu).
-   Exiba: Nome do Agente, Descrição, Data de Criação.
-   Inclua um botão "Copy API Key" que copie a chave para a área de transferência (usando `navigator.clipboard`).
-   Inclua um `DropdownMenu` com opções "Editar" e "Deletar" (que disparam funções de callback).
-   O design deve seguir o estilo minimalista dark-first.
**Formato de Saída:** Código TypeScript/TSX para o componente `AgentCard.tsx` e um exemplo de uso.

Prompt 2: Layout de Dashboard Responsivo (Next.js)

prompt
Você é um desenvolvedor frontend com profundo conhecimento em Next.js, Tailwind CSS e design responsivo.
**Contexto:** Precisamos de um layout base para o dashboard do MemóriaIA Pro, onde os usuários gerenciarão seus workspaces e agentes.
**Tarefa:** Crie um componente `DashboardLayout` para Next.js.
**Requisitos:**
-   Header fixo com o logo do MemóriaIA Pro, nome do usuário e um `DropdownMenu` (shadcn/ui) para "Logout" e "Configurações".
-   Sidebar responsiva (oculta em mobile, slide-in/out) com navegação para "Meus Agentes", "Workspaces", "Faturamento".
-   Área de conteúdo principal para renderizar o `children`.
-   Design dark-first e responsivo para mobile, tablet e desktop.
-   Use CSS custom properties ou variáveis do Tailwind para cores.
**Formato de Saída:** Código TypeScript/TSX para `DashboardLayout.tsx` e um exemplo de como usá-lo em uma página Next.js.

Prompt 3: Formulário de Criação de Agente (React Hook Form + Zod)

prompt
Você é um especialista em React, validação de formulários e UX.
**Contexto:** Para criar um novo agente, o usuário precisa preencher um formulário com nome e descrição.
**Tarefa:** Crie um componente de formulário `CreateAgentForm` usando React Hook Form e Zod para validação.
**Requisitos:**
-   Campos: `name` (texto, obrigatório, min 3 chars, max 50), `description` (textarea, opcional, max 200 chars).
-   Utilize componentes de formulário do shadcn/ui (Input, Textarea, Button, Label).
-   Validação em tempo real com Zod.
-   Exiba mensagens de erro claras abaixo dos campos.
-   Botão "Criar Agente" que fica desabilitado se o formulário for inválido ou estiver submetendo.
-   O formulário deve aceitar uma prop `onSubmit` que recebe os dados validados.
-   Design minimalista dark.
**Formato de Saída:** Código TypeScript/TSX para `CreateAgentForm.tsx`, incluindo o schema Zod e um exemplo de como integrar com o tRPC.

🔍 Prompts de SEO & Schema.org

Para que o MemóriaIA Pro seja encontrado, precisamos de um SEO técnico impecável, com foco em dados estruturados e performance.

Prompt 1: Otimização de Meta Tags e Open Graph para Next.js

prompt
Você é um especialista em SEO técnico e Next.js App Router.
**Contexto:** A página inicial do MemóriaIA Pro precisa ser otimizada para buscadores e compartilhamento em redes sociais.
**Tarefa:** Crie o arquivo `metadata.ts` para a página inicial (`/app/page.tsx`) do Next.js 14+.
**Requisitos:**
-   `title`: "MemóriaIA Pro | Memória de Longo Prazo para Agentes de IA"
-   `description`: "SaaS plug-and-play para dar memória contextual e de longo prazo a agentes de IA. Integre com LangChain, CrewAI e personalize a experiência do seu chatbot."
-   `keywords`: "memória IA, agentes IA, LangChain, CrewAI, memória de longo prazo, IA conversacional, SaaS IA, Pinecone, Weaviate, Qdrant"
-   `openGraph`: Título, descrição, URL (ex: `https://memoriaia.pro`), tipo (`website`), imagem (ex: `https://memoriaia.pro/og-image.jpg`).
-   `twitter`: Card (`summary_large_image`), título, descrição, imagem, handle (`@MemoriaIAPro`).
-   `alternates`: Canonical URL.
**Formato de Saída:** Código TypeScript para o arquivo `metadata.ts` no App Router do Next.js.

Prompt 2: Schema.org para Produto SaaS

prompt
Você é um guru de Schema.org e dados estruturados, focado em rich snippets.
**Contexto:** Queremos que o MemóriaIA Pro apareça com rich snippets nos resultados de busca, destacando-o como um produto de software.
**Tarefa:** Crie o JSON-LD para a página inicial do MemóriaIA Pro, utilizando o tipo `SoftwareApplication` e `Product`.
**Requisitos:**
-   `@context`: `https://schema.org`
-   `@type`: `SoftwareApplication` e `Product`.
-   `name`: "MemóriaIA Pro"
-   `description`: "SaaS plug-and-play para dar memória contextual e de longo prazo a agentes de IA. Integre com LangChain, CrewAI e personalize a experiência do seu chatbot."
-   `operatingSystem`: "Web, Cloud"
-   `applicationCategory`: "DeveloperApplication"
-   `offers`: `Offer` com `priceCurrency` ("USD"), `price` ("0" para freemium ou plano inicial), `availability` (`InStock`).
-   `aggregateRating`: (Opcional, se houver avaliações) `AggregateRating` com `ratingValue` e `reviewCount`.
-   `url`: `https://memoriaia.pro`
-   `logo`: `https://memoriaia.pro/logo.png`
-   `screenshot`: `https://memoriaia.pro/screenshot.jpg`
**Formato de Saída:** Bloco de código JSON-LD para ser inserido no `<head>` da página.

Prompt 3: Sitemap XML Dinâmico com Next.js

prompt
Você é um especialista em SEO técnico e Next.js.
**Contexto:** Precisamos de um sitemap XML dinâmico para garantir que todas as páginas do MemóriaIA Pro sejam indexadas corretamente, incluindo as páginas de agentes e workspaces (se forem públicas).
**Tarefa:** Crie o arquivo `sitemap.ts` para o App Router do Next.js.
**Requisitos:**
-   Inclua a página inicial (`/`).
-   Inclua páginas estáticas como `/about`, `/pricing`, `/contact`.
-   **Importante:** Se houver workspaces ou agentes públicos (ex: landing pages para agentes), inclua-os dinamicamente (simulando a busca no banco de dados). Para este prompt, simule com dados mock.
-   Defina `changeFrequency` e `priority` para cada tipo de URL.
**Formato de Saída:** Código TypeScript para o arquivo `sitemap.ts` no diretório `app` do Next.js.

⚡ Prompts de Performance & Core Web Vitals

A performance é crucial para a experiência do usuário e ranqueamento. Vamos focar em otimizações que impactam diretamente as Core Web Vitals.

Prompt 1: Otimização de Imagens com Next.js Image Component

prompt
Você é um engenheiro de performance web com foco em Next.js e Core Web Vitals.
**Contexto:** A landing page do MemóriaIA Pro terá várias imagens (hero image, logos de integração, screenshots). Precisamos garantir que elas carreguem de forma otimizada.
**Tarefa:** Crie um exemplo de uso do componente `next/image` para uma hero image e alguns logos de parceiros.
**Requisitos:**
-   Hero image: `priority`, `fill` ou `width`/`height` explícitos, `alt` descritivo.
-   Logos de parceiros: `width`/`height` explícitos, `loading="lazy"`.
-   Utilize formatos modernos como WebP ou AVIF (simule com `.webp` ou `.avif`).
-   Garanta que não haja CLS (Cumulative Layout Shift) devido às imagens.
**Formato de Saída:** Snippet de código TSX para uma seção de uma página Next.js, demonstrando o uso correto de `next/image`.

Prompt 2: Carregamento de Fontes Otimizado (Next.js Font)

prompt
Você é um especialista em performance de frontend, com foco em otimização de fontes e LCP.
**Contexto:** O MemóriaIA Pro usará uma fonte customizada para branding (ex: Inter). Precisamos carregá-la de forma eficiente para evitar FOUT/FOIT e melhorar o LCP.
**Tarefa:** Demonstre como carregar a fonte Inter usando `next/font/google` e aplicá-la globalmente.
**Requisitos:**
-   Use `next/font/google` para carregar a fonte Inter.
-   Configure `display: 'swap'` ou `display: 'optional'` para um bom comportamento de carregamento.
-   Aplique a fonte à tag `<body>` globalmente via Tailwind CSS.
-   Gere variáveis CSS personalizadas para a fonte principal.
**Formato de Saída:** Código TypeScript/CSS para `layout.tsx` e `globals.css` do Next.js App Router.

Prompt 3: Critical CSS e Bundle Splitting para LCP

prompt
Você é um ninja de performance frontend, focado em LCP e otimização de bundle.
**Contexto:** Queremos garantir que o conteúdo acima do fold da landing page do MemóriaIA Pro seja renderizado o mais rápido possível.
**Tarefa:** Explique e demonstre como o Next.js lida com Critical CSS e Bundle Splitting automaticamente, e como podemos reforçar isso para um LCP excelente.
**Requisitos:**
-   Explique o conceito de Critical CSS e como o Next.js/Vercel o otimiza.
-   Explique o Bundle Splitting automático do Next.js para componentes e rotas.
-   Sugira uma estratégia para componentes grandes que só aparecem abaixo do fold (ex: `dynamic` com `ssr: false`).
-   Forneça um snippet de código para um componente que seria lazy-loaded.
**Formato de Saída:** Texto explicativo com um snippet de código TSX para lazy loading de um componente.

🚀 Prompts de Deploy & DevOps

Deploy contínuo, edge functions e monitoramento são a chave para um SaaS robusto e sempre online.

Prompt 1: Configuração de CI/CD para Vercel

prompt
Você é um engenheiro de DevOps com experiência em Vercel e GitHub Actions.
**Contexto:** O MemóriaIA Pro precisa de um pipeline de CI/CD automatizado para deploy contínuo na Vercel a cada push no `main`.
**Tarefa:** Crie um arquivo de GitHub Actions (`.yml`) para deploy na Vercel.
**Requisitos:**
-   Trigger em `push` para o branch `main`.
-   Instalação de dependências (`npm ci`).
-   Build do projeto Next.js.
-   Deploy para a Vercel usando o `vercel-action`.
-   Variáveis de ambiente seguras para o token da Vercel e ID do projeto/org.
-   Inclua um passo para rodar testes (simule com um comando `npm test`).
**Formato de Saída:** Código YAML para o arquivo `.github/workflows/deploy.yml`.

Prompt 2: Monitoramento de Performance e Erros (Vercel Analytics + Sentry)

prompt
Você é um especialista em monitoramento de aplicações web e observabilidade.
**Contexto:** Precisamos monitorar a performance do MemóriaIA Pro (Core Web Vitals) e capturar erros em produção para garantir a estabilidade.
**Tarefa:** Explique como configurar Vercel Analytics e Sentry para o MemóriaIA Pro.
**Requisitos:**
-   **Vercel Analytics:** Explique como habilitar e o que ele monitora (Core Web Vitals, page views, etc.).
-   **Sentry:**
    -   Explique a integração com Next.js (via `@sentry/nextjs`).
    -   Forneça snippets de código para inicialização do Sentry no frontend (`sentry.client.config.ts`) e backend (`sentry.server.config.ts`).
    -   Demonstre como capturar um erro manualmente.
-   Foco em como essas ferramentas ajudam a manter as Core Web Vitals sob controle.
**Formato de Saída:** Texto explicativo com snippets de código TypeScript para Sentry.

Prompt 3: Configuração de Edge Functions para API de Memória

prompt
Você é um arquiteto de software com expertise em Edge Functions e performance de API.
**Contexto:** A API de memória do MemóriaIA Pro (addMemory, retrieveMemories) precisa ser extremamente rápida e distribuída globalmente.
**Tarefa:** Explique como as Edge Functions da Vercel são ideais para a API de memória e como configurá-las.
**Requisitos:**
-   Explique o benefício das Edge Functions (baixa latência, execução próxima ao usuário).
-   Descreva como o Next.js automaticamente transforma API Routes em Edge Functions se `runtime: 'edge'` for especificado.
-   Forneça um snippet de código de uma API Route de memória que utilize o runtime `edge`.
-   Mencione as limitações (ex: acesso a alguns Node.js APIs).
**Formato de Saída:** Texto explicativo com um snippet de código TypeScript para uma Edge Function no Next.js.

4. Prompt Único Completo

Este é o mega-prompt. Jogue isso em um GPT-4 ou Claude 3 Opus e veja a mágica acontecer. Ele abrange a visão completa do MemóriaIA Pro.

prompt
Você é um arquiteto de software full-stack, especialista em SaaS, Next.js 14+, tRPC, Drizzle ORM, Supabase, Vercel, LangChain, bancos de dados vetoriais (Pinecone/Weaviate/Qdrant), Stripe, shadcn/ui e SEO avançado.

**Contexto do Projeto:**
Construa o MVP do "MemóriaIA Pro", um SaaS plug-and-play que fornece memória de longo prazo e contextual para agentes de IA.
- **Problema Resolvido:** Agentes de IA com memória de curto prazo.
- **Público-alvo:** Desenvolvedores e empresas que constroem agentes de IA.
- **Features Core:**
    1.  **Gerenciamento de Agentes:** CRUD para agentes de IA (nome, descrição, API Key).
    2.  **API de Memória:** Endpoints para `addMemory` (texto -> embedding -> vetor DB + Supabase) e `retrieveMemories` (query -> embedding -> vetor DB -> Supabase).
    3.  **Autenticação:** Usuário (Supabase Auth) e Agente (API Key).
    4.  **Monetização:** Integração com Stripe para planos de assinatura (simples, ex: Free, Pro).
    5.  **Dashboard:** Interface para usuários gerenciarem workspaces, agentes e visualizar uso.
    6.  **Design:** Minimalista, dark-first, responsivo.
- **Tecnologias Obrigatórias:** Next.js 14+ (App Router), React, tRPC, Drizzle ORM, Supabase (Auth, DB, Storage), Vercel, LangChain (para embeddings), Pinecone/Weaviate/Qdrant (escolha um para o exemplo), Stripe. Tailwind CSS, shadcn/ui.

**Tarefa:**
Gere um conjunto completo de arquivos e instruções para construir o MVP do MemóriaIA Pro, seguindo a estrutura de um projeto Next.js.

**Estrutura da Saída:**
1.  **`README.md`**: Descrição do projeto, como configurar o ambiente, variáveis de ambiente necessárias (`.env.local`), como rodar o projeto.
2.  **`package.json`**: Dependências essenciais.
3.  **`drizzle/schema.ts`**: Esquema completo do banco de dados (users, workspaces, agents, memories) usando Drizzle ORM para PostgreSQL.
4.  **`lib/supabase.ts`**: Configuração do cliente Supabase.
5.  **`lib/vector-db.ts`**: Interface para `VectorDBService` (add, retrieve, delete) e uma implementação mock (ou simplificada) para Pinecone/Weaviate/Qdrant.
6.  **`lib/embeddings.ts`**: Função para gerar embeddings usando LangChain e um LLM (ex: OpenAI).
7.  **`app/layout.tsx`**: Layout principal com `next/font`, `ThemeProvider` (dark mode) e `SessionProvider` (Supabase).
8.  **`app/page.tsx`**: Landing page minimalista com CTA para login/cadastro, descrição do produto, e seções de "Features" e "Integrations". Otimizada para SEO (meta tags).
9.  **`app/(dashboard)/layout.tsx`**: Layout do dashboard com sidebar e header (autenticado).
10. **`app/(dashboard)/agents/page.tsx`**: Página para listar e gerenciar agentes (CRUD). Incluir `AgentCard` e `CreateAgentForm`.
11. **`server/trpc/root.ts`**: Root router do tRPC.
12. **`server/trpc/routers/auth.ts`**: Router para autenticação (login, logout, register via Supabase).
13. **`server/trpc/routers/agent.ts`**: Router para CRUD de agentes, incluindo geração de `api_key`.
14. **`server/trpc/routers/memory.ts`**: Router para a API de memória (`addMemory`, `retrieveMemories`, `deleteAgentMemories`), protegida por `api_key`.
15. **`components/ui/*.tsx`**: Componentes do shadcn/ui customizados ou exemplos de uso (ex: `AgentCard`, `CreateAgentForm`).
16. **`app/api/stripe-webhook/route.ts`**: Exemplo de webhook para Stripe (simples, apenas para receber eventos).
17. **`middleware.ts`**: Middleware de autenticação para proteger rotas do dashboard.
18. **`sentry.client.config.ts`, `sentry.server.config.ts`**: Configuração básica do Sentry.
19. **`next.config.js`**: Configurações do Next.js (imagens, Sentry).

**Restrições e Detalhes:**
-   Priorize a segurança (API Keys, autenticação).
-   Use `async/await` e tratamento de erros adequado.
-   Comentários claros no código.
-   Design dark-first com Tailwind CSS e shadcn/ui.
-   Foco em performance (Next.js Image, Fonts, Edge Functions).
-   Para o banco vetorial, use um cliente genérico e simule a interação se uma integração completa for muito complexa para um único prompt.
-   A integração com LangChain para embeddings deve ser explícita.
-   A monetização via Stripe pode ser um placeholder para o MVP (ex: apenas um botão "Upgrade to Pro").
-   Use Zod para validação em todos os endpoints tRPC e formulários.
-   As API Keys dos agentes devem ser geradas com criptografia forte e armazenadas de forma segura (ex: hashed no DB, plaintext retornada apenas uma vez).
-   A `api_key` do agente deve ser um UUID v4 + um token aleatório de 32 caracteres, hashed com bcrypt antes de salvar no DB.
-   As rotas de API de memória (`addMemory`, `retrieveMemories`) devem ser Edge Functions.

5. Stack Mínima Viável

Para lançar o MemóriaIA Pro em 48 horas, o Zé Mané te entrega a stack enxuta e poderosa:

Essa combinação garante performance, escalabilidade, experiência de desenvolvimento e um custo-benefício imbatível para um MVP.

6. Checklist de Lançamento

Antes de apertar o botão "Go Live", certifique-se de que cada item deste checklist está ticado. Não quero ver o nome do Zé Mané associado a bugs em produção!

  1. Configuração de Variáveis de Ambiente: Todas as chaves de API (Supabase, OpenAI, Pinecone, Stripe, Vercel) configuradas corretamente no Vercel.
  2. Testes de Autenticação: Login, cadastro, logout de usuário e autenticação de agente (via API Key) funcionando perfeitamente.
  3. Testes de CRUD de Agentes: Criar, ler, atualizar e deletar agentes sem falhas.
  4. Testes da API de Memória: addMemory e retrieveMemories funcionando com o banco vetorial e Supabase. Verifique a relevância dos resultados de retrieveMemories.
  5. Performance: Lighthouse score acima de 90 para LCP, FID/INP e CLS na landing page e dashboard.
  6. SEO Técnico: Meta tags, Open Graph, JSON-LD e sitemap XML validados e funcionando.
  7. Responsividade: Teste em diferentes dispositivos (mobile, tablet, desktop) e navegadores.
  8. Monitoramento: Sentry e Vercel Analytics configurados e reportando dados.
  9. Segurança: Revisão de políticas de segurança (RLS no Supabase, validação de input, proteção contra XSS/CSRF). API Keys geradas e armazenadas de forma segura.
  10. Plano de Faturamento (Stripe): Integração básica do Stripe funcionando, mesmo que seja apenas para exibir planos e redirecionar para o checkout.

Com isso, você tem o playbook completo para construir o MemóriaIA Pro. Agora é arregaçar as mangas e codar! Qualquer dúvida, o Zé Mané tá na escuta. Mas duvido que precise, com esses prompts na mão, a IA vai fazer o trabalho pesado.

Compartilhar