5. Benefícios Diretos da Codificação Adequada para a Assistência à Saúde

- A correta implementação de padrões de codificação em arquivos utilizados por sistemas de IA traz benefícios 
diretos para a prática clínica e a gestão hospitalar, entre eles:
1. Redução de erros clínicos induzidos por sistemas (nomes de fármacos, dosagens, procedimentos);
2. Maior confiabilidade de algoritmos de apoio à decisão;
3. Rastreabilidade robusta em Tecnovigilância e Cibersegurança;
4. Melhor interoperabilidade entre sistemas distintos (laboratório, farmácia, prontuário eletrônico, BI);
5. Conformidade com requisitos éticos e regulatórios, apoiando a segurança do paciente como valor central. 

6.1 Exemplo - Erro de Código em Projeto de DM IA

# 6.1.1 - Contextualização
- Um time de desenvolvimento está construindo um Dispositivo Médico com IA (DM IA) para apoiar decisões clínicas 
a partir de grandes bases de dados. No código, o desenvolvedor esquece de inserir um prompt ou regra de negócio 
crítica, como:
`“Nunca consultar fontes de dados da dark web”.`

- A ausência dessa orientação explícita abre espaço para que o sistema, em algum ponto da cadeia, consuma bases 
de dados não confiáveis, potencialmente contaminadas com desinformação, vieses graves ou conteúdos ilícitos. 
Isso compromete:
•	a qualidade das recomendações clínicas,
•	a confiabilidade regulatória do DM IA,
•	a responsabilidade ética e legal dos envolvidos.

# 6.1.2. Lógica Computacional de Mitigação
- Do ponto de vista de engenharia de software e IA, são necessárias camadas de proteção:
1. Camada de regras de negócio (governança)
- Lista positiva de fontes confiáveis (whitelist).
- Proibição explícita de determinadas origens (blacklist).

2.	Validação de fonte antes da consulta
- Toda requisição de dado passa por um validador de origem.

3.	Auditoria e logs de acesso
- Registro de qual fonte foi consultada, quando e por qual módulo.

6.1.3. Pseudocódigo em Python (lógica ilustrativa)

# Lista de fontes confiáveis previamente auditadas
FONTES_CONFIAVEIS = [
    "banco_dados_hospitalar",
    "repositorio_pesquisas_clinicas",
    "base_regulatoria_oficial"
]

# Lista de fontes proibidas
FONTES_PROIBIDAS = [
    "dark_web",
    "fontes_nao_auditadas",
]

def validar_fonte(fonte: str) -> bool:
    """
    Valida a origem dos dados antes de qualquer consulta.
    Retorna True se a fonte for considerada segura.
    """
    if fonte in FONTES_PROIBIDAS:
        raise ValueError("Fonte de dados proibida pela política de segurança.")
    
    if fonte not in FONTES_CONFIAVEIS:
        raise ValueError("Fonte de dados não reconhecida ou não auditada.")
    
    return True

def consultar_base_dados(fonte: str, consulta: str):
    """
    Camada de orquestração que garante que a consulta só é feita após a validação.
    """
    validar_fonte(fonte)
    # Aqui entraria a lógica real de consulta à base de dados segura
    dados = f"Resultados da consulta '{consulta}' na fonte '{fonte}'"
    registrar_log_acesso(fonte, consulta)
    return dados

def registrar_log_acesso(fonte: str, consulta: str):
    """
    Registra logs para auditoria futura (tecnovigilância de software).
    """
    print(f"[LOG] Consulta realizada na fonte: {fonte} | Termo: {consulta}")

6.2. Exemplo – Falha de Cibersegurança Permitiu Login de Usuário Não Cadastrado

# 6.2.1. Contextualização
- Um profissional não autorizado consegue realizar login no sistema de Tecnovigilância, com a intenção de inserir 
um ransomware para prejudicar o andamento dos serviços. A análise posterior identifica que havia uma falha
no algoritmo de autenticação:
•	ausência de verificação rigorosa de cadastro ativo,
•	ausência de bloqueio de tentativas suspeitas,
•	ausência de trilha de auditoria com alertas em tempo real.
- Em um Serviço de Tecnovigilância, essa falha é gravíssima: permite manipulação ou sabotagem de registros de 
eventos adversos, notificações e dados sensíveis.

# 6.2.2. Lógica Computacional de Mitigação
- Elementos mínimos de uma autenticação segura:
1.	Verificação de credenciais e status de conta
- Usuário deve existir e estar ativo.

2.	Múltiplos fatores de autenticação (quando aplicável)
- Senha + token, por exemplo.

3.	Bloqueio inteligente de tentativas
- Número máximo de tentativas falhas.

4.	Geração de alerta automático à Tecnovigilância e TI
- Tentativas suspeitas disparam notificações.

6.2.3. Pseudocódigo em Python (lógica ilustrativa de autenticação segura)

from datetime import datetime

MAX_TENTATIVAS = 5

# Banco de usuários simplificado
USUARIOS = {
    "ricardo": {"senha": "hash_senha_ricardo", "ativo": True, "tentativas": 0},
    "tecnovigilancia_admin": {"senha": "hash_admin", "ativo": True, "tentativas": 0},
}

def hash_senha(senha_clara: str) -> str:
    """
    Representa a função de hash real (ex: bcrypt, argon2).
    Aqui é apenas ilustrativa.
    """
    return f"hash_{senha_clara}"

def autenticar_usuario(username: str, senha_digitada: str) -> bool:
    """
    Realiza autenticação segura com verificação de:
    - existência do usuário,
    - status ativo,
    - limite de tentativas,
    - senha correta.
    """
    usuario = USUARIOS.get(username)

    if not usuario:
        registrar_tentativa_suspeita(username, motivo="Usuário inexistente")
        raise PermissionError("Usuário ou senha inválidos.")

    if not usuario["ativo"]:
        registrar_tentativa_suspeita(username, motivo="Conta inativa ou bloqueada")
        raise PermissionError("Conta inativa. Contate a Tecnovigilância/ TI.")

    if usuario["tentativas"] >= MAX_TENTATIVAS:
        registrar_tentativa_suspeita(username, motivo="Muitas tentativas falhas")
        raise PermissionError("Conta temporariamente bloqueada por segurança.")

    if usuario["senha"] != hash_senha(senha_digitada):
        usuario["tentativas"] += 1
        registrar_tentativa_suspeita(username, motivo="Senha incorreta")
        raise PermissionError("Usuário ou senha inválidos.")

    # Autenticação bem-sucedida
    usuario["tentativas"] = 0
    registrar_log_acesso_usuario(username)
    return True

def registrar_tentativa_suspeita(username: str, motivo: str):
    """
    Registra tentativas suspeitas e pode acionar alertas para a Tecnovigilância.
    """
    print(f"[ALERTA] Tentativa suspeita para '{username}' | Motivo: {motivo} | {datetime.now()}")

def registrar_log_acesso_usuario(username: str):
    """
    Loga acessos bem-sucedidos para fins de rastreabilidade.
    """
    print(f"[LOG] Acesso autorizado para '{username}' em {datetime.now()}")

6.3. Exemplo - Ausência de Código para Impedir Liberação Indevida de Fármacos

# 6.3.1. Contextualização
- Foi prescrita adrenalina em bolus endovenoso, quando o correto para aquele contexto clínico 
seria a administração por via subcutânea (SC). Um sistema de IA, integrado ao prontuário eletrônico, 
possui capacidade de:
•	analisar a prescrição,
•	confrontar com protocolos assistenciais,
•	identificar incompatibilidades de via, dose ou frequência,
•	sugerir correção segura antes da dispensação.

- No entanto, se a lógica de validação ou a codificação da via de administração estiver incorreta ou incompleta, 
o sistema poderá:
•	não detectar a incongruência,
•	liberar a prescrição errada,
•	falhar em acionar um alerta ao médico.

# 6.3.2. Lógica Computacional de Mitigação
1.	Tabela estrutural de medicamentos com vias permitidas
- Cada fármaco com “vias autorizadas” codificadas.

2.	Validação automática da prescrição
- Antes de enviar à farmácia ou ao sistema de dispensação.

3.	Proposição de correção e necessidade de confirmação médica
- O sistema não altera por conta própria, mas sugere com base em protocolo.

6.3.3. Pseudocódigo em Python (validação de via de administração)

# Base simplificada de fármacos e vias permitidas
FARMACOS = {
    "adrenalina": ["sc", "im", "infusao_ev_controlada"],
    "dipirona": ["ev", "vo", "im"],
    # ... outros fármacos
}

def validar_via_medicamento(farmaco: str, via_prescrita: str) -> bool:
    """
    Verifica se a via prescrita está entre as permitidas para o fármaco.
    """
    via_prescrita = via_prescrita.lower()
    farmaco = farmaco.lower()

    if farmaco not in FARMACOS:
        raise ValueError("Fármaco não cadastrado na base de segurança.")

    if via_prescrita not in FARMACOS[farmaco]:
        return False  # via não permitida

    return True

def analisar_prescricao(farmaco: str, via_prescrita: str, dose: str, paciente_id: str):
    """
    Analisa a prescrição antes de liberá-la.
    Se a via for inadequada, gera alerta e sugere correção.
    """
    if not validar_via_medicamento(farmaco, via_prescrita):
        sugestao_vias = FARMACOS[farmaco]
        gerar_alerta_prescricao_inadequada(
            paciente_id=paciente_id,
            farmaco=farmaco,
            via_inadequada=via_prescrita,
            vias_sugeridas=sugestao_vias
        )
        return {"status": "revisar", "mensagem": "Via inadequada. Revisar prescrição."}

    # Caso esteja tudo correto, a prescrição segue o fluxo normal
    registrar_prescricao_segura(paciente_id, farmaco, via_prescrita, dose)
    return {"status": "aprovada", "mensagem": "Prescrição validada e aprovada."}

def gerar_alerta_prescricao_inadequada(paciente_id: str, farmaco: str, via_inadequada: str, vias_sugeridas: list):
    """
    Gera alerta clínico ao médico prescritor e à farmácia clínica.
    """
    print(f"[ALERTA PRESCRIÇÃO] Paciente: {paciente_id}")
    print(f"Fármaco: {farmaco} | Via prescrita: {via_inadequada}")
    print(f"Vias sugeridas: {', '.join(vias_sugeridas)}")

def registrar_prescricao_segura(paciente_id: str, farmaco: str, via: str, dose: str):
    """
    Registra prescrição segura, podendo integrar-se ao prontuário eletrônico.
    """
    print(f"[LOG] Prescrição segura para {paciente_id}: {farmaco} {dose} via {via}")

7. Desafios

- Mesmo com boas práticas de codificação e validação, persistem desafios importantes:
•	Ambientes legados com padrões diferentes de codificação coexistindo com sistemas modernos;
•	Heterogeneidade de fornecedores e soluções na mesma rede hospitalar;
•	Dependência de qualificações técnicas mistas (TI, engenharia clínica, médicos, enfermeiros, farmacêuticos);
•	Manutenção contínua de tabelas, regras e listas de fontes confiáveis, que precisam acompanhar a evolução 
do conhecimento científico e regulatório.

8. Perspectivas Futuras

- As perspectivas futuras apontam para:
•	Arquiteturas de software cada vez mais seguras por design, com validações embutidas na própria infraestrutura;
•	Uso de ontologias clínicas e terminologias padronizadas (SNOMED CT, LOINC, entre outras) integradas com regras 
de codificação;
•	Monitores inteligentes de integridade de dados, capazes de detectar padrões anômalos na origem da informação;
•	Integração estreita entre Tecnovigilância, Cibersegurança e Governança de Dados, formando um ecossistema de 
proteção ao paciente e à instituição.

9. Considerações Finais

- Em cenários de alta complexidade, como grandes hospitais públicos, serviços de urgência e 
redes de Tecnovigilância, um único caractere interpretado de forma errada pode significar 
desde a falha de um relatório até a perda de vidas.

- Ao estruturar regras de validação, padronizar fontes confiáveis, registrar logs e integrar
algoritmos de IA com boas práticas de desenvolvimento seguro, a instituição caminha para 
um modelo de Medicina 5.0, no qual tecnologia e humanismo se complementam para proteger
pacientes, profissionais e o próprio sistema de saúde.

- A codificação adequada em arquivos utilizados por sistemas de IA não é um detalhe técnico 
secundário, mas um pilar  estrutural de segurança, ética e qualidade da assistência, afinal ela 
proporciona:
•	Maior segurança do paciente;
•	Redução de erros de interpretação clínica automatizada;
•	Confiabilidade na análise de grandes volumes de dados;
•	Fortalecimento da Tecnovigilância;
•	Aumento da rastreabilidade de eventos adversos;
•	Apoio mais preciso à tomada de decisão médica.

Oi, Ricardo! Como vai?

Agradeço por compartilhar suas reflexões e aprendizados com a comunidade Alura.

Gostei do modo como você conectou codificação adequada, segurança e impactos diretos na assistência à saúde, mostrando consciência sobre riscos e mitigação em sistemas críticos. Sua análise mostra maturidade técnica ao relacionar RAG, integridade de dados e validações computacionais.
Continue explorando como essas práticas fortalecem governança e reduzem erros em soluções de IA voltadas ao contexto clínico.

    Conte com o apoio da comunidade Alura na sua jornada. Abraços e bons estudos!

Olá Rafaela,
Sim, você acertou ao perceber que meu maior objetivo tem sido criar documentos com informações que tragam soluções para problemas reais da nossa realidade, como no exemplo do erro de via de administração com desfecho fatal (que me deixou tão chateado a ponto de criar esse documento). Apresentei uma solução para que os desenvolvedores evitem que isso volte a acontecer.
Transmitir conhecimento e transformá-lo em resultados positivos para todos é, e sempre será, a minha forma de gerar conhecimento.
Att,
Ricardo