Automaticé mi búsqueda semanal de efectos adversos con IA en AWS
🇺🇸 English version: AI Drug Side Effect Tracker – Automated Weekly Monitoring
La historia detrás del proyecto
Trabajo en farmacovigilancia, y una parte de mi trabajo es la búsqueda de literatura: revisar cada semana los artículos médicos nuevos para ver si alguno describe una reacción adversa a nuestros medicamentos.
Puede sonar a una tarea tranquila, pero tiene un reloj encima. En Estados Unidos, cuando una compañía se entera de una reacción adversa grave e inesperada, incluso si sale publicada en una revista médica, tiene como máximo 15 días calendario para reportarla a la FDA. Y ese plazo corre desde que la compañía recibe la información. Un artículo que se encuentra tarde es un caso que se reporta tarde.
Como Community Builder de AWS, quería aprender algo nuevo con un problema que conozco de verdad. Así que me hice una pregunta: ¿qué pasaría si la búsqueda semanal se hiciera sola, y yo solo tuviera que revisar los resultados?
Este laboratorio es mi respuesta. Lo armé para un solo medicamento, la crema de fluorouracilo tópico al 5%, y cada lunes:
- Busca en PubMed los artículos nuevos sobre reacciones en la piel.
- Le pide a una IA que clasifique cada uno según su gravedad y que copie la frase exacta del resumen que lo demuestra.
- Guarda un reporte en JSON y en CSV.
- Me manda un correo con el enlace de cada artículo para verificarlo.
En la primera prueba con artículos reales, la IA encontró un caso de necrosis en ambas orejas tras el uso prolongado de 5-FU tópico. Lo curioso es que ese caso yo ya lo había encontrado en mi búsqueda manual. Ver que el sistema llegaba al mismo resultado, solo, fue el momento en que pensé que esto valía la pena.
Una aclaración importante antes de seguir: esto es un prototipo para aprender. No decide si un caso se debe reportar, no establece causalidad y no reemplaza a nadie del equipo de seguridad. Lo que hace es ahorrar la parte repetitiva para que una persona pueda dedicarse a revisar.
En pocas palabras
Un laboratorio para principiantes, hecho todo desde la consola de AWS, sin instalar nada en la computadora. Usa AWS Lambda, Amazon Bedrock (con el modelo Nova Micro), Amazon S3, Amazon SNS y EventBridge Scheduler.
📂 El código está en GitHub: github.com/sinai07/efudex-ai-tracker
Cómo funciona
Cada lunes a las 8:00 AM, EventBridge Scheduler despierta a una función Lambda. La función busca en PubMed, le pasa cada resumen a Nova Micro, guarda los resultados en S3 y me envía el resumen por correo con SNS.
La IA tiene que elegir una de estas cinco etiquetas para cada artículo. Las dejé en inglés porque son los valores exactos que usa el código:
| Etiqueta | Qué significa |
|---|---|
⚪ not_relevant
|
No habla de reacciones en la piel por fluorouracilo tópico |
🟢 expected
|
Efectos locales habituales: enrojecimiento, costras, ardor |
🟡 notable
|
Algo más allá de lo habitual, como una dermatitis alérgica |
🔴 potentially_serious
|
Algo grave: ulceración, infección, hospitalización |
🔍 needs_review
|
No queda claro, o la IA no pudo citar el resumen |
Separar expected de potentially_serious fue importante para mí. Con Efudex, el enrojecimiento y las costras son justamente el efecto que se espera del tratamiento. Si el sistema marcara todo eso como alarma, el correo sería puro ruido.
Para mantenerlo simple, tomé algunas decisiones a propósito: solo se analizan los resúmenes (no el artículo completo), si una semana falla no se recupera, y el correo es de texto simple. Al final borré todo para no dejar nada corriendo.
Lo que necesitas: una cuenta de AWS (yo usé us-east-1), un correo y un navegador.
Paso 0: Preparar las herramientas
Antes de escribir una sola línea de código, preferí comprobar que cada servicio funcionaba por separado. Si algo fallaba después, quería saber exactamente dónde.
Necesitaba tres piezas: la IA que lee los artículos (Bedrock), un lugar privado para guardar los reportes (S3) y alguien que me mande el correo (SNS).
Probar Nova Micro
Lo primero fue hablar con el modelo directamente en el Playground de Bedrock. Antes había que activar cada modelo a mano, pero ahora Bedrock los habilita por defecto. Igual quise comprobarlo.
Elegí Nova Micro porque solo procesa texto y es de los más económicos, y para leer resúmenes no necesitaba más.
- Abre Amazon Bedrock en us-east-1 → Playgrounds → Chat.
- Select model → Amazon → Nova Micro → Apply.
- Le hice esta pregunta:
In one sentence, what is topical fluorouracil 5% cream used for?
Respondió bien, así que la cuenta podía usarlo.
Crear el bucket de S3
El bucket es básicamente una carpeta privada en la nube donde se guardan los reportes de cada semana.
- Amazon S3 → Create bucket.
- Nombre: el mío fue
efudex-tracker-reports-sr-2026. Tiene que ser único en todo AWS, así que agrégale algo tuyo. - Deja marcado Block all public access.
- Create bucket.
Configurar el correo con SNS
En SNS se crea un "tema", que funciona como un buzón: todo lo que el código publique ahí te llega por correo. Lo elegí en lugar de Amazon SES porque solo hay que confirmar tu correo, sin más configuración.
- Amazon SNS → Topics → Create topic.
- Tipo Standard (el tipo FIFO no envía correos). Nombre:
efudex-tracker-alerts. - Create subscription → Protocol: Email → tu correo.
- Confirma desde el correo que te llega y verifica que el estado diga Confirmed.
- Para probar, usé Publish message con el asunto
Testy el mensajeHello from the Efudex tracker.
Con el correo en mi bandeja, ya tenía las tres herramientas listas.
Paso 1: Buscar en PubMed
Aquí entra Lambda, que en este proyecto funciona como el "robot": un pedazo de código que vive en la nube y se ejecuta solo cuando se le pide. No hay servidor que mantener ni computadora que dejar prendida.
Decidí construirlo por partes. Primero el robot solo iba a buscar en PubMed, y nada más. La IA, los reportes y el correo vendrían después.
Crear la función
- AWS Lambda → Create function → Author from scratch.
- Nombre:
efudex-tracker. - Runtime: Python 3.14, la versión más nueva que me apareció.
- En permisos dejé la opción por defecto: Create a new role with basic Lambda permissions.
Ese rol por defecto solo deja que la función escriba sus registros. Los permisos para la IA, S3 y SNS se los fui dando uno por uno, solo cuando los necesitaba. Es lo que en seguridad se llama privilegio mínimo.
El código de búsqueda
PubMed tiene una API gratuita llamada E-utilities, que no pide clave. El código solo usa librerías que Python ya trae, así que bastó con pegarlo en el editor de Lambda.
Dos detalles que me parecen importantes:
- La búsqueda es amplia a propósito. Trae artículos que no son exactamente de Efudex al 5%. Prefiero que traiga de más y que la IA descarte, a que se me escape un caso.
- Busca por la fecha en que el artículo entró a PubMed (la "fecha Entrez"), no por la fecha de publicación, que muchas veces es de meses antes. Para un monitoreo semanal, "nuevo" significa "nuevo en PubMed".
Reemplacé el código de ejemplo de lambda_function.py por este y presioné Deploy:
import json
import urllib.parse
import urllib.request
import xml.etree.ElementTree as ET
# PubMed E-utilities base URL (free NCBI API, no key required)
EUTILS = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
# Search: fluorouracil/Efudex + topical/cream + skin-related terms, in title or abstract
QUERY = (
'("fluorouracil"[tiab] OR "5-fluorouracil"[tiab] OR "5-FU"[tiab] OR "Efudex"[tiab]) '
'AND (topical[tiab] OR cream[tiab]) '
'AND (skin[tiab] OR cutaneous[tiab] OR dermatitis[tiab] OR reaction*[tiab] OR adverse[tiab])'
)
def get(url):
"""Download a URL and return its text."""
req = urllib.request.Request(url, headers={"User-Agent": "efudex-tracker-lab"})
with urllib.request.urlopen(req, timeout=30) as resp:
return resp.read().decode("utf-8")
def search_pubmed(days):
"""Return the PMIDs of articles added to PubMed in the last `days` days."""
params = urllib.parse.urlencode({
"db": "pubmed",
"term": QUERY,
"datetype": "edat", # Entrez date: when the article entered PubMed
"reldate": days,
"retmax": 100,
"retmode": "json",
})
data = json.loads(get(f"{EUTILS}/esearch.fcgi?{params}"))
return data["esearchresult"]["idlist"]
def fetch_articles(pmids):
"""Download the title and abstract of each PMID."""
if not pmids:
return []
params = urllib.parse.urlencode({
"db": "pubmed",
"id": ",".join(pmids),
"retmode": "xml",
})
root = ET.fromstring(get(f"{EUTILS}/efetch.fcgi?{params}"))
articles = []
for item in root.findall(".//PubmedArticle"):
pmid = item.findtext(".//PMID")
title = "".join(item.find(".//ArticleTitle").itertext()) if item.find(".//ArticleTitle") is not None else ""
abstract = " ".join("".join(p.itertext()) for p in item.findall(".//AbstractText"))
articles.append({
"pmid": pmid,
"title": title.strip(),
"abstract": abstract.strip(),
"url": f"https://pubmed.ncbi.nlm.nih.gov/{pmid}/",
})
return articles
def lambda_handler(event, context):
days = int(event.get("days", 7)) # default: last 7 days
pmids = search_pubmed(days)
articles = fetch_articles(pmids)
summary = {
"days_searched": days,
"articles_found": len(articles),
"articles_without_abstract": sum(1 for a in articles if not a["abstract"]),
"articles": [
{"pmid": a["pmid"], "title": a["title"], "url": a["url"],
"abstract_length": len(a["abstract"])}
for a in articles
],
}
print(json.dumps(summary, indent=2))
return summary
La primera prueba
Antes de probar hay que cambiar algo: Lambda, por defecto, detiene la función a los 3 segundos. Lo subí a 5 minutos en Configuration → General configuration → Edit.
Me preocupaba que eso subiera el costo, pero no: es solo un límite de seguridad. Lambda cobra el tiempo que la función realmente trabaja.
En la pestaña Test creé un evento llamado search-90-days:
{"days": 90}
Normalmente el robot busca los últimos 7 días, pero en una semana puede no haber nada. Con 90 días me aseguraba de ver resultados reales sin que fueran demasiados.
| Resultado | |
|---|---|
| Artículos encontrados (90 días) | 8 |
| Artículos sin resumen | 0 |
| Tiempo | menos de 1 segundo |
El primer resultado fue un caso de fibroxantoma atípico, que no parecía tener nada que ver con una reacción a Efudex. Justo para eso estaba el siguiente paso.
Paso 2: Que la IA lea los artículos
Al empezar este paso me di cuenta de algo que me confundió al principio. Yo pensaba que todo se iba a hacer desde el chat de Nova, donde hicimos la prueba del Paso 0. Pero no: el Playground sirvió solo para comprobar que el modelo funcionaba. El trabajo de verdad lo hace el código, que le habla a la IA a través de una API, artículo por artículo, sin que yo esté presente.
Creo que esa es la diferencia más importante entre "usar IA" y "construir con IA":
| Playground (Paso 0) | Lambda + API (Paso 2) | |
|---|---|---|
| Quién le habla a la IA | Yo, escribiendo | El código |
| Cuántas preguntas | Una | Cada artículo nuevo, cada semana |
| Para qué | Probar | Hacer el trabajo |
Darle permiso para usar la IA
En AWS nada puede usar otro servicio sin permiso. Así que al rol de la función le agregué una política que le permite usar Nova Micro, y solo Nova Micro.
- En la función: Configuration → Permissions → clic en el nombre del rol (se abre IAM).
- Add permissions → Create inline policy → JSON:
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "InvokeNovaMicroOnly",
"Effect": "Allow",
"Action": "bedrock:InvokeModel",
"Resource": "arn:aws:bedrock:us-east-1::foundation-model/amazon.nova-micro-v1:0"
}
]
}
- Nombre:
allow-nova-micro→ Create policy.
Habría sido más rápido usar la política AmazonBedrockFullAccess, pero esa da acceso a todos los modelos de Bedrock, incluidos los más caros. El robot solo necesitaba uno.
Usé una política inline (que vive dentro del rol) porque este permiso es solo para esta función y se borra junto con el rol al final. En proyectos grandes se suelen usar políticas reutilizables, pero para un laboratorio esta es la opción más limpia.
El código de la IA
Esta versión del código mantiene la búsqueda del Paso 1 y le agrega la parte de la IA. A cada artículo le manda el título y el resumen a Nova Micro junto con unas instrucciones que explican qué significa cada etiqueta, y recibe una etiqueta, la reacción, una cita del resumen y una explicación.
La parte que más me importaba: el código no le cree a la IA sin comprobar. Si la IA dice que hay una reacción, la cita que da tiene que aparecer palabra por palabra en el resumen. Si no aparece, el artículo pasa a needs_review para que lo revise una persona. Los modelos a veces inventan, y en este tema eso no se puede permitir.
También usé temperature: 0, que hace que la IA responda de la forma más consistente posible.
Lo nuevo en este paso (las instrucciones para la IA están en inglés porque los resúmenes también lo están):
import re
import boto3
MODEL_ID = "amazon.nova-micro-v1:0"
LABELS = ["not_relevant", "expected", "notable", "potentially_serious", "needs_review"]
bedrock = boto3.client("bedrock-runtime", region_name="us-east-1")
# ---------- Instructions for the AI ----------
SYSTEM_PROMPT = """You screen PubMed abstracts for skin reactions to TOPICAL fluorouracil (5-FU), especially 5% cream (Efudex).
Choose exactly one label:
- not_relevant: not about topical fluorouracil, or no skin reaction to it is reported (e.g., systemic/IV 5-FU, other drugs, efficacy only).
- expected: usual local effects within the treated area (redness, crusting, burning, itching, erosion).
- notable: beyond the usual effect (e.g., allergic contact dermatitis, spread beyond the treated area, pigment changes).
- potentially_serious: severe outcomes (e.g., ulceration, necrosis, secondary infection, hospitalization, SJS/TEN, systemic toxicity).
- needs_review: the formulation or route is unclear, or the abstract does not give enough information to decide.
Rules:
- Use only the abstract. Do not use outside knowledge about the patient.
- evidence_quote must be copied WORD FOR WORD from the abstract (one sentence or less). Use "" if the label is not_relevant.
- Answer with JSON only, no other text:
{"label": "...", "formulation": "...", "reaction": "...", "evidence_quote": "...", "reason": "..."}"""
# ---------- AI classification (Step 2) ----------
def normalize(text):
"""Lowercase and collapse spaces, so small formatting differences don't matter."""
return re.sub(r"\s+", " ", text).strip().lower()
def parse_json(text):
"""Extract the JSON object from the model's answer."""
match = re.search(r"\{.*\}", text, re.DOTALL)
return json.loads(match.group(0))
def classify(article):
if not article["abstract"]:
return {"label": "needs_review", "formulation": "", "reaction": "",
"evidence_quote": "", "reason": "No abstract available."}
response = bedrock.converse(
modelId=MODEL_ID,
system=[{"text": SYSTEM_PROMPT}],
messages=[{"role": "user", "content": [{"text":
f"Title: {article['title']}\n\nAbstract: {article['abstract']}"}]}],
inferenceConfig={"maxTokens": 400, "temperature": 0},
)
answer = response["output"]["message"]["content"][0]["text"]
result = parse_json(answer)
# Safety checks: the code does not blindly trust the AI.
if result.get("label") not in LABELS:
result["reason"] = f"Invalid label from model: {result.get('label')}"
result["label"] = "needs_review"
quote = result.get("evidence_quote", "")
if result["label"] in ("expected", "notable", "potentially_serious"):
if not quote or normalize(quote) not in normalize(article["abstract"]):
result["reason"] = "Evidence quote not found in the abstract. " + result.get("reason", "")
result["label"] = "needs_review"
return result
En Lambda reemplacé todo el código por la versión completa y presioné Deploy:
📄 Código completo del Paso 2
import json
import re
import urllib.parse
import urllib.request
import xml.etree.ElementTree as ET
import boto3
# ---------- Settings ----------
EUTILS = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
MODEL_ID = "amazon.nova-micro-v1:0"
LABELS = ["not_relevant", "expected", "notable", "potentially_serious", "needs_review"]
QUERY = (
'("fluorouracil"[tiab] OR "5-fluorouracil"[tiab] OR "5-FU"[tiab] OR "Efudex"[tiab]) '
'AND (topical[tiab] OR cream[tiab]) '
'AND (skin[tiab] OR cutaneous[tiab] OR dermatitis[tiab] OR reaction*[tiab] OR adverse[tiab])'
)
bedrock = boto3.client("bedrock-runtime", region_name="us-east-1")
# ---------- Instructions for the AI ----------
SYSTEM_PROMPT = """You screen PubMed abstracts for skin reactions to TOPICAL fluorouracil (5-FU), especially 5% cream (Efudex).
Choose exactly one label:
- not_relevant: not about topical fluorouracil, or no skin reaction to it is reported (e.g., systemic/IV 5-FU, other drugs, efficacy only).
- expected: usual local effects within the treated area (redness, crusting, burning, itching, erosion).
- notable: beyond the usual effect (e.g., allergic contact dermatitis, spread beyond the treated area, pigment changes).
- potentially_serious: severe outcomes (e.g., ulceration, necrosis, secondary infection, hospitalization, SJS/TEN, systemic toxicity).
- needs_review: the formulation or route is unclear, or the abstract does not give enough information to decide.
Rules:
- Use only the abstract. Do not use outside knowledge about the patient.
- evidence_quote must be copied WORD FOR WORD from the abstract (one sentence or less). Use "" if the label is not_relevant.
- Answer with JSON only, no other text:
{"label": "...", "formulation": "...", "reaction": "...", "evidence_quote": "...", "reason": "..."}"""
# ---------- PubMed (Step 1) ----------
def get(url):
req = urllib.request.Request(url, headers={"User-Agent": "efudex-tracker-lab"})
with urllib.request.urlopen(req, timeout=30) as resp:
return resp.read().decode("utf-8")
def search_pubmed(days):
params = urllib.parse.urlencode({
"db": "pubmed", "term": QUERY, "datetype": "edat",
"reldate": days, "retmax": 100, "retmode": "json",
})
data = json.loads(get(f"{EUTILS}/esearch.fcgi?{params}"))
return data["esearchresult"]["idlist"]
def fetch_articles(pmids):
if not pmids:
return []
params = urllib.parse.urlencode({"db": "pubmed", "id": ",".join(pmids), "retmode": "xml"})
root = ET.fromstring(get(f"{EUTILS}/efetch.fcgi?{params}"))
articles = []
for item in root.findall(".//PubmedArticle"):
pmid = item.findtext(".//PMID")
title_el = item.find(".//ArticleTitle")
title = "".join(title_el.itertext()) if title_el is not None else ""
abstract = " ".join("".join(p.itertext()) for p in item.findall(".//AbstractText"))
articles.append({
"pmid": pmid,
"title": title.strip(),
"abstract": abstract.strip(),
"url": f"https://pubmed.ncbi.nlm.nih.gov/{pmid}/",
})
return articles
# ---------- AI classification (Step 2) ----------
def normalize(text):
"""Lowercase and collapse spaces, so small formatting differences don't matter."""
return re.sub(r"\s+", " ", text).strip().lower()
def parse_json(text):
"""Extract the JSON object from the model's answer."""
match = re.search(r"\{.*\}", text, re.DOTALL)
return json.loads(match.group(0))
def classify(article):
if not article["abstract"]:
return {"label": "needs_review", "formulation": "", "reaction": "",
"evidence_quote": "", "reason": "No abstract available."}
response = bedrock.converse(
modelId=MODEL_ID,
system=[{"text": SYSTEM_PROMPT}],
messages=[{"role": "user", "content": [{"text":
f"Title: {article['title']}\n\nAbstract: {article['abstract']}"}]}],
inferenceConfig={"maxTokens": 400, "temperature": 0},
)
answer = response["output"]["message"]["content"][0]["text"]
result = parse_json(answer)
# Safety checks: the code does not blindly trust the AI.
if result.get("label") not in LABELS:
result["reason"] = f"Invalid label from model: {result.get('label')}"
result["label"] = "needs_review"
quote = result.get("evidence_quote", "")
if result["label"] in ("expected", "notable", "potentially_serious"):
if not quote or normalize(quote) not in normalize(article["abstract"]):
result["reason"] = "Evidence quote not found in the abstract. " + result.get("reason", "")
result["label"] = "needs_review"
return result
# ---------- Main ----------
def lambda_handler(event, context):
days = int(event.get("days", 7))
articles = fetch_articles(search_pubmed(days))
results = []
for article in articles:
try:
analysis = classify(article)
except Exception as error: # one bad article must not stop the whole run
analysis = {"label": "needs_review", "formulation": "", "reaction": "",
"evidence_quote": "", "reason": f"Analysis error: {error}"}
results.append({
"pmid": article["pmid"],
"title": article["title"],
"url": article["url"],
**analysis,
})
summary = {
"days_searched": days,
"articles_found": len(results),
"counts": {label: sum(1 for r in results if r["label"] == label) for label in LABELS},
"results": results,
}
print(json.dumps(summary, indent=2))
return summary
El momento de la verdad
Volví a ejecutar la prueba de 90 días, ahora con la IA leyendo cada artículo.
| Etiqueta | Artículos |
|---|---|
⚪ not_relevant
|
6 |
🟢 expected
|
1 |
🟡 notable
|
0 |
🔴 potentially_serious
|
1 |
🔍 needs_review
|
0 |
La IA tardó unos 5 segundos en leer los 8 artículos.
Y ahí estaba: Bilateral Auricular Necrosis After Prolonged Self-Application of Topical 5-Fluorouracil, clasificado como potentially_serious, con la cita "resulting in substantial necrosis". El código confirmó que esa frase sí estaba en el resumen.
Me pareció sospechoso que 6 de 8 artículos fueran not_relevant, así que los revisé a mano uno por uno:
| Artículo | La IA dijo | Mi revisión |
|---|---|---|
| Fibroxantoma atípico | ⚪ not_relevant | ✅ Menciona 5-FU, pero no reporta una reacción |
| Pretratamientos para terapia fotodinámica | ⚪ not_relevant | ✅ Usa 5-FU como herramienta |
| Gel con baicalina | ⚪ not_relevant | ✅ Es sobre otro medicamento |
| Terapias no quirúrgicas en adultos mayores | ⚪ not_relevant | ✅ Revisión general, sin un caso |
| Hidrogel para cicatrices | ⚪ not_relevant | ✅ Otra formulación, estudio de laboratorio |
| Crema de 5-FU al 4% en un paciente con VIH | 🟢 expected | ⚠️ La reacción está bien clasificada, pero es al 4%, no al 5% |
| Carcinoma de conjuntiva | ⚪ not_relevant | ✅ Uso en el ojo, no en la piel |
| Necrosis en ambas orejas | 🔴 potentially_serious | ✅ Correcto |
La IA acertó en todos. Pero el caso del 4% me enseñó algo: en las instrucciones yo había escrito que se enfocara "especially" en la crema al 5%, y "especialmente" no es una regla. La IA hizo lo que le pedí, no lo que yo quería decir. Decidí no corregirlo para este laboratorio, porque el campo formulation muestra la concentración y se detecta fácil al revisar. En una versión real lo ajustaría para que cualquier concentración distinta al 5% vaya a revisión.
Paso 3: Guardar los reportes
Hasta aquí, los resultados solo aparecían en la pantalla de prueba y desaparecían al cerrarla. Quería que cada ejecución dejara un reporte guardado: un JSON, por si algún día lo conecto con otra herramienta, y un CSV para abrirlo en Excel.
El permiso para escribir en S3
Otra política inline, pero esta vez el robot solo puede escribir archivos, y solo dentro de la carpeta reports/. No puede leer ni borrar nada, así que un error nunca podría borrar reportes viejos.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "WriteReportsOnly",
"Effect": "Allow",
"Action": "s3:PutObject",
"Resource": "arn:aws:s3:::efudex-tracker-reports-sr-2026/reports/*"
}
]
}
Nombre: allow-s3-write-reports.
El código de los reportes
Cada reporte se guarda en una carpeta con la fecha, como reports/2026-11-07/report.csv, y los artículos quedan ordenados del más grave al menos grave. Al abrir el CSV, lo importante está arriba.
Lo nuevo en este paso:
import csv
import io
from datetime import datetime, timezone
BUCKET = "efudex-tracker-reports-sr-2026" # change to your bucket name
SEVERITY_ORDER = ["potentially_serious", "notable", "needs_review", "expected", "not_relevant"]
s3 = boto3.client("s3")
# ---------- Reports in S3 (Step 3) ----------
def save_reports(summary):
"""Save the results as JSON and CSV in s3://BUCKET/reports/YYYY-MM-DD/."""
folder = f"reports/{summary['run_date']}"
json_key = f"{folder}/report.json"
s3.put_object(
Bucket=BUCKET, Key=json_key,
Body=json.dumps(summary, indent=2, ensure_ascii=False).encode("utf-8"),
ContentType="application/json",
)
columns = ["label", "pmid", "title", "formulation", "reaction",
"evidence_quote", "reason", "url"]
buffer = io.StringIO()
writer = csv.DictWriter(buffer, fieldnames=columns, extrasaction="ignore")
writer.writeheader()
writer.writerows(summary["results"])
csv_key = f"{folder}/report.csv"
s3.put_object(
Bucket=BUCKET, Key=csv_key,
Body=buffer.getvalue().encode("utf-8-sig"), # utf-8-sig so Excel shows special characters correctly
ContentType="text/csv",
)
return [json_key, csv_key]
# In lambda_handler: sort by severity, then save the reports
results.sort(key=lambda r: SEVERITY_ORDER.index(r["label"]))
summary["report_files"] = save_reports(summary)
📄 Código completo del Paso 3
import csv
import io
import json
import re
import urllib.parse
import urllib.request
import xml.etree.ElementTree as ET
from datetime import datetime, timezone
import boto3
# ---------- Settings ----------
EUTILS = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
MODEL_ID = "amazon.nova-micro-v1:0"
LABELS = ["not_relevant", "expected", "notable", "potentially_serious", "needs_review"]
BUCKET = "efudex-tracker-reports-sr-2026" # change to your bucket name
# Order used in reports: most important first
SEVERITY_ORDER = ["potentially_serious", "notable", "needs_review", "expected", "not_relevant"]
QUERY = (
'("fluorouracil"[tiab] OR "5-fluorouracil"[tiab] OR "5-FU"[tiab] OR "Efudex"[tiab]) '
'AND (topical[tiab] OR cream[tiab]) '
'AND (skin[tiab] OR cutaneous[tiab] OR dermatitis[tiab] OR reaction*[tiab] OR adverse[tiab])'
)
bedrock = boto3.client("bedrock-runtime", region_name="us-east-1")
s3 = boto3.client("s3")
# ---------- Instructions for the AI ----------
SYSTEM_PROMPT = """You screen PubMed abstracts for skin reactions to TOPICAL fluorouracil (5-FU), especially 5% cream (Efudex).
Choose exactly one label:
- not_relevant: not about topical fluorouracil, or no skin reaction to it is reported (e.g., systemic/IV 5-FU, other drugs, efficacy only).
- expected: usual local effects within the treated area (redness, crusting, burning, itching, erosion).
- notable: beyond the usual effect (e.g., allergic contact dermatitis, spread beyond the treated area, pigment changes).
- potentially_serious: severe outcomes (e.g., ulceration, necrosis, secondary infection, hospitalization, SJS/TEN, systemic toxicity).
- needs_review: the formulation or route is unclear, or the abstract does not give enough information to decide.
Rules:
- Use only the abstract. Do not use outside knowledge about the patient.
- evidence_quote must be copied WORD FOR WORD from the abstract (one sentence or less). Use "" if the label is not_relevant.
- Answer with JSON only, no other text:
{"label": "...", "formulation": "...", "reaction": "...", "evidence_quote": "...", "reason": "..."}"""
# ---------- PubMed (Step 1) ----------
def get(url):
req = urllib.request.Request(url, headers={"User-Agent": "efudex-tracker-lab"})
with urllib.request.urlopen(req, timeout=30) as resp:
return resp.read().decode("utf-8")
def search_pubmed(days):
params = urllib.parse.urlencode({
"db": "pubmed", "term": QUERY, "datetype": "edat",
"reldate": days, "retmax": 100, "retmode": "json",
})
data = json.loads(get(f"{EUTILS}/esearch.fcgi?{params}"))
return data["esearchresult"]["idlist"]
def fetch_articles(pmids):
if not pmids:
return []
params = urllib.parse.urlencode({"db": "pubmed", "id": ",".join(pmids), "retmode": "xml"})
root = ET.fromstring(get(f"{EUTILS}/efetch.fcgi?{params}"))
articles = []
for item in root.findall(".//PubmedArticle"):
pmid = item.findtext(".//PMID")
title_el = item.find(".//ArticleTitle")
title = "".join(title_el.itertext()) if title_el is not None else ""
abstract = " ".join("".join(p.itertext()) for p in item.findall(".//AbstractText"))
articles.append({
"pmid": pmid,
"title": title.strip(),
"abstract": abstract.strip(),
"url": f"https://pubmed.ncbi.nlm.nih.gov/{pmid}/",
})
return articles
# ---------- AI classification (Step 2) ----------
def normalize(text):
"""Lowercase and collapse spaces, so small formatting differences don't matter."""
return re.sub(r"\s+", " ", text).strip().lower()
def parse_json(text):
"""Extract the JSON object from the model's answer."""
match = re.search(r"\{.*\}", text, re.DOTALL)
return json.loads(match.group(0))
def classify(article):
if not article["abstract"]:
return {"label": "needs_review", "formulation": "", "reaction": "",
"evidence_quote": "", "reason": "No abstract available."}
response = bedrock.converse(
modelId=MODEL_ID,
system=[{"text": SYSTEM_PROMPT}],
messages=[{"role": "user", "content": [{"text":
f"Title: {article['title']}\n\nAbstract: {article['abstract']}"}]}],
inferenceConfig={"maxTokens": 400, "temperature": 0},
)
answer = response["output"]["message"]["content"][0]["text"]
result = parse_json(answer)
# Safety checks: the code does not blindly trust the AI.
if result.get("label") not in LABELS:
result["reason"] = f"Invalid label from model: {result.get('label')}"
result["label"] = "needs_review"
quote = result.get("evidence_quote", "")
if result["label"] in ("expected", "notable", "potentially_serious"):
if not quote or normalize(quote) not in normalize(article["abstract"]):
result["reason"] = "Evidence quote not found in the abstract. " + result.get("reason", "")
result["label"] = "needs_review"
return result
# ---------- Reports in S3 (Step 3) ----------
def save_reports(summary):
"""Save the results as JSON and CSV in s3://BUCKET/reports/YYYY-MM-DD/."""
folder = f"reports/{summary['run_date']}"
json_key = f"{folder}/report.json"
s3.put_object(
Bucket=BUCKET, Key=json_key,
Body=json.dumps(summary, indent=2, ensure_ascii=False).encode("utf-8"),
ContentType="application/json",
)
columns = ["label", "pmid", "title", "formulation", "reaction",
"evidence_quote", "reason", "url"]
buffer = io.StringIO()
writer = csv.DictWriter(buffer, fieldnames=columns, extrasaction="ignore")
writer.writeheader()
writer.writerows(summary["results"])
csv_key = f"{folder}/report.csv"
s3.put_object(
Bucket=BUCKET, Key=csv_key,
Body=buffer.getvalue().encode("utf-8-sig"), # utf-8-sig so Excel shows special characters correctly
ContentType="text/csv",
)
return [json_key, csv_key]
# ---------- Main ----------
def lambda_handler(event, context):
days = int(event.get("days", 7))
articles = fetch_articles(search_pubmed(days))
results = []
for article in articles:
try:
analysis = classify(article)
except Exception as error: # one bad article must not stop the whole run
analysis = {"label": "needs_review", "formulation": "", "reaction": "",
"evidence_quote": "", "reason": f"Analysis error: {error}"}
results.append({
"pmid": article["pmid"],
"title": article["title"],
"url": article["url"],
**analysis,
})
# Most important articles first
results.sort(key=lambda r: SEVERITY_ORDER.index(r["label"]))
summary = {
"run_date": datetime.now(timezone.utc).strftime("%Y-%m-%d"),
"days_searched": days,
"articles_found": len(results),
"counts": {label: sum(1 for r in results if r["label"] == label) for label in LABELS},
"results": results,
}
summary["report_files"] = save_reports(summary)
print(json.dumps(summary, indent=2))
return summary
Probarlo
Al ejecutar la prueba, la respuesta ahora terminaba con los nombres de los archivos guardados:
Y en S3 estaban los dos:
Descargué el CSV y lo abrí en Excel. El caso de necrosis quedó en la primera fila, con su cita y el enlace a PubMed:
Paso 4: Recibir el resumen por correo
Esta era la parte que más quería. La idea nunca fue tener que entrar a AWS a buscar resultados, sino recibirlos y verificarlos.
El permiso para SNS
Una política más, para publicar solo en mi tema efudex-tracker-alerts:
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "PublishWeeklySummary",
"Effect": "Allow",
"Action": "sns:Publish",
"Resource": "arn:aws:sns:us-east-1:<YOUR_ACCOUNT_ID>:efudex-tracker-alerts"
}
]
}
Nombre: allow-sns-publish.
Al final, el rol quedó con cuatro políticas, cada una permitiendo una sola cosa:
| Política | Permite |
|---|---|
| AWSLambdaBasicExecutionRole | Escribir registros |
allow-nova-micro |
Usar solo Nova Micro |
allow-s3-write-reports |
Escribir solo en reports/
|
allow-sns-publish |
Publicar solo en un tema |
Cómo quería que fuera el correo
Tomé tres decisiones pensando en cómo lo usaría yo:
- Todos los artículos llevan su enlace a PubMed, incluso los que la IA descartó. Si quiero comprobar que no se le escapó nada, solo tengo que hacer clic.
- El asunto resume lo importante, por ejemplo: "Efudex Tracker: 1 potentially serious, 0 notable (8 articles)". Sin abrirlo ya sé si hay algo urgente.
- Si una semana no hay artículos, igual llega un correo. Si no llegara nada, no sabría si fue porque no hubo artículos o porque el robot falló.
Lo nuevo en este paso:
TOPIC_ARN = "arn:aws:sns:us-east-1:<YOUR_ACCOUNT_ID>:efudex-tracker-alerts" # change to your topic ARN
sns = boto3.client("sns", region_name="us-east-1")
# ---------- Email with SNS (Step 4) ----------
SECTION_TITLES = {
"potentially_serious": "🔴 POTENTIALLY SERIOUS",
"notable": "🟡 NOTABLE",
"needs_review": "🔍 NEEDS REVIEW",
"expected": "🟢 EXPECTED",
"not_relevant": "⚪ NOT RELEVANT",
}
def send_email(summary):
"""Send a plain-text summary with a link to every article."""
counts = summary["counts"]
lines = [
"AI Drug Side Effect Tracker – Weekly Report",
f"Run date: {summary['run_date']} | Period: last {summary['days_searched']} days",
f"Articles found: {summary['articles_found']}",
"",
]
if summary["articles_found"] == 0:
lines += ["No new articles matched the search this period.", ""]
for label in SEVERITY_ORDER if summary["articles_found"] else []:
group = [r for r in summary["results"] if r["label"] == label]
lines.append(f"{SECTION_TITLES[label]} ({len(group)})")
for r in group:
lines.append(f"- {r['title']}")
if label != "not_relevant":
lines.append(f" Reaction: {r.get('reaction', '')}")
lines.append(f" Formulation: {r.get('formulation', '')}")
if r.get("evidence_quote"):
lines.append(f' Evidence: "{r["evidence_quote"]}"')
if label == "needs_review":
lines.append(f" Reason: {r.get('reason', '')}")
lines.append(f" Link: {r['url']}")
lines.append("")
lines += [
f"Reports saved in S3: s3://{BUCKET}/reports/{summary['run_date']}/",
"",
"This is an educational prototype. Every result must be verified by a person.",
]
subject = (f"Efudex Tracker: {counts['potentially_serious']} potentially serious, "
f"{counts['notable']} notable ({summary['articles_found']} articles)")
sns.publish(TopicArn=TOPIC_ARN, Subject=subject[:100], Message="\n".join(lines))
# In lambda_handler, after saving the reports
send_email(summary)
La versión final completa está al final del artículo y en GitHub.
El primer correo
Ejecuté la prueba y a los pocos segundos tenía el correo en mi bandeja:
Hice clic en el enlace del caso de necrosis, busqué la cita con Ctrl + F en el resumen de PubMed, y ahí estaba.
Un detalle que noté: las etiquetas salieron idénticas a la prueba anterior, pero la formulación del caso de necrosis cambió de "topical 5-FU" a solo "topical". Aunque la temperatura esté en 0, la forma de redactar de la IA puede variar un poco. Por eso las decisiones dependen de las etiquetas fijas, y el texto libre es solo contexto.
Paso 5: Que trabaje solo cada lunes
Hasta aquí, el robot solo trabajaba cuando yo presionaba Test. Para que lo hiciera solo usé EventBridge Scheduler.
Al principio no entendía la diferencia entre EventBridge y EventBridge Scheduler, porque están en la misma consola. La forma en que lo entendí: EventBridge es como un timbre, reacciona cuando pasa algo; Scheduler es como un despertador, actúa a una hora. Además, Scheduler permite elegir la zona horaria, así que las 8:00 AM siguen siendo las 8:00 AM después del cambio de horario. Y es prácticamente gratis: incluye 14 millones de ejecuciones al mes, y este robot usa 4 o 5.
El horario semanal
- Amazon EventBridge → Scheduler → Schedules → Create schedule.
- Nombre:
efudex-tracker-weekly. - Recurring schedule → Cron-based schedule:
| Minutes | Hours | Day of month | Month | Day of the week | Year |
|---|---|---|---|---|---|
0 |
8 |
? |
* |
MON |
* |
- Zona horaria: America/New_York. Flexible time window: Off.
- Destino: la función
efudex-tracker, con este mensaje:
{"days": 7}
- Dejé que AWS creara un rol nuevo para el horario, que solo puede despertar a la función.
Probarlo sin esperar al lunes
No quería esperar al lunes para saber si funcionaba, así que creé un segundo horario, efudex-tracker-test-once, para que se ejecutara una sola vez ese mismo día a las 12:00 PM, reutilizando el rol del horario semanal.
A las 12:00 en punto me llegó el correo, sin que yo tocara nada:
Esa vez no había artículos nuevos en los últimos 7 días, y el correo lo decía claramente. Justo para eso había decidido que llegara un correo aunque no hubiera resultados.
En la pestaña Monitor de Lambda se veía la ejecución:
El gráfico me confundió un momento, porque el punto aparecía a las 17:00. Es que está en hora UTC, y las 17:00 UTC eran las 12:00 en Nueva York. Los puntos anteriores son mis pruebas manuales.
Paso 6: Limpiar todo
Al terminar borré todo en este orden: primero lo que despierta al robot y al final lo que guarda datos, para que nada se ejecutara a mitad de la limpieza.
| # | Servicio | Qué borré |
|---|---|---|
| 1 | EventBridge Scheduler | Los dos horarios |
| 2 | Lambda | La función efudex-tracker
|
| 3 | CloudWatch Logs | El grupo /aws/lambda/efudex-tracker, que no se borra solo |
| 4 | IAM | Los dos roles y la política AWSLambdaBasicExecutionRole-..., que tampoco se borra con el rol |
| 5 | S3 | Vacié el bucket y luego lo borré |
| 6 | SNS | El tema y la suscripción |
Bedrock no necesita limpieza: Nova Micro se cobra solo cuando se usa.
Lo que aprendí
Sobre AWS: se puede construir algo útil sin instalar nada, solo desde la consola. Y dar los permisos de uno en uno, solo cuando se necesitan, resultó más fácil de lo que pensaba.
Sobre la IA: hace lo que le pides, no lo que quisiste decir. El caso del 4% me lo dejó muy claro. Y conviene no confiar en ella sin comprobar: exigirle una cita textual fue la decisión que más tranquilidad me dio.
Sobre mi trabajo: que el sistema encontrara solo el mismo caso que yo había encontrado a mano me hizo ver el potencial. Pero también sus límites. La versión del caso que yo encontré tenía imágenes clínicas, y este sistema solo lee el resumen de PubMed.
Lo que mejoraría en una versión real:
| Limitación | Cómo la resolvería |
|---|---|
| Incluye otras concentraciones, como el 4% | Mandar a revisión todo lo que no sea 5% |
| Dos ejecuciones el mismo día se sobrescriben (me pasó con la prueba de las 12:00) | Agregar la hora al nombre de la carpeta y guardar un mes de historial con una regla de S3 |
| Solo lee resúmenes | Revisar el texto completo, donde está el contexto (y las imágenes) |
| Solo busca en PubMed | Agregar fuentes como Embase, revisando antes sus licencias y si permiten el uso con IA |
| Si una semana falla, no se recupera | Guardar la fecha de la última ejecución exitosa y buscar desde ahí |
Este proyecto no reemplaza la revisión humana, y no está pensado para eso. Lo que hace es encargarse de buscar y ordenar, para que la persona que revisa pueda concentrarse en lo importante.
El código completo
📂 github.com/sinai07/efudex-ai-tracker, con el código, las políticas de IAM y los eventos de prueba.
Este es el lambda_function.py final. Para usarlo, reemplaza BUCKET y <YOUR_ACCOUNT_ID> con tus datos.
import csv
import io
import json
import re
import urllib.parse
import urllib.request
import xml.etree.ElementTree as ET
from datetime import datetime, timezone
import boto3
# ---------- Settings ----------
EUTILS = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
MODEL_ID = "amazon.nova-micro-v1:0"
LABELS = ["not_relevant", "expected", "notable", "potentially_serious", "needs_review"]
BUCKET = "efudex-tracker-reports-sr-2026" # change to your bucket name
TOPIC_ARN = "arn:aws:sns:us-east-1:<YOUR_ACCOUNT_ID>:efudex-tracker-alerts" # change to your topic ARN
# Order used in reports: most important first
SEVERITY_ORDER = ["potentially_serious", "notable", "needs_review", "expected", "not_relevant"]
QUERY = (
'("fluorouracil"[tiab] OR "5-fluorouracil"[tiab] OR "5-FU"[tiab] OR "Efudex"[tiab]) '
'AND (topical[tiab] OR cream[tiab]) '
'AND (skin[tiab] OR cutaneous[tiab] OR dermatitis[tiab] OR reaction*[tiab] OR adverse[tiab])'
)
bedrock = boto3.client("bedrock-runtime", region_name="us-east-1")
s3 = boto3.client("s3")
sns = boto3.client("sns", region_name="us-east-1")
# ---------- Instructions for the AI ----------
SYSTEM_PROMPT = """You screen PubMed abstracts for skin reactions to TOPICAL fluorouracil (5-FU), especially 5% cream (Efudex).
Choose exactly one label:
- not_relevant: not about topical fluorouracil, or no skin reaction to it is reported (e.g., systemic/IV 5-FU, other drugs, efficacy only).
- expected: usual local effects within the treated area (redness, crusting, burning, itching, erosion).
- notable: beyond the usual effect (e.g., allergic contact dermatitis, spread beyond the treated area, pigment changes).
- potentially_serious: severe outcomes (e.g., ulceration, necrosis, secondary infection, hospitalization, SJS/TEN, systemic toxicity).
- needs_review: the formulation or route is unclear, or the abstract does not give enough information to decide.
Rules:
- Use only the abstract. Do not use outside knowledge about the patient.
- evidence_quote must be copied WORD FOR WORD from the abstract (one sentence or less). Use "" if the label is not_relevant.
- Answer with JSON only, no other text:
{"label": "...", "formulation": "...", "reaction": "...", "evidence_quote": "...", "reason": "..."}"""
# ---------- PubMed (Step 1) ----------
def get(url):
req = urllib.request.Request(url, headers={"User-Agent": "efudex-tracker-lab"})
with urllib.request.urlopen(req, timeout=30) as resp:
return resp.read().decode("utf-8")
def search_pubmed(days):
params = urllib.parse.urlencode({
"db": "pubmed", "term": QUERY, "datetype": "edat",
"reldate": days, "retmax": 100, "retmode": "json",
})
data = json.loads(get(f"{EUTILS}/esearch.fcgi?{params}"))
return data["esearchresult"]["idlist"]
def fetch_articles(pmids):
if not pmids:
return []
params = urllib.parse.urlencode({"db": "pubmed", "id": ",".join(pmids), "retmode": "xml"})
root = ET.fromstring(get(f"{EUTILS}/efetch.fcgi?{params}"))
articles = []
for item in root.findall(".//PubmedArticle"):
pmid = item.findtext(".//PMID")
title_el = item.find(".//ArticleTitle")
title = "".join(title_el.itertext()) if title_el is not None else ""
abstract = " ".join("".join(p.itertext()) for p in item.findall(".//AbstractText"))
articles.append({
"pmid": pmid,
"title": title.strip(),
"abstract": abstract.strip(),
"url": f"https://pubmed.ncbi.nlm.nih.gov/{pmid}/",
})
return articles
# ---------- AI classification (Step 2) ----------
def normalize(text):
"""Lowercase and collapse spaces, so small formatting differences don't matter."""
return re.sub(r"\s+", " ", text).strip().lower()
def parse_json(text):
"""Extract the JSON object from the model's answer."""
match = re.search(r"\{.*\}", text, re.DOTALL)
return json.loads(match.group(0))
def classify(article):
if not article["abstract"]:
return {"label": "needs_review", "formulation": "", "reaction": "",
"evidence_quote": "", "reason": "No abstract available."}
response = bedrock.converse(
modelId=MODEL_ID,
system=[{"text": SYSTEM_PROMPT}],
messages=[{"role": "user", "content": [{"text":
f"Title: {article['title']}\n\nAbstract: {article['abstract']}"}]}],
inferenceConfig={"maxTokens": 400, "temperature": 0},
)
answer = response["output"]["message"]["content"][0]["text"]
result = parse_json(answer)
# Safety checks: the code does not blindly trust the AI.
if result.get("label") not in LABELS:
result["reason"] = f"Invalid label from model: {result.get('label')}"
result["label"] = "needs_review"
quote = result.get("evidence_quote", "")
if result["label"] in ("expected", "notable", "potentially_serious"):
if not quote or normalize(quote) not in normalize(article["abstract"]):
result["reason"] = "Evidence quote not found in the abstract. " + result.get("reason", "")
result["label"] = "needs_review"
return result
# ---------- Reports in S3 (Step 3) ----------
def save_reports(summary):
"""Save the results as JSON and CSV in s3://BUCKET/reports/YYYY-MM-DD/."""
folder = f"reports/{summary['run_date']}"
json_key = f"{folder}/report.json"
s3.put_object(
Bucket=BUCKET, Key=json_key,
Body=json.dumps(summary, indent=2, ensure_ascii=False).encode("utf-8"),
ContentType="application/json",
)
columns = ["label", "pmid", "title", "formulation", "reaction",
"evidence_quote", "reason", "url"]
buffer = io.StringIO()
writer = csv.DictWriter(buffer, fieldnames=columns, extrasaction="ignore")
writer.writeheader()
writer.writerows(summary["results"])
csv_key = f"{folder}/report.csv"
s3.put_object(
Bucket=BUCKET, Key=csv_key,
Body=buffer.getvalue().encode("utf-8-sig"), # utf-8-sig so Excel shows special characters correctly
ContentType="text/csv",
)
return [json_key, csv_key]
# ---------- Email with SNS (Step 4) ----------
SECTION_TITLES = {
"potentially_serious": "🔴 POTENTIALLY SERIOUS",
"notable": "🟡 NOTABLE",
"needs_review": "🔍 NEEDS REVIEW",
"expected": "🟢 EXPECTED",
"not_relevant": "⚪ NOT RELEVANT",
}
def send_email(summary):
"""Send a plain-text summary with a link to every article."""
counts = summary["counts"]
lines = [
"AI Drug Side Effect Tracker – Weekly Report",
f"Run date: {summary['run_date']} | Period: last {summary['days_searched']} days",
f"Articles found: {summary['articles_found']}",
"",
]
if summary["articles_found"] == 0:
lines += ["No new articles matched the search this period.", ""]
for label in SEVERITY_ORDER if summary["articles_found"] else []:
group = [r for r in summary["results"] if r["label"] == label]
lines.append(f"{SECTION_TITLES[label]} ({len(group)})")
for r in group:
lines.append(f"- {r['title']}")
if label != "not_relevant":
lines.append(f" Reaction: {r.get('reaction', '')}")
lines.append(f" Formulation: {r.get('formulation', '')}")
if r.get("evidence_quote"):
lines.append(f' Evidence: "{r["evidence_quote"]}"')
if label == "needs_review":
lines.append(f" Reason: {r.get('reason', '')}")
lines.append(f" Link: {r['url']}")
lines.append("")
lines += [
f"Reports saved in S3: s3://{BUCKET}/reports/{summary['run_date']}/",
"",
"This is an educational prototype. Every result must be verified by a person.",
]
subject = (f"Efudex Tracker: {counts['potentially_serious']} potentially serious, "
f"{counts['notable']} notable ({summary['articles_found']} articles)")
sns.publish(TopicArn=TOPIC_ARN, Subject=subject[:100], Message="\n".join(lines))
# ---------- Main ----------
def lambda_handler(event, context):
days = int(event.get("days", 7))
articles = fetch_articles(search_pubmed(days))
results = []
for article in articles:
try:
analysis = classify(article)
except Exception as error: # one bad article must not stop the whole run
analysis = {"label": "needs_review", "formulation": "", "reaction": "",
"evidence_quote": "", "reason": f"Analysis error: {error}"}
results.append({
"pmid": article["pmid"],
"title": article["title"],
"url": article["url"],
**analysis,
})
# Most important articles first
results.sort(key=lambda r: SEVERITY_ORDER.index(r["label"]))
summary = {
"run_date": datetime.now(timezone.utc).strftime("%Y-%m-%d"),
"days_searched": days,
"articles_found": len(results),
"counts": {label: sum(1 for r in results if r["label"] == label) for label in LABELS},
"results": results,
}
summary["report_files"] = save_reports(summary)
send_email(summary)
print(json.dumps(summary, indent=2))
return summary
Si trabajas en farmacovigilancia, o si tienes una tarea repetitiva que te gustaría automatizar, me encantaría leer en los comentarios cómo lo harías tú.




























Top comments (0)