Script Python: transcripción limpia con IA

pip install anthropic python-dotenv

python transcripcion.py mi_reunion.txt

#!/usr/bin/env python3
"""
transcripcion.py
Convierte transcripciones crudas en resúmenes estructurados usando Claude API.
Uso: python transcripcion.py <archivo_transcripcion>
"""

import sys
import os
import re
from pathlib import Path
from datetime import datetime
import anthropic
from dotenv import load_dotenv

load_dotenv()

ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
if not ANTHROPIC_API_KEY:
    raise ValueError("Falta ANTHROPIC_API_KEY en el archivo .env")

client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)


def limpiar_transcripcion(texto: str) -> str:
    """Elimina timestamps y etiquetas de formato VTT/SRT."""
    texto = re.sub(r'\d{2}:\d{2}:\d{2}[,\.]\d{3}\s*-->\s*\d{2}:\d{2}:\d{2}[,\.]\d{3}', '', texto)
    texto = re.sub(r'^\d+\s*$', '', texto, flags=re.MULTILINE)
    texto = re.sub(r'<[^>]+>', '', texto)
    texto = re.sub(r'^WEBVTT.*$', '', texto, flags=re.MULTILINE)
    texto = re.sub(r'\n{3,}', '\n\n', texto)
    return texto.strip()


def procesar_transcripcion(texto: str) -> dict:
    """Envía la transcripción a Claude y obtiene el análisis estructurado."""
    MAX_CHARS = 150000
    if len(texto) > MAX_CHARS:
        texto = texto[:MAX_CHARS] + "\n\n[TRANSCRIPCIÓN TRUNCADA POR LONGITUD]"

    prompt = f"""Analiza la siguiente transcripción de reunión y genera un informe estructurado completo en español.

TRANSCRIPCIÓN:
{texto}

Genera el informe con EXACTAMENTE este formato markdown:

## Resumen Ejecutivo
[2-3 párrafos que expliquen el contexto, objetivo y resultado de la reunión]

## Participantes Identificados
[Lista de personas mencionadas o que hablaron, si se puede inferir]

## Puntos Clave Discutidos
[Lista numerada de los 5-10 temas más importantes]

## Decisiones Tomadas
[Lista de decisiones concretas que se tomaron en la reunión]

## Action Items
| Tarea | Responsable | Fecha límite |
|-------|-------------|--------------|
[Tabla con todas las tareas, responsables y fechas si se mencionaron. Si no hay fecha, pon "Por definir"]

## Próxima Reunión
[Fecha y temas de la próxima reunión si se mencionaron, o "No definida"]

Sé específico y usa solo información que aparezca en la transcripción. No inventes datos."""

    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[{"role": "user", "content": prompt}]
    )

    return {
        "contenido": response.content[0].text,
        "tokens_usados": response.usage.input_tokens + response.usage.output_tokens
    }


def guardar_resultado(contenido: str, ruta_original: Path) -> Path:
    """Guarda el resumen como archivo Markdown."""
    timestamp = datetime.now().strftime("%Y%m%d_%H%M")
    nombre_salida = ruta_original.stem + f"_resumen_{timestamp}.md"
    ruta_salida = ruta_original.parent / nombre_salida

    header = f"""---
Fuente: {ruta_original.name}
Procesado: {datetime.now().strftime("%d/%m/%Y %H:%M")}
Modelo: claude-sonnet-4-20250514
---

"""
    ruta_salida.write_text(header + contenido, encoding="utf-8")
    return ruta_salida


def main():
    if len(sys.argv) < 2:
        print("Uso: python transcripcion.py <archivo_transcripcion.txt|.vtt|.srt>")
        sys.exit(1)

    ruta = Path(sys.argv[1])

    if not ruta.exists():
        print(f"Archivo no encontrado: {ruta}")
        sys.exit(1)

    print(f"Leyendo: {ruta.name}")
    texto_crudo = ruta.read_text(encoding="utf-8")
    texto_limpio = limpiar_transcripcion(texto_crudo)

    print(f"Procesando con Claude API ({len(texto_limpio):,} caracteres)...")
    resultado = procesar_transcripcion(texto_limpio)

    ruta_salida = guardar_resultado(resultado["contenido"], ruta)

    print(f"Resumen guardado en: {ruta_salida.name}")
    print(f"Tokens usados: {resultado['tokens_usados']:,}")
    print(f"\n{'='*50}")
    print(resultado["contenido"][:500] + "...")


if __name__ == "__main__":
    main()

Crea un script Python que procese transcripciones de reuniones usando la Claude API de Anthropic.

Requisitos:
- Lee archivos .txt, .vtt o .srt desde argv[1]
- Limpia timestamps SRT/VTT con regex antes de enviar a la API
- Trunca a 150,000 caracteres si el archivo es muy largo
- Usa anthropic.Anthropic() con modelo claude-sonnet-4-20250514
- El prompt debe pedir: resumen ejecutivo, participantes, puntos clave, decisiones, tabla de action items (con responsable y fecha), próxima reunión
- Guarda el output como {nombre_original}_resumen_{timestamp}.md con frontmatter YAML
- Imprime progreso en consola con emojis y muestra tokens usados
- Usa dotenv para ANTHROPIC_API_KEY
- Manejo de errores con mensajes descriptivos

Salida: script completo listo para ejecutar con python transcripcion.py archivo.txt