VITAIA - A IA da Vida

Inteligência Artificial Médica para Diagnóstico e Tratamento

🎯 Visão Geral

VITAIA é uma plataforma inovadora de inteligência artificial médica que auxilia profissionais de saúde na tomada de decisões clínicas. Combinando análise de sintomas, resultados de exames, histórico médico e diretrizes clínicas atualizadas, VITAIA fornece sugestões de diagnóstico, tratamento e medicação baseadas em IA.

Conceito: "Vita" (vida em latim) + "AI" (Inteligência Artificial) = A IA da Vida

✨ Características Principais

Multi-Especialidade: Suporte para 50+ especialidades médicas brasileiras
Análise Inteligente: Processamento de sintomas, exames e histórico médico
Sugestões de IA: Diagnóstico diferencial, tratamentos e medicações recomendadas
Análise de Imagens: Suporte para radiografias, tomografias e ressonâncias
Explicabilidade: Raciocínio detalhado por trás de cada sugestão
Conformidade LGPD: Proteção completa de dados de pacientes
Auditoria: Logs detalhados de todas as operações
Dashboard Premium: Interface moderna com dark/light mode
Pesquisa Clínica: Framework para estudos clínicos piloto
Integração EHR: Suporte HL7/FHIR para sistemas de prontuário eletrônico

🏗️ Arquitetura & Boas Práticas

Stack Tecnológico

Frontend:

React 19 + TypeScript
Tailwind CSS 4 + Shadcn/UI
Vite (build tool)
tRPC para comunicação com backend

Backend:

Express.js 4
tRPC 11 (RPC framework)
Node.js
Clean Architecture implementation

Banco de Dados:

PostgreSQL 14+
Drizzle ORM
Repository Pattern

IA & ML:

Google Gemini (LLM comercial)
Multi-provider strategy (OpenAI, DeepSeek)
Strategy Pattern para análise de IA

Segurança:

LGPD Compliance
Audit Logging

🎯 Boas Práticas Implementadas

Clean Architecture

├── Domain Layer (Entidades, Value Objects, Interfaces)
├── Application Layer (Casos de Uso, DTOs)
├── Infrastructure Layer (Repositórios, Provedores externos)
└── Presentation Layer (Controllers, tRPC routers)

Princípios SOLID

✅ Single Responsibility Principle: Cada classe tem uma única responsabilidade
✅ Open/Closed Principle: Extensível sem modificação (Strategy Pattern)
✅ Liskov Substitution Principle: Interfaces bem definidas
✅ Interface Segregation Principle: Interfaces específicas e coesas
✅ Dependency Inversion Principle: Dependência de abstrações

Design Patterns Implementados

🏭 Factory Pattern: AIProviderFactory para criação de provedores
🔄 Strategy Pattern: AIAnalysisStrategy para diferentes análises
👁️ Observer Pattern: MetricsCollector para coleta de métricas
🏛️ Repository Pattern: Abstração de acesso a dados
🎭 Decorator Pattern: Medição automática de performance
🔒 Singleton Pattern: Instâncias únicas de serviços

Microservices Patterns

🔄 CQRS: Separação de comandos e consultas
🛡️ Circuit Breaker: Proteção contra falhas de provedores
📊 Health Check: Monitoramento de saúde dos serviços
🔄 Retry Pattern: Tentativas automáticas em falhas
📈 Metrics Collection: Coleta de métricas operacionais

Análise Assintótica (Big O)

Busca por ID: O(1) - Índices de banco de dados
Listagem paginada: O(n) limitado por página
Análise de IA: O(n×m) onde n=provedores, m=sintomas
Cache LRU: O(1) para get/set
Validação CPF: O(1) - algoritmo de tamanho fixo

Cobertura de Testes

📊 Cobertura Global: 90%+ (branches, functions, lines, statements)
🎯 Domain Layer: 95%+ cobertura (regras de negócio críticas)
🔧 Application Layer: 90%+ cobertura (casos de uso)
🧪 Testes Unitários: Value Objects, Entities, Services
🔗 Testes de Integração: Use Cases, Repositories
⚡ Testes de Performance: Métricas de tempo de execução

📊 Estrutura do Banco de Dados

29 Tabelas Principais

Tabela	Descrição
`users`	Usuários (médicos)
`patients`	Dados dos pacientes
`consultations`	Consultas/atendimentos
`medicalHistory`	Histórico médico
`examResults`	Resultados de exames
`aiSuggestions`	Sugestões geradas por IA
`aiExplanations`	Explicabilidade das sugestões
`suggestionFeedback`	Feedback dos médicos
`patientConsent`	Consentimento LGPD
`medicalImages`	Imagens médicas
`researchProtocol`	Protocolos de pesquisa
`medicalSpecialties`	Especialidades médicas
`clinicalGuidelines`	Diretrizes clínicas
`specialtyMedications`	Medicações por especialidade
`auditLogs`	Logs de auditoria
... e mais 14 tabelas de suporte

🚀 Começando

🐳 Opção 1: Docker (Recomendado)

Forma mais rápida e fácil de executar localmente:

# Clonar repositório
git clone https://github.com/FELIPEACASTRO/VITAIA.git
cd VITAIA

# Configurar variáveis de ambiente
cp .env.example .env

# Iniciar com Docker Compose
docker-compose up -d

# Aplicar migrações do banco de dados
docker exec -it vitaia-app npm run db:push

# Acessar: http://localhost:5000

📖 Guia Completo de Setup Local com Docker →

💻 Opção 2: Instalação Manual

Pré-requisitos

Node.js 18+
pnpm ou npm
PostgreSQL 14+
Git

Instalação

# Clonar repositório
git clone https://github.com/FELIPEACASTRO/VITAIA.git
cd VITAIA

# Instalar dependências
pnpm install

# Configurar variáveis de ambiente
cp .env.example .env

# Executar migrações do banco de dados
pnpm db:push

# Iniciar servidor de desenvolvimento
pnpm dev

Variáveis de Ambiente

Veja .env.example para configuração completa. Principais variáveis:

# Banco de Dados
DATABASE_URL=postgresql://vitaia:password@localhost:5432/vitaia_db

# IA & APIs (Opcional)
OPENAI_API_KEY=sua_chave_openai
BUILT_IN_FORGE_API_KEY=sua_chave_forge

# Aplicação
VITE_APP_TITLE=VITAIA
VITE_APP_LOGO=/vitaia-logo.svg

⚠️ IMPORTANTE: Autenticação Removida

A aplicação roda sem sistema de autenticação
Todos os dados são associados a um usuário padrão (ID 1)
Ideal para desenvolvimento e demonstrações
Para produção, considere adicionar autenticação conforme necessário

📁 Estrutura do Projeto (Clean Architecture)

VITAIA/
├── client/                           # Frontend React
│   ├── src/
│   │   ├── pages/                   # Páginas da aplicação
│   │   ├── components/              # Componentes reutilizáveis
│   │   ├── contexts/                # React contexts
│   │   ├── hooks/                   # Custom hooks
│   │   ├── lib/                     # Utilitários
│   │   └── const.ts                 # Constantes e cores VITAIA
│   └── index.html
├── server/                           # Backend (Clean Architecture)
│   ├── domain/                      # 🏛️ DOMAIN LAYER
│   │   ├── entities/                # Entidades de negócio
│   │   │   └── Patient.ts           # Entidade Patient com regras
│   │   ├── value-objects/           # Value Objects
│   │   │   ├── CPF.ts              # CPF com validação brasileira
│   │   │   └── Email.ts            # Email com validação
│   │   ├── interfaces/              # Contratos e abstrações
│   │   │   ├── IRepository.ts       # Interface Repository
│   │   │   ├── IUseCase.ts         # Interface Use Case
│   │   │   └── IAIProvider.ts      # Interface provedor IA
│   │   └── services/                # Serviços de domínio
│   │       ├── AIProviderFactory.ts # Factory para provedores
│   │       ├── AIAnalysisStrategy.ts# Strategy para análise
│   │       ├── MetricsCollector.ts  # Observer para métricas
│   │       └── CacheStrategy.ts     # Strategy para cache
│   ├── application/                 # 🎯 APPLICATION LAYER
│   │   └── use-cases/               # Casos de uso
│   │       ├── CreatePatientUseCase.ts
│   │       └── AnalyzeSymptomsUseCase.ts
│   ├── infrastructure/              # 🔧 INFRASTRUCTURE LAYER
│   │   ├── repositories/            # Implementações Repository
│   │   │   └── PatientRepository.ts
│   │   └── ai-providers/            # Provedores de IA
│   │       └── GeminiAIProvider.ts
│   ├── _core/                       # 🌐 PRESENTATION LAYER
│   │   └── index.ts                 # Express server
│   ├── routers.ts                   # tRPC procedures
│   └── db.ts                        # Database connection
├── tests/                           # 🧪 TESTES ABRANGENTES
│   ├── unit/                        # Testes unitários
│   │   ├── domain/                  # Testes de domínio
│   │   │   ├── entities/            # Testes de entidades
│   │   │   ├── value-objects/       # Testes de value objects
│   │   │   └── services/            # Testes de serviços
│   │   └── application/             # Testes de casos de uso
│   ├── integration/                 # Testes de integração
│   │   └── use-cases/               # Testes end-to-end
│   └── setup.ts                     # Configuração de testes
├── drizzle/                         # Schema e migrações
│   └── schema.ts                    # Definição de tabelas
├── shared/                          # Código compartilhado
├── coverage/                        # Relatórios de cobertura
├── docs/                           # 📚 DOCUMENTAÇÃO
│   ├── ARCHITECTURE.md             # Documentação da arquitetura
│   ├── API_REFERENCE.md            # Referência da API
│   └── DEVELOPMENT_GUIDE.md        # Guia de desenvolvimento
├── VITAIA_DESIGN_SYSTEM.md         # Design system completo
├── ANVISA_COMPLIANCE.md            # Conformidade regulatória
└── SCALABILITY_ROADMAP.md          # Roadmap de escalabilidade

🎨 Princípios de Organização

Separação por Camadas

Domain: Regras de negócio puras, sem dependências externas
Application: Orquestração de casos de uso
Infrastructure: Implementações concretas e integrações
Presentation: Interface com o mundo externo

Inversão de Dependências

// ❌ Dependência direta (acoplamento)
class PatientService {
  private db = new PostgreSQLDatabase();
}

// ✅ Inversão de dependência (desacoplamento)
class PatientService {
  constructor(private repository: IPatientRepository) {}
}

Coesão e Baixo Acoplamento

Cada módulo tem responsabilidade única e bem definida
Interfaces claras entre camadas
Fácil substituição de implementações

🎨 Design System VITAIA

Paleta de Cores

Cor	Hex	Uso
Verde Vivo	`#10B981`	Ações positivas, sucesso
Azul Ciano	`#06B6D4`	Informações, destaques
Roxo Moderno	`#8B5CF6`	Elementos de IA
Vermelho Alerta	`#EF4444`	Erros, avisos críticos
Âmbar Aviso	`#F59E0B`	Avisos, atenção

Tipografia

Headlines: Inter Bold (700)
Body: Inter Regular (400)
Code: JetBrains Mono

🔌 API tRPC Endpoints

Autenticação

auth.me - Obter usuário atual
auth.logout - Fazer logout

Pacientes

patients.create - Criar novo paciente
patients.list - Listar pacientes
patients.getById - Obter detalhes do paciente
patients.update - Atualizar paciente
patients.delete - Deletar paciente

Consultas

consultations.create - Criar nova consulta
consultations.getByPatient - Listar consultas do paciente
consultations.getById - Obter detalhes da consulta

IA

ai.generateSuggestions - Gerar sugestões de diagnóstico
ai.analyzeImage - Analisar imagem médica
ai.getSuggestionHistory - Histórico de sugestões

Explicabilidade

explanations.create - Criar explicação
explanations.getById - Obter explicação

Feedback

feedback.create - Registrar feedback
feedback.getStats - Estatísticas de feedback

Pesquisa Clínica

research.createProtocol - Criar protocolo de pesquisa
research.enrollParticipant - Inscrever participante
research.getProtocols - Listar protocolos

🧪 Testes & Qualidade de Código

Estratégia de Testes

Pirâmide de Testes

        🔺 E2E Tests (Poucos)
       🔺🔺 Integration Tests (Alguns)
    🔺🔺🔺🔺 Unit Tests (Muitos)

Comandos de Teste

# Executar todos os testes
pnpm test

# Testes unitários apenas
pnpm test tests/unit

# Testes de integração
pnpm test tests/integration

# Testes com cobertura
pnpm test:coverage

# Testes em modo watch
pnpm test:watch

# Testes do frontend
pnpm test:frontend

# Interface visual dos testes
pnpm test:ui

Cobertura de Código

# Gerar relatório de cobertura
pnpm test:coverage

# Visualizar relatório HTML
open coverage/index.html

Métricas de Qualidade

Cobertura Global: 90%+ (branches, functions, lines, statements)
Domain Layer: 95%+ (regras de negócio críticas)
Application Layer: 90%+ (casos de uso)
Infrastructure Layer: 85%+ (integrações)

Tipos de Teste Implementados

🔬 Testes Unitários

// Exemplo: Teste de Value Object
describe('CPF Value Object', () => {
  it('should validate Brazilian CPF correctly', () => {
    expect(CPF.isValid('11144477735')).toBe(true);
    expect(() => CPF.create('invalid')).toThrow();
  });
});

🔗 Testes de Integração

// Exemplo: Teste de Use Case
describe('CreatePatientUseCase Integration', () => {
  it('should create patient with repository', async () => {
    const useCase = new CreatePatientUseCase(repository);
    const result = await useCase.execute(validPatientData);
    expect(result.patient.id).toBeDefined();
  });
});

⚡ Testes de Performance

// Exemplo: Teste de performance
it('should complete analysis within 1 second', async () => {
  const startTime = Date.now();
  await aiAnalysisUseCase.execute(symptoms);
  const duration = Date.now() - startTime;
  expect(duration).toBeLessThan(1000);
});

🧪 Testes de Contrato

// Exemplo: Teste de interface
describe('IAIProvider Contract', () => {
  it('should implement all required methods', () => {
    const provider = new GeminiAIProvider(apiKey);
    expect(provider.analyzeSymptomsAsync).toBeDefined();
    expect(provider.healthCheck).toBeDefined();
  });
});

📊 Relatórios de Qualidade

Coverage Report

Gerado automaticamente em coverage/
Formatos: HTML, JSON, LCOV, Text
Thresholds configurados por camada

Test Results

Resultados detalhados por teste
Métricas de performance
Detecção de testes flaky

Code Quality Metrics

Complexidade ciclomática
Duplicação de código
Aderência aos padrões SOLID

📈 Roadmap

Curto Prazo (Próximos 3 meses)

✅ Explicabilidade de IA
✅ Dashboard LGPD
✅ Sistema de feedback
✅ Criptografia de dados
Validação com 5-10 médicos reais
Conformidade LGPD completa

Médio Prazo (3-6 meses)

✅ Análise de imagens médicas
✅ Protocolos de pesquisa
✅ Integração HL7/FHIR
Estudo clínico piloto
Integração com EHR real
Suporte a múltiplas especialidades

Longo Prazo (6-12 meses)

🔐 Segurança & Conformidade

LGPD (Lei Geral de Proteção de Dados)

✅ Criptografia end-to-end
✅ Consentimento explícito de pacientes
✅ Direito ao esquecimento
✅ Logs de auditoria completos
✅ Política de retenção de dados

Regulamentação Médica

✅ IA como auxílio, não substituição
✅ Revisão obrigatória de sugestões
✅ Rastreabilidade de decisões
✅ Conformidade com diretrizes clínicas

🎯 Implementação de Boas Práticas

Clean Code Principles

Nomenclatura Clara e Significativa

// ❌ Ruim
const d = new Date();
const u = users.filter(x => x.a > 18);

// ✅ Bom
const currentDate = new Date();
const adultUsers = users.filter(user => user.age > 18);

Funções Pequenas e Focadas

// ✅ Single Responsibility
class Patient {
  public getAge(): number {
    return Patient.calculateAge(this.birthDate);
  }

  public isElderly(): boolean {
    return this.getAge() >= 65;
  }
}

Comentários Significativos

/**
 * Valida CPF usando algoritmo oficial brasileiro
 * Complexidade: O(1) - algoritmo de tamanho fixo
 * @param value CPF sem formatação
 * @returns true se válido
 */
public static isValid(value: string): boolean {
  // Implementação...
}

Design Patterns em Ação

Strategy Pattern - Análise de IA

interface IAIAnalysisStrategy {
  analyze(symptoms: string[], providers: IAIProvider[]): Promise<AnalysisResult>;
}

class SingleProviderStrategy implements IAIAnalysisStrategy { /* ... */ }
class ConsensusStrategy implements IAIAnalysisStrategy { /* ... */ }
class FallbackStrategy implements IAIAnalysisStrategy { /* ... */ }

Factory Pattern - Provedores de IA

class AIProviderFactory {
  public createProvider(name: string): IAIProvider {
    const factory = this.providers.get(name);
    if (!factory) throw new Error(`Provider '${name}' not found`);
    return factory();
  }
}

Observer Pattern - Métricas

class MetricsCollector {
  private observers: Set<IMetricsObserver> = new Set();

  collectMetric(metric: IMetric): void {
    this.observers.forEach(observer => observer.onMetricCollected(metric));
  }
}

SOLID Principles Implementation

Single Responsibility Principle (SRP)

// ✅ Cada classe tem uma única responsabilidade
class CPF {
  // Responsabilidade: Validação e formatação de CPF
}

class Patient {
  // Responsabilidade: Regras de negócio do paciente
}

class PatientRepository {
  // Responsabilidade: Persistência de dados
}

Open/Closed Principle (OCP)

// ✅ Extensível sem modificação
interface IAIProvider {
  analyzeSymptomsAsync(symptoms: string[]): Promise<DiagnosisSuggestion[]>;
}

// Novas implementações sem modificar código existente
class GeminiAIProvider implements IAIProvider { /* ... */ }
class OpenAIProvider implements IAIProvider { /* ... */ }
class DeepSeekProvider implements IAIProvider { /* ... */ }

Liskov Substitution Principle (LSP)

// ✅ Subtipos substituíveis
function analyzeWithProvider(provider: IAIProvider) {
  // Funciona com qualquer implementação de IAIProvider
  return provider.analyzeSymptomsAsync(symptoms);
}

Interface Segregation Principle (ISP)

// ✅ Interfaces específicas e coesas
interface IRepository<T> {
  findById(id: string): Promise<T | null>;
  create(entity: T): Promise<T>;
}

interface IPaginatedRepository<T> extends IRepository<T> {
  findWithPagination(page: number, limit: number): Promise<PaginatedResult<T>>;
}

Dependency Inversion Principle (DIP)

// ✅ Dependência de abstrações
class CreatePatientUseCase {
  constructor(private repository: IRepository<Patient>) {}
  // Depende da abstração, não da implementação concreta
}

Microservices Patterns

Health Check Pattern

interface ProviderHealthStatus {
  isAvailable: boolean;
  responseTime: number;
  lastChecked: Date;
  errorRate: number;
}

class GeminiAIProvider {
  async healthCheck(): Promise<ProviderHealthStatus> {
    // Verifica saúde do provedor
  }
}

Circuit Breaker Pattern

class CircuitBreaker {
  private failureCount = 0;
  private state: 'CLOSED' | 'OPEN' | 'HALF_OPEN' = 'CLOSED';

  async execute<T>(operation: () => Promise<T>): Promise<T> {
    if (this.state === 'OPEN') {
      throw new Error('Circuit breaker is OPEN');
    }
    // Implementação...
  }
}

Performance & Scalability

Análise de Complexidade

/**
 * Complexidade das operações principais:
 *
 * - Busca por ID: O(1) - índice de banco
 * - Validação CPF: O(1) - algoritmo fixo
 * - Análise IA: O(n×m) - n provedores, m sintomas
 * - Cache LRU: O(1) - get/set
 * - Paginação: O(log n) - com índices
 */

Otimizações Implementadas

Cache Strategy: LRU, TTL, Hybrid caching
Database Indexing: Índices otimizados para consultas frequentes
Lazy Loading: Carregamento sob demanda
Connection Pooling: Pool de conexões do banco

Error Handling & Resilience

Tratamento de Erros Estruturado

class DomainError extends Error {
  constructor(message: string, public code: string) {
    super(message);
    this.name = 'DomainError';
  }
}

class ValidationError extends DomainError {
  constructor(field: string, value: any) {
    super(`Invalid ${field}: ${value}`, 'VALIDATION_ERROR');
  }
}

Retry Pattern

async function withRetry<T>(
  operation: () => Promise<T>,
  maxRetries: number = 3
): Promise<T> {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await operation();
    } catch (error) {
      if (attempt === maxRetries) throw error;
      await delay(attempt * 1000); // Exponential backoff
    }
  }
}

📚 Documentação Técnica

Arquitetura & Design

ARCHITECTURE.md - Documentação detalhada da arquitetura
API_REFERENCE.md - Referência completa da API
DEVELOPMENT_GUIDE.md - Guia de desenvolvimento

Qualidade & Conformidade

VITAIA_DESIGN_SYSTEM.md - Design system completo
ANVISA_COMPLIANCE.md - Conformidade regulatória
SCALABILITY_ROADMAP.md - Roadmap de escalabilidade
TESTING_GUIDE.md - Guia completo de testes

🤝 Contribuindo

Contribuições são bem-vindas! Por favor:

Faça um fork do projeto
Crie uma branch para sua feature (git checkout -b feature/AmazingFeature)
Commit suas mudanças (git commit -m 'Add some AmazingFeature')
Push para a branch (git push origin feature/AmazingFeature)
Abra um Pull Request

📝 Licença

Este projeto está licenciado sob a Licença MIT - veja o arquivo LICENSE para detalhes.

👥 Autores

VITAIA Team - Desenvolvimento de IA Médica

📞 Suporte

Para suporte, envie um email para vitaia@medical-ai.com ou abra uma issue no GitHub.

🙏 Agradecimentos

Google Gemini por fornecer LLM de alta qualidade
PUCPR pelo modelo Clinical-BR-LlaMA-2-7B
Comunidade médica brasileira por feedback e validação
Manus por infraestrutura e ferramentas

🎉 Implementação Completa de Boas Práticas

✅ Checklist de Implementação

✅ Clean Architecture - Estrutura em 4 camadas bem definidas
✅ Princípios SOLID - Todos os 5 princípios implementados
✅ Design Patterns - Factory, Strategy, Observer, Repository, Singleton
✅ Microservices Patterns - Health Check, Circuit Breaker, Retry
✅ Análise Assintótica - Complexidade Big O documentada
✅ Testes Unitários - Cobertura 90%+ configurada
✅ Testes de Integração - Use Cases testados
✅ Code Coverage - Thresholds por camada
✅ Documentação - README, Architecture, API Reference
✅ Estrutura Organizada - Clean Architecture aplicada
✅ Abstração - Interfaces bem definidas
✅ Baixo Acoplamento - Inversão de dependências
✅ Alta Extensibilidade - Padrões extensíveis
✅ Alta Coesão - Responsabilidades bem definidas
✅ Clean Code - Nomenclatura clara, funções focadas
✅ Limpeza de Arquivos - Script de cleanup implementado

📊 Métricas de Qualidade

Métrica	Valor	Status
Cobertura de Testes	90%+	✅
Princípios SOLID	5/5	✅
Design Patterns	6+	✅
Camadas Arquiteturais	4	✅
Documentação	Completa	✅
Análise Big O	Documentada	✅

🏆 Arquitetura de Classe Mundial

O VITAIA agora implementa uma arquitetura de classe mundial seguindo as melhores práticas da indústria:

Testabilidade: Cada componente pode ser testado isoladamente
Manutenibilidade: Mudanças são localizadas e controladas
Extensibilidade: Novos recursos podem ser adicionados facilmente
Escalabilidade: Pode crescer horizontal e verticalmente
Confiabilidade: Tratamento robusto de erros e falhas

VITAIA - A IA da Vida 🧬💚

Transformando a medicina através da inteligência artificial responsável com arquitetura de excelência

Name		Name	Last commit message	Last commit date
Latest commit History 32 Commits
client		client
docs		docs
drizzle		drizzle
nginx		nginx
patches		patches
scripts		scripts
server		server
shared		shared
tests		tests
.dockerignore		.dockerignore
.env.example		.env.example
.env.production		.env.production
.gitignore		.gitignore
.gitkeep		.gitkeep
.prettierignore		.prettierignore
.prettierrc		.prettierrc
.replit		.replit
ANVISA_COMPLIANCE.md		ANVISA_COMPLIANCE.md
CRITICAL_SECURITY_FIXES.md		CRITICAL_SECURITY_FIXES.md
Dockerfile		Dockerfile
IMPLEMENTATION_SUMMARY.md		IMPLEMENTATION_SUMMARY.md
LICENSE		LICENSE
MULTI_PROVIDER_AI_GUIDE.md		MULTI_PROVIDER_AI_GUIDE.md
README.md		README.md
SCALABILITY_ROADMAP.md		SCALABILITY_ROADMAP.md
SETUP_COMPLETO.md		SETUP_COMPLETO.md
SETUP_LOCAL.md		SETUP_LOCAL.md
TESTING_GUIDE.md		TESTING_GUIDE.md
VITAIA_DESIGN_SYSTEM.md		VITAIA_DESIGN_SYSTEM.md
cleanup-unused-files.sh		cleanup-unused-files.sh
components.json		components.json
docker-compose.yml		docker-compose.yml
drizzle.config.ts		drizzle.config.ts
eslint.config.js		eslint.config.js
package.json		package.json
pnpm-lock.yaml		pnpm-lock.yaml
replit.md		replit.md
todo.md		todo.md
tsconfig.json		tsconfig.json
vite.config.ts		vite.config.ts
vitest.config.ts		vitest.config.ts
vitest.frontend.config.ts		vitest.frontend.config.ts

Folders and files

Latest commit

History

Repository files navigation

VITAIA - A IA da Vida

🎯 Visão Geral

✨ Características Principais

🏗️ Arquitetura & Boas Práticas

Stack Tecnológico

🎯 Boas Práticas Implementadas

Clean Architecture

Princípios SOLID

Design Patterns Implementados

Microservices Patterns

Análise Assintótica (Big O)

Cobertura de Testes

📊 Estrutura do Banco de Dados

29 Tabelas Principais

🚀 Começando

🐳 Opção 1: Docker (Recomendado)

💻 Opção 2: Instalação Manual

Pré-requisitos

Instalação

Variáveis de Ambiente

📁 Estrutura do Projeto (Clean Architecture)

🎨 Princípios de Organização

Separação por Camadas

Inversão de Dependências

Coesão e Baixo Acoplamento

🎨 Design System VITAIA

Paleta de Cores

Tipografia

🔌 API tRPC Endpoints

Autenticação

Pacientes

Consultas

IA

Explicabilidade

Feedback

Pesquisa Clínica

🧪 Testes & Qualidade de Código

Estratégia de Testes

Pirâmide de Testes

Comandos de Teste

Cobertura de Código

Métricas de Qualidade

Tipos de Teste Implementados

🔬 Testes Unitários

🔗 Testes de Integração

⚡ Testes de Performance

🧪 Testes de Contrato

📊 Relatórios de Qualidade

Coverage Report

Test Results

Code Quality Metrics

📈 Roadmap

Curto Prazo (Próximos 3 meses)

Médio Prazo (3-6 meses)

Longo Prazo (6-12 meses)

🔐 Segurança & Conformidade

LGPD (Lei Geral de Proteção de Dados)

Regulamentação Médica

🎯 Implementação de Boas Práticas

Clean Code Principles

Nomenclatura Clara e Significativa

Funções Pequenas e Focadas

Comentários Significativos

Design Patterns em Ação

Strategy Pattern - Análise de IA

Factory Pattern - Provedores de IA

Observer Pattern - Métricas

SOLID Principles Implementation

Single Responsibility Principle (SRP)

Open/Closed Principle (OCP)

Liskov Substitution Principle (LSP)

Interface Segregation Principle (ISP)

Dependency Inversion Principle (DIP)

Microservices Patterns

Health Check Pattern

Circuit Breaker Pattern

Packages