Prompts Mestre: Agente Jurídico IA com LangChain e RAG para Super-Advogados

"Crie o esquema de banco de dados PostgreSQL para o Agente Jurídico IA. Inclua tabelas para `users` (com autenticação Supabase), `documents` (para documentos carregados pelos usuários, com metadados como título, tipo, upload_date, user_id, status_processamento), `jurisprudence_chunks` (para armazenar chunks de jurisprudência com embeddings e metadados como id_original, tribunal, data_decisao, ementa, texto_chunk, embedding_vector), `legislation_chunks` (similar a jurisprudência, com id_original, tipo_norma, numero, ano, ementa, texto_chunk, embedding_vector), `legal_drafts` (para peças geradas, com user_id, tipo_peca, conteudo, data_geracao, status), e `conversations` (para histórico de interações com a IA, user_id, query, response, timestamp). Utilize Drizzle ORM para a definição dos schemas e migrações. Assegure que os campos de embedding sejam do tipo `vector` para uso com `pgvector` e que haja índices apropriados para performance de busca."

"Desenvolva as rotas tRPC para o backend do Agente Jurídico IA. As rotas devem incluir:
1. `auth.getSession`: Para obter a sessão do usuário logado.
2. `document.upload`: Para upload de documentos (recebe um URL de arquivo do Supabase Storage e metadados).
3. `document.list`: Lista documentos do usuário.
4. `document.get`: Retorna um documento específico.
5. `rag.queryJurisprudence`: Recebe uma query de texto e retorna resultados relevantes de jurisprudência usando busca vetorial.
6. `rag.queryLegislation`: Recebe uma query de texto e retorna resultados relevantes de legislação usando busca vetorial.
7. `document.analyze`: Recebe um document_id e dispara um processo de sumarização/análise via LangChain.
8. `draft.generate`: Recebe um tipo de peça (ex: 'Petição Inicial'), contexto (fatos, partes, etc.) e gera um rascunho.
9. `conversation.add`: Adiciona uma interação de query/resposta ao histórico.
Utilize zod para validação de input e output em todas as rotas. Implemente autenticação de usuário para todas as rotas sensíveis."

"Crie um módulo de orquestração RAG usando LangChain. Este módulo deve:
1. Receber uma `query` do usuário.
2. Realizar uma busca vetorial nos `jurisprudence_chunks` e `legislation_chunks` (utilizando pgvector como VectorStore).
3. Recuperar os `k` chunks mais relevantes.
4. Formatar esses chunks como contexto para o LLM.
5. Chamar um LLM (ex: GPT-4) com a query do usuário e o contexto recuperado para gerar uma resposta.
6. Implementar um mecanismo de `retriever` e `chain` do LangChain.
Considere estratégias de re-ranking ou multi-query para melhorar a relevância dos resultados. A saída deve ser um texto conciso e relevante."

"Projete um pipeline de ingestão e processamento de documentos para o Agente Jurídico IA. Este pipeline, acionado por um `document.upload` no tRPC, deve:
1. Baixar o arquivo do Supabase Storage.
2. Extrair texto do PDF (usando uma biblioteca como `pdf-parse` ou `pypdf` via um worker).
3. Dividir o texto em chunks menores, com sobreposição (chunking strategy: RecursiveCharacterTextSplitter do LangChain).
4. Gerar embeddings para cada chunk usando um modelo de embedding (ex: OpenAI Embeddings ou similar).
5. Armazenar os chunks, seus embeddings e metadados (incluindo o `document_id` original) nas tabelas `jurisprudence_chunks` ou `legislation_chunks` (ou uma tabela genérica `document_chunks` se for para documentos do usuário).
6. Atualizar o `status_processamento` do documento para 'processado' ou 'falha'.
Este processo deve ser assíncrono, idealmente em um Cloudflare Worker ou Vercel Edge Function separada para processamento intensivo."

"Desenvolva o componente `ChatInterface` para o Agente Jurídico IA. Este componente React deve:
1. Apresentar um campo de input para a query do usuário e um botão de envio.
2. Exibir o histórico de conversas (queries e respostas da IA) de forma clara e legível, com balões de chat.
3. Incluir um indicador de carregamento enquanto a IA processa a resposta.
4. O design deve ser minimalista dark, usando Tailwind CSS e shadcn/ui. Garanta responsividade para mobile e desktop.
5. Adicione suporte para markdown nas respostas da IA para formatação de texto (listas, negrito, código).
Utilize `useQuery` e `useMutation` do tRPC para interagir com o backend."

"Crie o layout principal da aplicação para o Agente Jurídico IA. Este layout, construído com Next.js e Tailwind CSS, deve incluir:
1. Uma `Sidebar` de navegação à esquerda (ocultável em mobile) com links para 'Dashboard', 'Meus Documentos', 'Consultar IA', 'Gerar Peça', 'Configurações'.
2. Um `Header` no topo com o nome da aplicação, um avatar do usuário (com menu dropdown para 'Perfil', 'Sair') e um botão para alternar tema (dark/light, embora o padrão seja dark).
3. A área de conteúdo principal deve ser dinâmica, renderizando as páginas conforme a navegação.
4. O design deve ser coeso, minimalista dark, com tipografia expressiva (ex: Inter ou Geist Sans) e uso estratégico de espaço negativo. Utilize `Radix UI` para elementos como dropdowns e modais."

"Implemente os componentes `DocumentUploadCard` e `DocumentListItem`.
O `DocumentUploadCard` deve ser um componente de arrastar e soltar (drag-and-drop) para arquivos PDF, com um indicador de progresso de upload e feedback visual (sucesso/erro).
O `DocumentListItem` deve exibir o título do documento, data de upload, status de processamento (pendente, processado, falha) e um menu de ações (visualizar, analisar, excluir).
Ambos os componentes devem aderir ao tema minimalista dark com Tailwind CSS e shadcn/ui. Garanta acessibilidade, incluindo labels ARIA e navegação via teclado."

"Desenvolva a página `GenerateLegalDraft` para o Agente Jurídico IA. Esta página deve:
1. Apresentar um formulário dinâmico onde o usuário seleciona o `tipo_peca` (ex: 'Petição Inicial', 'Contrato de Aluguel').
2. Com base no tipo, o formulário deve exibir campos relevantes (ex: para Petição Inicial: 'Partes', 'Fatos', 'Fundamentação Legal', 'Pedidos').
3. Um botão 'Gerar Rascunho' que envia os dados para a API `draft.generate`.
4. Uma área de texto editável (ex: usando um editor WYSIWYG simples ou um `textarea` estilizado) para exibir o rascunho gerado, permitindo ao usuário copiar ou salvar.
5. O design deve ser clean, minimalista dark, com foco na usabilidade para entrada de dados complexos. Utilize `react-hook-form` com `zod` para validação."

"Gere as meta tags essenciais para as páginas do Agente Jurídico IA, focando em SEO e social sharing. Para cada página principal (Home, Dashboard, Features, Preços, Contato), inclua:
1. `<title>` descritivo e otimizado.
2. `<meta name='description'>` concisa e com palavras-chave relevantes.
3. `<meta name='robots'>` para controle de indexação.
4. Open Graph tags (`og:title`, `og:description`, `og:image`, `og:url`, `og:type`) para Facebook/LinkedIn.
5. Twitter Card tags (`twitter:card`, `twitter:site`, `twitter:title`, `twitter:description`, `twitter:image`) para Twitter/X.
6. `canonical` URL.
Utilize `next/head` ou o novo `Metadata API` do Next.js 13/14 para gerenciar essas tags dinamicamente."

"Crie um Schema.org JSON-LD para a homepage do Agente Jurídico IA, utilizando o tipo `SoftwareApplication` ou `WebApplication`. Inclua propriedades como:
1. `name`, `description`, `url`.
2. `applicationCategory` (ex: 'LegalApplication').
3. `operatingSystem` (ex: 'Web').
4. `offers` (com `Offer` type, incluindo `price`, `priceCurrency`, `availability`).
5. `aggregateRating` (se houver reviews).
6. `publisher` (com `Organization` type).
7. `screenshot` (URL para imagem da UI).
Adicionalmente, crie um `Organization` JSON-LD para a empresa por trás do Agente Jurídico IA, com `name`, `url`, `logo`, `contactPoint` e links para perfis sociais. Incorpore este JSON-LD no `<head>` da página."

"Desenvolva um sitemap XML dinâmico e um arquivo `robots.txt` para o Agente Jurídico IA.
O `sitemap.xml` deve incluir todas as URLs públicas da aplicação (Home, Features, Preços, Contato, Blog - se houver). Ele deve ser gerado dinamicamente para incluir novas páginas ou artigos de blog.
O `robots.txt` deve permitir o rastreamento de todas as páginas públicas e especificar a localização do sitemap.
Garanta que páginas de usuário (Dashboard, configurações, documentos privados) sejam excluídas do sitemap e desindexadas via `robots.txt` ou meta tags `noindex`."

"Otimize o carregamento de imagens e fontes para o Agente Jurídico IA.
Para imagens:
1. Utilize o componente `next/image` com otimização automática (WebP/AVIF).
2. Defina `width`, `height` e `alt` para todas as imagens.
3. Implemente `lazy loading` para imagens fora da viewport inicial.
Para fontes:
1. Use `next/font` para otimização automática de fontes (subsetting, self-hosting).
2. Pré-carregue as fontes críticas (`preload`).
3. Garanta que não haja CLS (Cumulative Layout Shift) devido a fontes não carregadas (`font-display: optional` ou `swap` com fallback adequado).
O objetivo é atingir um LCP (Largest Contentful Paint) abaixo de 2.5 segundos."

"Implemente otimizações de bundle splitting e lazy loading para componentes React no Agente Jurídico IA.
1. Identifique componentes que não são críticos para a carga inicial da página (ex: modais complexos, editores de texto, gráficos pesados, páginas de configurações).
2. Utilize `React.lazy()` e `Suspense` ou o `dynamic()` do Next.js para carregar esses componentes sob demanda.
3. Configure o webpack (via `next.config.js`) para otimizar o bundle, dividindo-o em chunks menores.
4. Monitore o tamanho do bundle e o tempo de carregamento com Lighthouse e WebPageTest para garantir melhorias no LCP e FID/INP."

"Otimize o CSS para o Agente Jurídico IA.
1. Garanta que o Tailwind CSS esteja configurado para purgar CSS não utilizado em produção.
2. Identifique e extraia o CSS crítico (Critical CSS) para ser injetado diretamente no `<head>` das páginas, evitando um FOUC (Flash of Unstyled Content) e melhorando o LCP.
3. Minimize e comprima todos os arquivos CSS.
4. Utilize `CSS Custom Properties` para gerenciamento de tema (dark/light) de forma eficiente.
O objetivo é reduzir o tempo de bloqueio de renderização do CSS e melhorar a pontuação do Lighthouse."

"Configure o pipeline de CI/CD para o Agente Jurídico IA usando Vercel.
1. Conecte o repositório Git (GitHub/GitLab/Bitbucket) ao Vercel.
2. Configure variáveis de ambiente (API keys, credenciais do Supabase, etc.) de forma segura no Vercel.
3. Garanta que cada push para a branch `main` dispare um deploy de produção.
4. Configure previews automáticos para cada pull request, permitindo testes antes do merge.
5. Inclua scripts de build (`next build`) e testes (`npm test` ou `yarn test`) no pipeline.
O objetivo é ter um processo de deploy automatizado, rápido e confiável."

"Implemente monitoramento de performance e erros para o Agente Jurídico IA.
1. Integre ferramentas de monitoramento de erros (ex: Sentry, Rollbar) para capturar exceções no frontend e backend.
2. Configure monitoramento de performance de frontend (ex: Vercel Analytics, Google Analytics com Core Web Vitals report) para acompanhar LCP, FID/INP, CLS.
3. Monitore o uso da API (Supabase, LLMs) e a performance do backend (Vercel logs, Supabase logs).
4. Crie alertas para anomalias ou degradação de performance.
Isso é crucial para identificar e resolver problemas proativamente."

"Configure as Vercel Edge Functions para otimizar a performance do Agente Jurídico IA.
1. Utilize Edge Functions para rotas de API que exigem baixa latência e processamento leve (ex: autenticação, validação de requisições simples).
2. Considere o uso de `middleware.ts` do Next.js para redirecionamentos, reescritas e manipulação de headers na edge.
3. Explore o caching de respostas de API na edge para dados estáticos ou que mudam pouco.
4. Garanta que as Edge Functions sejam eficientes em termos de recursos e tempo de execução, evitando operações intensivas em CPU/memória."

"Você é um engenheiro de software sênior, especialista em full-stack moderno com foco em IA e performance. Sua tarefa é criar um projeto Next.js 14+ completo para o 'Agente Jurídico IA'.

**Contexto do Projeto:**
- **Nome:** Agente Jurídico IA
- **Problema:** Automatiza tarefas repetitivas e de baixo valor agregado na advocacia (pesquisa de jurisprudência, análise de documentos, redação de peças processuais) usando IA e RAG.
- **Público-alvo:** Advogados e escritórios de advocacia.
- **Features Core:**
    1.  **Consulta Inteligente de Jurisprudência e Legislação (RAG-Powered):** Usuário faz uma query, IA busca e sintetiza informações relevantes.
    2.  **Análise e Sumarização de Documentos Jurídicos:** Upload de PDFs, IA extrai texto, sumariza e destaca pontos chave.
    3.  **Geração de Peças Processuais e Documentos Legais:** Formulários para gerar rascunhos de documentos com base em contexto fornecido.
- **Stack Recomendada:** Next.js 14 (App Router), React 19, TypeScript, Tailwind CSS v4, shadcn/ui, Radix UI, tRPC, Drizzle ORM, Supabase (Auth, PostgreSQL com pgvector, Storage), LangChain.js, OpenAI API (para LLM e Embeddings), Vercel para deploy.
- **Estilo de Design:** Minimalista dark, tipografia expressiva, espaço negativo estratégico.
- **Performance:** Otimizado para Core Web Vitals (LCP < 2.5s, INP < 200ms, CLS = 0).
- **Acessibilidade:** WCAG 2.2 compliant, navegação por teclado, ARIA patterns.

**Tarefa:**
Gere um projeto Next.js 14+ completo, incluindo:

**1. Estrutura de Pastas e Configurações Iniciais:**
   - `next.config.js` com otimizações de imagem e fonte.
   - `tailwind.config.ts` com tema dark padrão e cores customizadas.
   - `tsconfig.json` para TypeScript.
   - Estrutura básica do App Router (`app/`, `components/`, `lib/`, `server/`, `db/`).

**2. Esquema de Banco de Dados (Drizzle ORM):**
   - Definições de schemas para `users`, `documents`, `jurisprudence_chunks`, `legislation_chunks`, `legal_drafts`, `conversations`.
   - Uso de `pgvector` para embeddings.
   - Scripts de migração inicial.

**3. Backend (tRPC & LangChain):**
   - Definição do router tRPC (`server/trpc/router.ts`) com rotas para:
     - `auth.getSession`
     - `document.upload` (recebe URL do Supabase Storage, dispara processamento assíncrono)
     - `document.list`, `document.get`
     - `rag.query` (para jurisprudência/legislação, usando LangChain e pgvector)
     - `document.analyze` (dispara sumarização via LangChain)
     - `draft.generate` (gera peça legal via LangChain)
     - `conversation.add`
   - Implementação do módulo `lib/langchain.ts` para orquestração RAG (retriever, chain, LLM calls).
   - Módulo `lib/documentProcessor.ts` para extração de texto, chunking e geração de embeddings (simulado ou com stubs para integração futura com workers).
   - Validação de inputs/outputs com Zod para todas as rotas tRPC.

**4. Frontend (Next.js, React, Tailwind, shadcn/ui, Radix UI):**
   - **Layout Principal:** `app/layout.tsx` com `Sidebar` (navegação), `Header` (avatar, tema), e área de conteúdo.
   - **Página Inicial (`app/page.tsx`):** Boas-vindas, talvez um campo de busca rápido.
   - **Página de Consulta IA (`app/consultar-ia/page.tsx`):** Componente `ChatInterface` interativo.
   - **Página Meus Documentos (`app/documentos/page.tsx`):** Componentes `DocumentUploadCard` e `DocumentListItem` (listando documentos do usuário).
   - **Página Gerar Peça (`app/gerar-peca/page.tsx`):** Formulário dinâmico para `GenerateLegalDraft`.
   - **Componentes Reutilizáveis:** Botões, inputs, modais, cards, spinners (todos estilizados com Tailwind/shadcn/ui/Radix UI).
   - **Autenticação:** Integração com Supabase Auth para login/logout e proteção de rotas.

**5. Otimizações de Performance:**
   - Uso de `next/image` e `next/font`.
   - `React.lazy()` e `Suspense` para lazy loading de componentes não críticos.
   - Configuração de purga de CSS no Tailwind.
   - Meta tags e Schema.org JSON-LD para SEO na homepage.

**6. Configuração de Deploy:**
   - `.env.example` com variáveis de ambiente necessárias.
   - `README.md` com instruções de setup local e deploy no Vercel.

**Restrições:**
- Todo o código deve ser em TypeScript.
- Priorize a simplicidade e a clareza do código.
- Use mocks ou stubs para APIs externas (LLM, Supabase) onde a implementação completa seria muito extensa, mas indique claramente onde a integração real ocorreria.
- Não gere código repetitivo para cada componente shadcn/ui, apenas os exemplos de uso.
- Foque na estrutura e nos principais blocos de código que demonstram a arquitetura.
- Inclua comentários explicativos onde necessário.
- O estilo de código deve ser limpo e moderno.
- A saída deve ser um conjunto de blocos de código markdown, organizados por arquivo/componente, com explicações concisas.
- Não inclua a implementação completa de todas as features, mas sim a estrutura e os pontos de integração."