Cumplimiento normativo y pista de auditoría
En esta página
Cumplimiento normativo y pista de auditoría
Para las aplicaciones de IA en producción, la trazabilidad es esencial. Una pista de auditoría completa te protege durante una inspección, una disputa o un incidente. Esta lección muestra cómo implementar un sistema de auditoría robusto, cerrando el curso al integrar todo lo que has construido hasta ahora —registro, moderación y protección de datos— en un único marco defendible.
¿Por qué una pista de auditoría?
Cuatro necesidades distintas convergen en la misma infraestructura. Primero, el cumplimiento normativo: el RGPD, la Ley de IA europea y los estándares del sector exigen que demuestres qué hace tu sistema, y una demostración sin registros no sirve para nada. Segundo, la trazabilidad en sentido estricto: saber quién hizo qué, cuándo, con qué resultado, incluso seis meses después. La depuración se beneficia diariamente de esto, ya que entender el comportamiento inesperado del modelo requiere recuperar las condiciones exactas de la llamada. Por último, la responsabilidad: documentar las decisiones tomadas por la IA es lo que te permitirá, llegado el momento, demostrar que una recomendación controvertida se basó en un proceso controlado.
Estructura de un registro de auditoría
La dataclass siguiente es tanto un contrato como una estructura de datos. Agrupa identificadores, contexto de la aplicación, la solicitud, la respuesta, el veredicto de moderación y metadatos técnicos. Dos decisiones merecen tu atención. El identificador de usuario aparece solo en forma hash, nunca en texto plano. Y el prompt no se almacena: solo su hash y su longitud. Esto preserva tu capacidad para demostrar que dos llamadas concernían al mismo contenido sin crear nunca un archivo de lo que escribieron tus usuarios.
from dataclasses import dataclass, field, asdict
from datetime import datetime
from typing import Optional
import json
import uuid
import hashlib
@dataclass
class AuditRecord:
"""Registro de auditoría para una llamada a la API."""
# Identificadores
audit_id: str = field(default_factory=lambda: str(uuid.uuid4()))
timestamp: str = field(
default_factory=lambda: datetime.now().isoformat()
)
# Contexto
user_id_hash: str = "" # Nunca el ID en claro
session_id: str = ""
application: str = ""
# Solicitud (sin datos sensibles)
model: str = ""
prompt_hash: str = "" # Hash del prompt, no el prompt en sí
prompt_length: int = 0
# Respuesta
response_id: str = ""
output_length: int = 0
input_tokens: int = 0
output_tokens: int = 0
# Moderación
input_flagged: bool = False
output_flagged: bool = False
# Metadatos
duration_ms: int = 0
status: str = "success"
error: Optional[str] = None
def to_json(self) -> str:
return json.dumps(asdict(self), ensure_ascii=False)
Sistema de auditoría completo
El cliente que aprovecha esta estructura encadena la moderación de entrada, la llamada a la API, la moderación de salida y escribe en todos los casos. La palabra importante es solo anexar: el archivo JSONL se abre en modo anexar, nunca se reescribe, lo cual es la condición para que un registro tenga valor probatorio. Observa la ruta de una entrada marcada: el registro se guarda antes de lanzar la excepción, con el estado blocked_input. Un bloqueo deja por tanto una traza igual que un éxito, y el bloque except final garantiza que ningún error, sea cual sea su origen, pase desapercibido.
import time
from openai import OpenAI
class AuditedClient:
"""Cliente de OpenAI con pista de auditoría integrada."""
def __init__(self, application: str, audit_store: str = "audit.jsonl"):
self.client = OpenAI()
self.application = application
self.audit_store = audit_store
def _hash(self, text: str) -> str:
"""Hash SHA-256 truncado para auditoría."""
return hashlib.sha256(text.encode()).hexdigest()[:16]
def _save_audit(self, record: AuditRecord):
"""Guarda un registro de auditoría (solo anexar)."""
with open(self.audit_store, "a", encoding="utf-8") as f:
f.write(record.to_json() + "\n")
def create(self, user_id: str, session_id: str,
model: str, input: str, **kwargs) -> object:
"""Llamada a la API con auditoría automática."""
record = AuditRecord(
user_id_hash=self._hash(user_id),
session_id=session_id,
application=self.application,
model=model,
prompt_hash=self._hash(input),
prompt_length=len(input),
)
start = time.monotonic()
try:
# Moderación de entrada
mod = self.client.moderations.create(
model="omni-moderation-latest",
input=input
)
record.input_flagged = mod.results[0].flagged
if record.input_flagged:
record.status = "blocked_input"
self._save_audit(record)
raise ValueError("Contenido de entrada inapropiado")
# Llamada a la API
response = self.client.responses.create(
model=model,
input=input,
**kwargs
)
# Moderación de salida
mod_out = self.client.moderations.create(
model="omni-moderation-latest",
input=response.output_text
)
record.output_flagged = mod_out.results[0].flagged
# Rellenar métricas
record.response_id = response.id
record.output_length = len(response.output_text)
record.input_tokens = response.usage.input_tokens
record.output_tokens = response.usage.output_tokens
record.duration_ms = round((time.monotonic() - start) * 1000)
record.status = "success"
self._save_audit(record)
return response
except Exception as e:
record.duration_ms = round((time.monotonic() - start) * 1000)
record.status = "error"
record.error = type(e).__name__
self._save_audit(record)
raise
# Uso
audited = AuditedClient(application="support-chatbot")
response = audited.create(
user_id="[email protected]",
session_id="sess-abc123",
model="gpt-5.6-terra",
input="How do I return a product?"
)
print(response.output_text)
En este ejemplo, la dirección de correo electrónico pasada como user_id nunca llega al archivo: se convierte en hash tan pronto como se construye el registro. Un archivo JSONL funciona bien para empezar y para una única instancia; en cuanto varios procesos escriban en paralelo, dirige este flujo a una base de datos o a un recolector de registros.
Consultas de auditoría
Un registro que no puedes consultar solo sirve para ocupar espacio en disco. La lectura línea por línea del formato JSONL hace que la explotación sea trivial, y el informe siguiente resume el periodo cubierto, la distribución entre éxitos, errores y bloqueos, el consumo de tokens y la latencia media. El recuento de usuarios únicos se basa en hashes, lo que demuestra incidentalmente que un registro seudonimizado sigue siendo perfectamente analizable.
import json
def read_audit(file: str = "audit.jsonl") -> list[dict]:
"""Lee todos los registros de auditoría."""
records = []
try:
with open(file, "r", encoding="utf-8") as f:
for line in f:
if line.strip():
records.append(json.loads(line))
except FileNotFoundError:
pass
return records
def audit_report(file: str = "audit.jsonl") -> dict:
"""Genera un informe de auditoría."""
records = read_audit(file)
if not records:
return {"message": "No hay registros"}
total = len(records)
errors = sum(1 for r in records if r["status"] == "error")
blocked = sum(1 for r in records if r["status"] == "blocked_input")
tokens_total = sum(
r.get("input_tokens", 0) + r.get("output_tokens", 0)
for r in records
)
durations = [r["duration_ms"] for r in records if r["duration_ms"] > 0]
return {
"period": {
"start": records[0]["timestamp"],
"end": records[-1]["timestamp"],
},
"total_calls": total,
"successes": total - errors - blocked,
"errors": errors,
"moderation_blocks": blocked,
"tokens_consumed": tokens_total,
"avg_latency_ms": round(sum(durations) / max(len(durations), 1)),
"unique_users": len(set(r["user_id_hash"] for r in records)),
}
print(json.dumps(audit_report(), indent=2, ensure_ascii=False))
Retención y archivado
Mantener datos indefinidamente contradice el principio de limitación del plazo de conservación; borrarlos demasiado pronto te priva de la prueba que podrías necesitar. La rotación resuelve este dilema: más allá de una duración que tú estableces —noventa días aquí—, los registros salen del archivo activo para pasar a un archivado fechado, mientras que el registro actual se reescribe solo con los recientes. Programa esta función como una tarea periódica y alinea retention_days con la política validada por tu asesor legal, no con un valor elegido al azar.
from datetime import datetime, timedelta
import shutil
import os
def archive_audit(file: str = "audit.jsonl",
retention_days: int = 90):
"""Archiva y purga registros antiguos."""
records = read_audit(file)
limit = datetime.now() - timedelta(days=retention_days)
recent = []
archives = []
for record in records:
date_record = datetime.fromisoformat(record["timestamp"])
if date_record > limit:
recent.append(record)
else:
archives.append(record)
if archives:
# Archivar los antiguos
archive_name = f"audit_archive_{datetime.now().strftime('%Y%m%d')}.jsonl"
with open(archive_name, "w", encoding="utf-8") as f:
for record in archives:
f.write(json.dumps(record, ensure_ascii=False) + "\n")
# Reescribir el archivo principal con los recientes
with open(file, "w", encoding="utf-8") as f:
for record in recent:
f.write(json.dumps(record, ensure_ascii=False) + "\n")
print(f"Archivados {len(archives)} registros en {archive_name}")
print(f"Conservados {len(recent)} registros recientes")
Ley de IA europea: qué cambia
La Ley de IA europea (AI Act) impone obligaciones basadas en el nivel de riesgo de tu aplicación. La lógica es gradual: cuanto más pese tu sistema en la vida de las personas, más estrictos son los requisitos. Un chatbot de preguntas frecuentes, un resumen o una traducción caen bajo riesgo mínimo y solo exigen transparencia básica. En cuanto hay conversación o análisis de sentimientos, pasas a riesgo limitado, con la obligación de informar al usuario de que está interactuando con una IA. El salto es abrupto para alto riesgo —puntuación crediticia, contratación, diagnóstico médico—, donde se añaden la evaluación de conformidad, la gestión de riesgos, la documentación de los datos de entrenamiento, la trazabilidad completa, la supervisión humana y la demostración de la precisión. Ciertos usos, como la puntuación social o la manipulación subliminal, están puramente prohibidos.
# Evalúa el nivel de riesgo de tu aplicación
RISK_LEVELS = {
"minimal": {
"examples": ["chatbot de preguntas frecuentes", "resumen de texto", "traducción"],
"obligations": ["Transparencia básica"]
},
"limited": {
"examples": ["chatbot de atención al cliente", "análisis de sentimientos"],
"obligations": ["Informar al usuario de que interactúa con una IA"]
},
"high": {
"examples": ["puntuación crediticia", "contratación", "diagnóstico médico"],
"obligations": [
"Evaluación de conformidad",
"Sistema de gestión de riesgos",
"Datos de entrenamiento documentados",
"Registro y trazabilidad completa",
"Supervisión humana obligatoria",
"Precisión y robustez demostradas"
]
},
"unacceptable": {
"examples": ["puntuación social", "manipulación subliminal"],
"obligations": ["PROHIBIDO"]
}
}
Sitúa honestamente tu proyecto en esta cuadrícula antes de escribir la primera línea de código: una aplicación clasificada como de alto riesgo impone restricciones arquitectónicas —registro exhaustivo, punto de control humano— que no pueden injertarse a posteriori en un sistema diseñado sin ellas.
Lista de comprobación de cumplimiento
- Pista de auditoría de solo anexar con marca de tiempo
- Hash de datos personales en los registros (nunca en texto plano)
- Moderación sistemática de entradas y salidas
- Registro de actividades de tratamiento del RGPD actualizado
- Política de retención y archivado definida
- Evaluación del nivel de riesgo de la Ley de IA realizada
- Informar a los usuarios de que interactúan con una IA
- Supervisión humana para decisiones impactantes
Puntos clave
- Una pista de auditoría es obligatoria para el cumplimiento normativo
- Registra en modo solo anexar: nunca modifiques registros existentes
- Aplica hash a todos los datos personales en los registros de auditoría
- La Ley de IA europea clasifica las aplicaciones por nivel de riesgo
- Implementa moderación automática Y supervisión humana
- Define una política de retención y archiva regularmente
Pon a prueba tus conocimientos
Veintidós lecciones de API: valida los mecanismos que mantienen la producción en pie.
1. ¿Por qué migrar a la API de Responses en lugar de quedarse en Chat Completions?
Respuesta: Es la API moderna de OpenAI: gestión integrada del estado de la conversación, herramientas nativas y evolución centrada en ella; Chat Completions sigue siendo compatible pero es legado.
2. ¿Cómo eliges entre Sol, Terra y Luna en el lado de la API?
Respuesta: gpt-5.6-sol para tareas exigentes, terra para el equilibrio coste/calidad, luna para volumen económico; y el nivel de razonamiento (none→max) se ajusta luego por solicitud.
3. ¿Qué garantiza Structured Output?
Respuesta: Una salida conforme al esquema JSON proporcionado —campos, tipos, estructura—, explotable por un programa sin análisis defensivo ni reparación.
4. ¿Qué haces ante un error 429?
Respuesta: Respeta los límites de tasa: reintenta con retroceso exponencial (y jitter), limita los intentos y planifica un disyuntor; nunca un bucle de reintento inmediato.
5. Nombra dos protecciones indispensables en el lado de la seguridad de la aplicación.
Respuesta: Moderación del contenido entrante/saliente mediante la API dedicada, y defensa contra la inyección de prompts: aísla las instrucciones de los datos, valida las salidas, limita las capacidades expuestas.
Producción, seguridad, cumplimiento: los últimos tres bloques del curso marcan la diferencia entre un prototipo y un servicio; consérvalos como lista de comprobación.