Automatización de Correos con Agentes IA

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Qué cubre este artículo sobre automatización de correos con agentes IA

• Cómo implementar automatización de correos con agentes IA.
• Cómo los agentes clasifican correos, redactan respuestas y los reenvían.
• Cómo construir filtros de spam, priorización y respuestas automáticas con IA local.
• Casos prácticos para buzones de soporte, solicitudes de ventas y distribución interna.
• Mejores prácticas para seguridad, privacidad y garantía de calidad.

Introducción: Automatización de correos con agentes IA explicada

El correo electrónico es uno de los canales de comunicación más intensivos en tiempo. Cada día llegan cientos de correos al buzón: consultas de soporte, leads de ventas, spam, mensajes internos. Clasificarlos, responderlos y reenviarlos manualmente consume horas. Los agentes IA pueden automatizar esto: leen correos, los clasifican, redactan respuestas y los reenvían a la persona correcta. Con IA local, estos agentes funcionan completamente en tu hardware, sin que el contenido de los correos llegue a proveedores de nube.

Este artículo va dirigido a desarrolladores que quieren construir automatización de correos con agentes IA. Deberías entender qué son los agentes IA y cómo ejecutarlos localmente con Ollama. Los fundamentos de programación con Python los encuentras en IRC-Coding.de.

¿Por qué necesito automatización de correos con agentes IA?

Imagina que gestionas un buzón de soporte con 200 correos diarios. Cada uno debe ser leído, categorizado, respondido o reenviado. Manualmente esto consume 4-6 horas al día. Un agente IA puede hacerlo en minutos: lee, clasifica, redacta respuestas y reenvía. Solo necesitas revisar y enviar las respuestas.

La automatización de correos es especialmente valiosa cuando recibes muchos mensajes, cuando la clasificación es compleja (múltiples categorías, consultas ambiguas) o cuando necesitas tiempos de respuesta rápidos.

Automatización de correos con agentes IA en pocas palabras

Un agente de correo es un agente IA que procesa mensajes. Lee correos entrantes, los clasifica por categoría, los prioriza, redacta respuestas y los reenvía a la persona indicada. El agente utiliza herramientas para acceder a correos (IMAP/SMTP) y el modelo de lenguaje para clasificación y redacción de respuestas.

La idea fundamental es esta: el agente es el asistente del buzón, las herramientas son IMAP y SMTP, el modelo es el cerebro.

¿Para quién es este artículo?

• Equipos de soporte, que quieren automatizar volumen de correos.
• Equipos de ventas, que quieren clasificar y priorizar leads automáticamente.
• Desarrolladores, que construyen agentes de correo.
• Administradores de sistemas, que configuran automatización de correos.

Se requieren conocimientos previos en Python, agentes IA y Ollama.

Términos clave sobre automatización de correos

• Agente de correo - Agente IA que procesa mensajes. Útil para: procesamiento automatizado de correos.
• IMAP - Protocolo para recepción de correos. Útil para: que el agente lea mensajes.
• SMTP - Protocolo para envío de correos. Útil para: que el agente envíe respuestas.
• Clasificación - Distribución en categorías. Útil para: ordenar correos.
• Priorización - Evaluación de importancia. Útil para: procesar primero los mensajes urgentes.
• Function Calling - Respuestas IA estructuradas. Útil para: clasificación y redacción de respuestas.
• Ollama - Servidor de modelos local. Útil para: como cerebro del agente.
• Agentes IA - Programas que resuelven tareas de forma autónoma. Útil para: base del sistema.
• Node-RED - Editor visual de flujos. Útil para: alternativa para workflows de correo.

Arquitectura de un agente de correo

Un agente de correo típico consta de estos componentes:

1. Recepción de correos: Polling IMAP o webhook para nuevos mensajes.
2. Análisis de correos: Extracción de asunto, remitente y cuerpo.
3. Clasificación: El modelo asigna el correo a una categoría.
4. Priorización: El modelo evalúa la importancia.
5. Redacción de respuesta: El modelo sugiere una respuesta.
6. Reenvío: El correo se reenvía a la persona correcta.
7. Respuesta automática: Se envía la respuesta (opcional, con aprobación).
8. Registro: Se registran todas las acciones.

Acceso a correos con Python

IMAP para recepción

import imaplib
import email
from email import policy

def fetch_emails(host, user, password, folder="INBOX", limit=10):
    mail = imaplib.IMAP4_SSL(host)
    mail.login(user, password)
    mail.select(folder)

    _, data = mail.search(None, "UNSEEN")
    email_ids = data[0].split()[:limit]

    emails = []
    for eid in email_ids:
        _, msg_data = mail.fetch(eid, "(RFC822)")
        msg = email.message_from_bytes(msg_data[0][1], policy=policy.default)
        emails.append({
            "from": msg["from"],
            "subject": msg["subject"],
            "body": get_body(msg),
            "date": msg["date"]
        })

    mail.logout()
    return emails

def get_body(msg):
    if msg.is_multipart():
        for part in msg.walk():
            if part.get_content_type() == "text/plain":
                return part.get_content()
    return msg.get_content()

SMTP para envío

import smtplib
from email.mime.text import MIMEText

def send_email(host, user, password, to, subject, body):
    msg = MIMEText(body)
    msg["Subject"] = subject
    msg["From"] = user
    msg["To"] = to

    with smtplib.SMTP_SSL(host, 465) as server:
        server.login(user, password)
        server.send_message(msg)

Clasificación con Ollama

import requests

def classify_email(subject, body):
    prompt = f"""
Klassifiziere diese E-Mail in eine der Kategorien:
- support: Technische Frage oder Problem
- sales: Kaufinteresse oder Angebot
- billing: Rechnung oder Zahlung
- spam: Werbung oder Phishing
- other: Sonstiges

Betreff: {subject}
Inhalt: {body[:1000]}

Antworte nur mit der Kategorie.
"""
    response = requests.post(
        "http://localhost:11434/api/chat",
        json={
            "model": "llama3.1",
            "messages": [
                {"role": "system", "content": "Du bist ein E-Mail-Klassifikator. Antworte nur mit einer Kategorie."},
                {"role": "user", "content": prompt}
            ],
            "stream": False
        }
    )
    return response.json()["message"]["content"].strip().lower()

Priorización con Function Calling

def prioritize_email(subject, body):
    tools = [
        {
            "type": "function",
            "function": {
                "name": "set_priority",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "priority": {"type": "string", "enum": ["high", "medium", "low"]},
                        "reason": {"type": "string"}
                    },
                    "required": ["priority", "reason"]
                }
            }
        }
    ]

    response = requests.post(
        "http://localhost:11434/api/chat",
        json={
            "model": "llama3.1",
            "messages": [
                {"role": "system", "content": "Bewerte die Priorität dieser E-Mail."},
                {"role": "user", "content": f"Betreff: {subject}\nInhalt: {body[:1000]}"}
            ],
            "tools": tools,
            "stream": False
        }
    )

    # Tool-Call extrahieren
    msg = response.json()["message"]
    if msg.get("tool_calls"):
        return msg["tool_calls"][0]["function"]["arguments"]
    return {"priority": "medium", "reason": "Unbekannt"}

Borrador de respuestas con Ollama

def draft_response(subject, body, category):
    prompt = f"""
Eres un asistente de correo electrónico. Redacta una respuesta cortés y profesional.

Categoría: {category}
Asunto: {subject}
Correo: {body[:2000]}

Redacta una respuesta adecuada. Si tienes dudas, sugiere derivar el correo a una persona.
"""
    response = requests.post(
        "http://localhost:11434/api/chat",
        json={
            "model": "llama3.1",
            "messages": [
                {"role": "system", "content": "Eres un asistente de correo electrónico. Redacta respuestas corteses y profesionales."},
                {"role": "user", "content": prompt}
            ],
            "stream": False
        }
    )
    return response.json()["message"]["content"]

Caso práctico 1: Buzón de soporte

Un agente que clasifica, prioriza y redacta respuestas para correos de soporte.

def support_agent(emails):
    results = []
    for email in emails:
        # Clasificación
        category = classify_email(email["subject"], email["body"])

        # Solo procesar correos de soporte
        if category != "support":
            continue

        # Priorización
        priority = prioritize_email(email["subject"], email["body"])

        # Borrador de respuesta
        draft = draft_response(email["subject"], email["body"], category)

        results.append({
            "email": email,
            "category": category,
            "priority": priority,
            "draft": draft
        })

    # Ordenar por prioridad
    results.sort(key=lambda x: {"high": 0, "medium": 1, "low": 2}[x["priority"]["priority"]])
    return results

Caso práctico 2: Calificación de oportunidades de venta

Un agente que califica consultas de ventas y las envía al representante adecuado.

def sales_agent(email):
    # Calificación
    qualification = requests.post(
        "http://localhost:11434/api/chat",
        json={
            "model": "llama3.1",
            "messages": [
                {"role": "system", "content": """
Califica esta consulta de ventas. Evalúa:
- budget: ¿Se menciona presupuesto? (yes/no/unknown)
- authority: ¿Es un responsable de toma de decisiones? (yes/no/unknown)
- need: ¿Se identifica una necesidad? (yes/no/unknown)
- timeline: ¿Hay un plazo definido? (yes/no/unknown)
Responde en JSON.
"""},
                {"role": "user", "content": f"Asunto: {email['subject']}\nContenido: {email['body'][:2000]}"}
            ],
            "format": "json",
            "stream": False
        }
    ).json()["message"]["content"]

    # Derivación según calificación
    score = sum(1 for v in json.loads(qualification).values() if v == "yes")
    if score >= 3:
        return {"action": "forward_to_senior", "qualification": qualification}
    elif score >= 1:
        return {"action": "forward_to_junior", "qualification": qualification}
    else:
        return {"action": "auto_reply_info", "qualification": qualification}

Caso práctico 3: Filtro anti-spam impulsado por IA

Un agente que detecta spam y phishing.

def spam_agent(email):
    result = requests.post(
        "http://localhost:11434/api/chat",
        json={
            "model": "llama3.1",
            "messages": [
                {"role": "system", "content": """
Evalúa si este correo es spam o phishing.
Criterios:
- Dominio del remitente inusual
- Llamada a la acción urgente
- Enlaces a sitios desconocidos
- Solicita datos personales
- Errores de gramática u ortografía
Responde en JSON: {"is_spam": true/false, "confidence": "high/medium/low", "reason": "..."}
"""},
                {"role": "user", "content": f"Remitente: {email['from']}\nAsunto: {email['subject']}\nContenido: {email['body'][:2000]}"}
            ],
            "format": "json",
            "stream": False
        }
    ).json()["message"]["content"]

    return json.loads(result)

Recomendaciones de seguridad

• Sin datos sensibles en la nube: Usa IA local para que los contenidos de correos no se transfieran a proveedores cloud.
• Aprobación humana: Para respuestas críticas, una persona debe revisar y aprobar. Consulta Aprobación humana.
• Registro de auditoría: Documenta todas las acciones de los agentes. Consulta Registro de auditoría.
• Protección contra inyección de prompts: Los correos pueden contener inyecciones de prompts. Consulta Protección contra inyección de prompts.
• Sin respuestas automáticas sin aprobación: Las respuestas automáticas deben ser revisadas por una persona.
• Autenticación de correo: Asegura SMTP/IMAP con OAuth2 o contraseñas de aplicación.

Errores comunes

• Clasificación incorrecta: El modelo puede equivocarse. Usa puntuaciones de confianza y aprobación humana.
• Inyección de prompts: Los correos pueden manipular el modelo. Protege el prompt del sistema.
• Respuestas automáticas sin revisión: Las respuestas no verificadas pueden ser embarazosas o perjudiciales.
• Bucles infinitos: Si el agente responde a sus propias respuestas, puede crear un bucle.
• Longitud del contexto: Los hilos de correo largos superan el contexto. Usa memoria resumida.
• Privacidad: Los contenidos de correos son sensibles. Usa IA local.

Enlaces relacionados e información sobre automatización de correo

• Fundamentos de agentes de IA - Qué son los agentes de IA.
• Agentes de IA con Ollama - Ejecutar agentes localmente.
• Function Calling - Fundamentos del uso de herramientas.
• Node-RED - Alternativa visual para flujos de correo.
• Aprobación humana - Human-in-the-loop.
• Protección contra inyección de prompts - Seguridad en contenidos de correos.
• Registro de auditoría - Trazabilidad.
• Flujos de investigación - Arquitectura de flujo similar.

Puntos clave:

• Los agentes de correo automatizan clasificación, priorización, redacción de respuestas y derivación.
• IMAP para recepción, SMTP para envío, Ollama para clasificación y respuestas.
• Casos prácticos: buzón de soporte, calificación de ventas, filtro anti-spam.
• Seguridad: IA local, aprobación humana, registro de auditoría, protección contra inyección de prompts.
• Sin respuestas automáticas sin aprobación.

Preguntas frecuentes: Automatización de correo con agentes de IA

Fuentes y lecturas complementarias

• Python imaplib - IMAP para Python.
• Python smtplib - SMTP para Python.
• Ollama - Servidor de modelos local.
• Node-RED - Alternativa visual.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert