Se sua empresa usa inteligencia artificial -- e 42% das brasileiras ja usam, segundo o IBGE -- o relogio esta correndo. O PL 2338/2023, que regula o uso de IA no Brasil, pode ser votado na Camara dos Deputados em 16 de junho de 2026, segundo o presidente Hugo Motta. E as multas previstas chegam a R$ 50 milhoes por infracao.

O problema e que mais de 60% das organizacoes ainda nao tem politicas especificas para uso de IA pelos colaboradores (Fonte: IAPP, citado no Guia Pratico de Compliance IA 2026 do IBGIA). E um fenomeno conhecido como shadow AI: equipes usando ChatGPT, ferramentas de geracao de imagem e chatbots sem que o departamento de compliance sequer saiba. Quando a lei entrar em vigor, cada um desses sistemas precisara estar catalogado, classificado por risco e documentado.

Este tutorial resolve exatamente isso. Voce vai construir, em Python, um sistema de compliance de IA que usa o Sabia-4 da Maritaca AI -- o modelo de linguagem mais avancado treinado especificamente para portugues brasileiro -- para automatizar cada etapa do processo: inventario de sistemas, classificacao de risco e avaliacao de impacto algoritmico.

"Eu vou trabalhar, enquanto presidente, para que essa Comissao Especial possa apresentar o seu relatorio agora no mes de junho e, quem sabe, ate o final do mes a Camara tenha a condicao de avancar nisso." -- Hugo Motta, presidente da Camara dos Deputados, em 28/05/2026

O relator Aguinaldo Ribeiro apresentara o parecer em 9 de junho. Se voce quer evitar multas de 2% do faturamento da sua empresa no Brasil -- ou os R$ 50 milhoes por infracao -- comecar agora e estrategico, nao opcional.

O Que Voce Vai Construir

Ao final deste tutorial, voce tera seis scripts e modulos Python que formam o esqueleto de um sistema de governanca de IA:

1. Um inventario automatizado que mapeia todos os sistemas de IA em uso
2. Um classificador de risco que aplica os criterios do PL 2338
3. Um gerador de Avaliacao de Impacto Algoritmico (AIA) semiautomatizado
4. Um sistema de logging para decisoes automatizadas
5. Um canal de contestacao com supervisao humana
6. Um dashboard de compliance em JSON auditavel

O mercado global de governanca de IA deve atingir US$ 492 milhoes em 2026 e ultrapassar US$ 1 bilhao ate 2030, segundo a Gartner. Empresas com plataformas de governanca sao 3,4 vezes mais eficazes na gestao de riscos (Fonte: Gartner, via IBGIA). O que voce vai construir aqui e o ponto de partida.

Pre-requisitos

• Python 3.10 ou superior instalado
• Pip para gerenciamento de pacotes
• Uma conta gratuita na Maritaca AI (https://maritaca.ai)
• Conhecimento basico de Python e JSON
• Cerca de R$ 5 a R$ 20 para testar a API (os precos do Sabia-4 sao R$ 5,00/input e R$ 20,00/output por 1 milhao de tokens; o Sabiazinho-4 custa R$ 1,00 e R$ 4,00 — Fonte: docs.maritaca.ai/pt/precos)

Para este tutorial, vamos usar o Sabiazinho-4 -- que custa 5x menos e entrega resultados solidos para as tarefas de estruturacao e classificacao. Se precisar de mais contexto (o Sabia-4 tem 128 mil tokens), e so trocar o nome do modelo.

Passo 1: Setup do Ambiente

Crie um diretorio para o projeto e instale as dependencias.

mkdir compliance-ia-pl2338
cd compliance-ia-pl2338
python -m venv venv
source venv/bin/activate  # Linux/Mac
# ou .\venv\Scripts\activate  # Windows
pip install openai python-dotenv

A API da Maritaca e 100% compativel com a OpenAI. A unica diferenca e a base_url. Crie um arquivo .env na raiz do projeto:

MARITACA_API_KEY=sua-chave-aqui

E um arquivo config.py para centralizar as configuracoes:

import os
from dotenv import load_dotenv

load_dotenv()

CLIENT = OpenAI( api_key=os.getenv("MARITACA_API_KEY"), base_url="https://api.maritaca.ai/v1" )

MODEL = "sabiazinho-4" # ou "sabia-4" para maior capacidade

Teste a conexao com um script simples:

from config import CLIENT, MODEL

response = CLIENT.chat.completions.create( model=MODEL, messages=[ {"role": "system", "content": "Responda em portugues brasileiro."}, {"role": "user", "content": "O que e o PL 2338/2023?"} ] ) print(response.choices[0].message.content)

Se aparecer uma explicacao sobre o projeto de lei que regula inteligencia artificial no Brasil, a conexao funcionou.

Passo 2: Inventario de Sistemas de IA

O PL 2338 exige que as empresas mantenham um inventario atualizado de todos os sistemas de IA em operacao. Isso inclui desde chatbots internos ate sistemas de scoring de credito e ferramentas de RH.

O problema e que muitas equipes nem sabem quantos sistemas de IA estao rodando. O script abaixo gera um questionario estruturado e usa o Sabiazinho-4 para ajudar o usuario a mapear cada sistema.

import json
from config import CLIENT, MODEL

def gerar_questionario_inventario(): prompt = """ Gere uma lista de 10 perguntas para mapear sistemas de IA em uma empresa brasileira, conforme os requisitos do PL 2338/2023. As perguntas devem incluir: - Nome e proposito do sistema - Departamento responsavel - Tipo de dados processados (pessoais, sensiveis, publicos) - Decisoes automatizadas com efeitos legais? - Ha supervisao humana? - O sistema interage com clientes ou apenas uso interno? - Fornecedor do sistema (proprietario, terceiro, open source) - Volume de decisoes por mes

Retorne APENAS um JSON array com objetos contendo "pergunta" e "campo".
"""

response = CLIENT.chat.completions.create(
    model=MODEL,
    messages=[{"role": "user", "content": prompt}],
    response_format={"type": "json_object"}
)
return json.loads(response.choices[0].message.content)

def inventariar_sistema(): print("=== INVENTARIO DE SISTEMAS DE IA ===") print("Preencha os dados para cada sistema identificado.\n")

sistemas = []

while True:
    nome = input("Nome do sistema (ou 'fim' para encerrar): ")
    if nome.lower() == "fim":
        break
        
    sistema = {
        "nome": nome,
        "departamento": input("Departamento: "),
        "proposito": input("Proposito: "),
        "dados_pessoais": input("Processa dados pessoais? (sim/nao): "),
        "decisao_automatizada": input("Toma decisoes automatizadas com efeitos legais? (sim/nao): "),
        "supervisao_humana": input("Ha supervisao humana? (sim/nao): "),
        "interacao_clientes": input("Interage com clientes? (sim/nao): "),
        "fornecedor": input("Fornecedor (proprietario/terceiro/open source): "),
        "volume_mensal": input("Volume estimado de decisoes por mes: ")
    }
    sistemas.append(sistema)
    print(f"Sistema '{nome}' registrado.\n")

return sistemas

Este script pode ser estendido para varrer a rede corporativa em busca de chamadas de API desconhecidas. O importante e ter pelo menos uma lista inicial -- o Sabiazinho-4 ajuda a estruturar a coleta de maneira consistente com o que a ANPD e o PL 2338 esperam.

Passo 3: Classificacao de Risco

O PL 2338 classifica sistemas de IA em tres niveis de risco, conforme a tabela abaixo:

A proposta mais recente do relator Aguinaldo Ribeiro sugere delegar a classificacao detalhada para agencias reguladoras setoriais, mas a estrutura de tres niveis deve permanecer.

O script abaixo usa function calling do Sabiazinho-4 para classificar cada sistema do inventario:

from config import CLIENT, MODEL
import json

def classificar_risco(sistema): tools = [{ "type": "function", "function": { "name": "classificar_sistema_ia", "description": "Classifica um sistema de IA conforme o PL 2338/2023", "parameters": { "type": "object", "properties": { "nivel_risco": { "type": "string", "enum": ["excessivo", "alto", "baixo"] }, "justificativa": {"type": "string"}, "artigos_aplicaveis": { "type": "array", "items": {"type": "string"} } }, "required": ["nivel_risco", "justificativa"] } } }]

prompt = f"""
Classifique o seguinte sistema de IA conforme o PL 2338/2023:

Nome: {sistema['nome']}
Proposito: {sistema['proposito']}
Departamento: {sistema['departamento']}
Processa dados pessoais: {sistema['dados_pessoais']}
Decisoes automatizadas com efeitos legais: {sistema['decisao_automatizada']}
Supervisao humana: {sistema['supervisao_humana']}
Interacao com clientes: {sistema['interacao_clientes']}
Volume mensal: {sistema['volume_mensal']}
"""

response = CLIENT.chat.completions.create(
    model=MODEL,
    messages=[{"role": "user", "content": prompt}],
    tools=tools,
    tool_choice="auto"
)

if response.choices[0].message.tool_calls:
    return json.loads(
        response.choices[0].message.tool_calls[0].function.arguments
    )
return None

Uso:

sistemas = inventariar_sistema() for sistema in sistemas: classificacao = classificar_risco(sistema) if classificacao: sistema["classificacao"] = classificacao print(f"{sistema['nome']}: {classificacao['nivel_risco'].upper()}") print(f" Justificativa: {classificacao['justificativa']}\n")

O resultado e uma lista de todos os seus sistemas com o nivel de risco atribuido. Sistemas classificados como risco excessivo precisam ser descontinuados. Sistemas de alto risco exigem a Avaliacao de Impacto Algoritmico.

Passo 4: Avaliacao de Impacto Algoritmico (AIA)

O Artigo 25 do PL 2338 exige que sistemas de alto risco passem por uma avaliacao de impacto algoritmico antes de entrar em operacao. O documento deve conher analise de riscos, medidas de mitigacao e protocolos de supervisao humana.

O script abaixo coleta os inputs do usuario e usa o Sabiazinho-4 para redigir o documento tecnico:

from config import CLIENT, MODEL

def gerar_aia(sistema, classificacao): prompt = f""" Voce e um especialista em compliance de IA. Redija uma Avaliacao de Impacto Algoritmico (AIA) conforme o Artigo 25 do PL 2338/2023 para o seguinte sistema:

SISTEMA: {sistema['nome']}
DEPARTAMENTO: {sistema['departamento']}
PROPÓSITO: {sistema['proposito']}
NIVEL DE RISCO: {classificacao['nivel_risco']}
JUSTIFICATIVA: {classificacao['justificativa']}

A AIA deve incluir:
1. Descricao detalhada do sistema e seu proposito
2. Identificacao de riscos potenciais (vies, discriminacao, privacidade, seguranca)
3. Medidas de mitigacao propostas
4. Protocolo de supervisao humana
5. Periodicidade de revisao sugerida
6. Responsaveis pela governanca do sistema

Formato: documento tecnico em markdown, com secoes numeradas.
Tom formal e tecnico, adequado para auditoria regulatoria.

Retorne APENAS o documento, sem comentarios adicionais.
"""

response = CLIENT.chat.completions.create(
    model=MODEL,
    messages=[{"role": "user", "content": prompt}],
    max_tokens=2000
)

return response.choices[0].message.content

Salva a AIA em um arquivo

def salvar_aia(sistema, documento): nome_arquivo = f"aia_{sistema['nome'].lower().replace(' ', '_')}.md" with open(nome_arquivo, "w", encoding="utf-8") as f: f.write(f"# Avaliacao de Impacto Algoritmico\n") f.write(f"Sistema: {sistema['nome']}\n") f.write(f"Data: 2026-05-31\n\n") f.write(documento) print(f"AIA salva em: {nome_arquivo}")

Exemplo de uso

for sistema in sistemas: if sistema.get("classificacao", {}).get("nivel_risco") == "alto": doc = gerar_aia(sistema, sistema["classificacao"]) salvar_aia(sistema, doc)

O Sabiá-4 foi treinado em corpus juridico brasileiro, o que significa que ele entende o contexto regulatorio nacional melhor que modelos genericos (Fonte: arXiv, Technical Report Sabiá-4). O resultado e um documento consistente com a linguagem esperada por auditorias.

Passo 5: Logging de Transparencia

O PL 2338 exige que decisoes automatizadas sejam rastreaveis. O script abaixo cria um sistema de logging que registra cada decisao de IA em um arquivo JSON auditavel:

import json
from datetime import datetime

class AuditLogger: def init(self, arquivo="auditoria_ia.jsonl"): self.arquivo = arquivo

def registrar_decisao(self, sistema, input_usuario, output_ia, acao_tomada):
    registro = {
        "timestamp": datetime.utcnow().isoformat(),
        "sistema": sistema,
        "input_resumido": input_usuario[:200],
        "output_resumido": output_ia[:500],
        "acao_tomada": acao_tomada,
        "revisao_humana_necessaria": False,
        "revisao_realizada": None,
        "versao_modelo": MODEL
    }
    
    with open(self.arquivo, "a", encoding="utf-8") as f:
        f.write(json.dumps(registro, ensure_ascii=False) + "\n")
    
    return registro

def marcar_revisao_humana(self, timestamp, revisor, resultado):
    registros = []
    with open(self.arquivo, "r", encoding="utf-8") as f:
        for linha in f:
            reg = json.loads(linha)
            if reg["timestamp"] == timestamp:
                reg["revisao_humana_necessaria"] = True
                reg["revisao_realizada"] = {
                    "revisor": revisor,
                    "data": datetime.utcnow().isoformat(),
                    "resultado": resultado
                }
            registros.append(reg)
    
    with open(self.arquivo, "w", encoding="utf-8") as f:
        for reg in registros:
            f.write(json.dumps(reg, ensure_ascii=False) + "\n")

Uso

logger = AuditLogger() logger.registrar_decisao( sistema="chatbot-atendimento-v1", input_usuario="Quero cancelar meu contrato", output_ia="Para cancelar, acesse a seção de contratos...", acao_tomada="informacao_fornecida" )

O formato JSON Lines (.jsonl) permite que voce importe os dados para qualquer ferramenta de analise ou dashboard. Cada decisao fica registrada com timestamp, versao do modelo e rastro de auditoria -- exatamente o que a fiscalizacao do PL 2338 vai procurar.

Passo 6: Canal de Contestacao com Supervisao Humana

O PL 2338 garante ao usuario o direito de contestar decisoes automatizadas. O script abaixo cria um assistente que revisa a contestacao, avalia se o modelo agiu corretamente e encaminha para revisao humana quando necessario:

from config import CLIENT, MODEL
import json

class CanalContestacao: def init(self, logger): self.logger = logger

def revisar_contestacao(self, sistema, decisao_original, contestacao_usuario):
    prompt = f"""
    Revisao de contestacao de decisao automatizada.
    
    Sistema: {sistema}
    Decisao original: {decisao_original}
    Contestacao do usuario: {contestacao_usuario}
    
    Analise:
    1. A decisao original estava correta com base nos dados disponiveis?
    2. A contestacao do usuario tem fundamento?
    3. Qual o nivel de confianca na revisao (0-100%)?
    4. Recomenda revisao humana?
    
    Retorne um JSON com: "decisao_mantida" (bool), "nivel_confianca" (int),
    "justificativa" (str), "revisao_humana_recomendada" (bool).
    """
    
    response = CLIENT.chat.completions.create(
        model=MODEL,
        messages=[{"role": "user", "content": prompt}],
        response_format={"type": "json_object"}
    )
    
    resultado = json.loads(response.choices[0].message.content)
    
    self.logger.registrar_decisao(
        sistema=sistema,
        input_usuario=contestacao_usuario,
        output_ia=json.dumps(resultado),
        acao_tomada="contestacao_revisada"
    )
    
    return resultado

Fluxo completo de contestacao

def processar_contestacao(): logger = AuditLogger() canal = CanalContestacao(logger)

print("=== CANAL DE CONTESTACAO DE DECISOES DE IA ===")
sistema = input("Nome do sistema que tomou a decisao: ")
decisao = input("Decisao original do sistema: ")
contestacao = input("Contestacao do usuario: ")

resultado = canal.revisar_contestacao(sistema, decisao, contestacao)

print(f"\nDecisao mantida: {resultado['decisao_mantida']}")
print(f"Confianca: {resultado['nivel_confianca']}%")
print(f"Justificativa: {resultado['justificativa']}")

if resultado["revisao_humana_recomendada"]:
    print("\n[ATENCAO] Revisao humana recomendada!")
    revisor = input("Nome do revisor humano: ")
    parecer = input("Parecer final do revisor: ")
    # Aqui voce registra a revisao humana no logger
else:
    print("\nContestacao processada automaticamente.")

if name == "main": processar_contestacao()

A chave aqui e que o sistema nunca toma a decisao final sozinho quando o nivel de confianca e baixo. A supervisao humana obrigatoria para sistemas de alto risco e um dos pilares do PL 2338, e este canal garante que o processo esteja documentado e auditavel.

Tabela Resumo: O Que Cada Passo Resolve

Proximos Passos e Checklist Final

O tutorial que voce acabou de seguir cobre o basico do que o PL 2338 vai exigir. Mas a lei e mais ampla. Aqui vai um checklist do que sua empresa precisa ter ate a votacao:

• Inventario completo de todos os sistemas de IA (incluindo shadow AI)
• Classificacao de risco para cada sistema
• AIA para todos os sistemas de alto risco
• Sistema de logging de decisoes automatizadas
• Canal de contestacao documentado
• Politica interna de uso de IA aprovada pela diretoria
• DPO ou responsavel pela governanca de IA designado
• Revisao juridica do enquadramento dos sistemas

O Sabia-4 e o Sabiazinho-4 tornam esse processo viavel ate para PMEs. Com um investimento de R$ 5 a R$ 20 por 1 milhao de tokens, voce automatiza a parte burocratica e libera sua equipe para o que realmente importa: construir IA responsavel.

O mercado de governanca de IA esta explodindo -- US$ 492 milhoes em 2026, segundo a Gartner. Mas mais importante que o numero e o principio: empresas que documentam e auditam seus sistemas de IA nao so evitam multas, como constroem confianca com clientes, regulatorse e investidores.

O PL 2338 nao e o fim da inovacao. E o comeco da maturidade. E com Python e o Sabia-4, sua empresa ja pode comecar hoje.

Fontes

• R7: Motta pretende pautar projeto que regula uso de IA para 16 de junho
• Valor: Ceticismo sobre votacao da regulamentacao da IA em junho
• O Globo: Relator propoe deixar classificacao de risco para agencias reguladoras
• Analise completa da regulacao de IA no Brasil 2026
• Guia pratico de compliance IA corporativo 2026
• OpenClaw: Regulamentacao IA Brasil 2026
• Precos da API Maritaca AI
• Technical Report Sabia-4 (arXiv)
• ANPD: Tomada de subsidios sobre tratamento automatizado de dados