IA para el correo: una bandeja más inteligente, borradores y respuestas

# Para quienes construyen: el servidor oficial de Gmail de Google se conecta a Claude como conector personalizado:
# Customize → Connectors → Add custom connector (Personalizar → Conectores → Agregar conector personalizado)
# Remote MCP server URL: https://gmailmcp.googleapis.com/mcp/v1
# El Client ID y el Secret de OAuth se crean en Google Cloud Console
# (instrucciones: developers.google.com/workspace/gmail/api/guides/configure-mcp-server)

import anthropic
import os

client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

def draft_reply(incoming_email: str, context: str = "") -> str:
    """
    Genera un borrador de respuesta a un correo entrante.
    Devuelve el borrador. NO envía nada de forma automática.
    Tú lo revisas y lo envías.
    """
    response = client.messages.create(
        model="claude-sonnet-5-5",  # ID de modelo vigentes: mira la documentación de Anthropic
        max_tokens=4000,  # con margen a propósito: el "razonamiento" del modelo cuenta dentro de este límite
        system="""Eres un asistente personal de correo. Escribes respuestas con este estilo:
        
        - Cortas y al punto: no más de 100-150 palabras
        - Empiezas con lo importante, sin saludos de cortesía de relleno
        - Siempre terminas con una llamada a la acción concreta: qué necesitas de la persona y para cuándo
        - Usas una lista si hay 3 puntos o más
        - Tono: profesional, no acartonado
        
        IMPORTANTE: propones un borrador, no el texto final.
        Nunca agregues firma; yo agrego la mía.""",
        messages=[{
            "role": "user",
            "content": f"""Correo entrante:
---
{incoming_email}
---

Contexto adicional para la respuesta: {context if context else 'ninguno'}

Escribe un borrador de respuesta."""
        }]
    )
    # La respuesta puede traer bloques de "razonamiento": nos quedamos solo con el texto
    return "".join(block.text for block in response.content if block.type == "text")


def classify_email(email_text: str) -> dict:
    """
    Clasifica un correo: si necesita respuesta, qué tan urgente es, de qué tipo es.
    Devuelve un dict con la clasificación.
    """
    response = client.messages.create(
        model="claude-haiku-4-5",  # Haiku es rápido y barato para clasificar; Haiku 4.5 podría retirarse de la API no antes del 15 de octubre de 2026, así que revisa el ID de modelo en la documentación
        max_tokens=150,
        messages=[{
            "role": "user",
            "content": f"""Clasifica este correo. Devuelve solo JSON:
{{
  "needs_reply": true/false,
  "urgency": "high"/"medium"/"low",
  "type": "client_inquiry"/"follow_up"/"newsletter"/"spam"/"internal"/"other",
  "summary": "una frase sobre de qué trata el correo"
}}

Correo:
{email_text}"""
        }]
    )
    import json
    text = "".join(block.text for block in response.content if block.type == "text")
    return json.loads(text)


# Ejemplo de uso
if __name__ == "__main__":
    incoming = """
    ¡Hola! Me gustaría agendar una consulta sobre comprar casa en Querétaro.
    Mi esposa y yo estamos pensando en mudarnos allá desde la Ciudad de México el próximo año, y
    queremos entender cuánto cuestan de verdad las casas y cómo funciona comprar desde otra ciudad.
    ¿Cuánto cuesta una consulta y cuándo tienes disponibilidad?
    """
    
    # Paso 1: clasificar
    classification = classify_email(incoming)
    print(f"Tipo: {classification['type']}")
    print(f"Urgencia: {classification['urgency']}")
    print(f"Resumen: {classification['summary']}")
    print(f"Necesita respuesta: {classification['needs_reply']}")
    
    # Paso 2: si necesita respuesta, generar un borrador
    if classification["needs_reply"]:
        context = "Una consulta cuesta $200 USD la hora. Próximos horarios libres: mañana a las 3 p. m. o el viernes a las 11 a. m."
        draft = draft_reply(incoming, context)
        print(f"\nBorrador de respuesta:\n{'-'*40}\n{draft}")

import anthropic
import requests
import os
import csv

client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
HUNTER_API_KEY = os.environ["HUNTER_API_KEY"]

def find_email(domain: str, first_name: str, last_name: str) -> str:
    """Encuentra una dirección de correo con Hunter.io a partir de un dominio y un nombre"""
    response = requests.get(
        "https://api.hunter.io/v2/email-finder",
        params={
            "domain": domain,
            "first_name": first_name,
            "last_name": last_name,
        },
        # La clave va en un encabezado, no en la URL, para que no quede en registros ni en el historial
        headers={"X-API-KEY": HUNTER_API_KEY},
    )
    data = response.json()
    if data.get("data", {}).get("email"):
        return data["data"]["email"]
    return None


def write_cold_email(
    recipient_name: str,
    company: str,
    context_about_them: str,
    language: str = "español"
) -> str:
    """Genera un correo en frío personalizado"""
    
    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=4000,  # con margen a propósito: el "razonamiento" del modelo cuenta dentro de este límite
        system=f"""Escribes correos en frío personalizados en este idioma: {language}.
        
        Reglas:
        - 120 palabras como máximo
        - Menciona un detalle concreto de la persona o de la empresa
        - El valor en 1-2 frases: exactamente qué puedes ofrecer
        - Una pregunta al final (no varias)
        - Nada de frases de plantilla como "Espero que te encuentres muy bien..."
        - Tono profesional, no de vendedor""",
        messages=[{
            "role": "user",
            "content": f"""Destinatario: {recipient_name}
Empresa: {company}
Lo que sé de esta persona: {context_about_them}

Yo: agente de Acme Inmobiliaria. Ayudo a familias que se mudan a Querétaro a comprar o rentar casa.
Estoy abierto a alianzas por recomendación y a operaciones compartidas con otras inmobiliarias.

Escribe un correo en frío."""
        }]
    )
    # La respuesta puede traer bloques de "razonamiento": nos quedamos solo con el texto
    return "".join(block.text for block in response.content if block.type == "text")


# Lista de contactos para la prospección
contacts = [
    {
        "name": "Carlos Rodríguez",
        "company": "Example Inmobiliaria",
        "domain": "example.com",
        "first_name": "Carlos",
        "last_name": "Rodriguez",
        "context": "Se especializa en casas antiguas cerca del centro histórico"
    },
    # ... el resto de tus contactos
]

# Genera los correos y guárdalos en un CSV
with open("cold_outreach.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["Nombre", "Empresa", "Correo", "Mensaje"])
    
    for contact in contacts:
        email = find_email(
            contact["domain"],
            contact["first_name"],
            contact["last_name"]
        )
        
        if email:
            letter = write_cold_email(
                contact["name"],
                contact["company"],
                contact["context"],
                language="español"  # o "inglés" para contactos de habla inglesa
            )
            writer.writerow([contact["name"], contact["company"], email, letter])
            print(f"Listo: {contact['name']} <{email}>")
        else:
            print(f"Correo no encontrado: {contact['name']}")

print("Guardado en cold_outreach.csv")

Alguien llena un formulario en tu sitio web
          |
          v
De inmediato: correo de bienvenida
            (Claude lo personaliza con los datos del formulario: nombre, de dónde se muda, qué le interesa)
          |
          v
Día 3:   Correo de valor
         (la IA elige contenido de tu biblioteca: si le interesa rentar → un artículo sobre rentar)
          |
          v
Día 7:   Correo con caso de éxito
         (la historia de un cliente real parecido a esta persona)
          |
          v
Día 14:  Correo con oferta
         (una oferta concreta con una llamada a la acción para agendar una consulta)

import anthropic
import os
from datetime import datetime

client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

def generate_welcome_email(
    name: str,
    interest: str,  # "renta" / "compra" / "inversión"
    city_of_origin: str
) -> str:
    """Correo de bienvenida personalizado"""
    
    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=4000,  # con margen a propósito: el "razonamiento" del modelo cuenta dentro de este límite
        system="""Escribes un correo de bienvenida para alguien interesado
        en comprar o rentar casa en Querétaro.
        
        Estilo: cálido, no formal. Tiene que sonar como si lo hubiera escrito una persona real.
        Extensión: 100-120 palabras.
        Estructura: saludo → qué va a recibir después → una pregunta para poder ayudarle mejor.""",
        messages=[{
            "role": "user",
            "content": f"""Nombre: {name}
Interés: {interest}
Se muda desde: {city_of_origin}

Escribe un correo de bienvenida."""
        }]
    )
    # La respuesta puede traer bloques de "razonamiento": nos quedamos solo con el texto
    return "".join(block.text for block in response.content if block.type == "text")


def select_value_content(interest: str, knowledge_base: dict) -> str:
    """
    Elige el contenido relevante de la base de conocimiento para el correo de valor.
    knowledge_base: un dict de temas → textos de artículos o consejos
    """
    response = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=600,
        messages=[{
            "role": "user",
            "content": f"""A esta persona le interesa: {interest}

Contenido disponible:
{chr(10).join([f"- {topic}: {text[:100]}..." for topic, text in knowledge_base.items()])}

Elige el contenido más relevante y escribe un correo de 120-150 palabras.
Usa datos concretos del contenido que elegiste."""
        }]
    )
    return "".join(block.text for block in response.content if block.type == "text")


# Base de conocimiento (en la vida real se lee de archivos o de una base de datos; los datos de abajo son inventados, solo para ilustrar)
KNOWLEDGE_BASE = {
    "renta": "Rentas de ejemplo en nuestra zona: 1 recámara $1,100-1,400 USD al mes, 2 recámaras $1,400-1,900 USD al mes. Colonias por las que más preguntan los clientes: el Centro, la zona norte...",
    "compra": "Pasos típicos para quien compra: preaprobación del crédito → oferta → inspección → avalúo → firma. Muchas veces de 30 a 60 días desde la oferta aceptada hasta la firma...",
    "inversión": "El rendimiento de una renta depende de la zona y de la propiedad; en una base de conocimiento real, aquí van tus propios números verificados y tus advertencias (no es asesoría de inversión)...",
}

# Ejemplo: generar un correo de bienvenida
email = generate_welcome_email(
    name="Miguel",
    interest="compra",
    city_of_origin="Ciudad de México"
)
print("Correo de bienvenida:")
print(email)
print()

# Correo de valor
value_email = select_value_content("compra", KNOWLEDGE_BASE)
print("Correo de valor (día 3):")
print(value_email)

import anthropic
import os
from typing import List

client = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])

def process_inbox(emails: List[dict], your_context: str) -> dict:
    """
    Procesa una lista de correos: los clasifica y escribe borradores.
    
    emails: una lista de dicts con los campos subject, sender, body, date
    your_context: una descripción de tu trabajo para que Claude escriba con tu estilo
    """
    
    results = {
        "urgent": [],
        "normal": [],
        "fyi": [],
        "spam": [],
    }
    
    for email in emails:
        # Clasificación
        classification_response = client.messages.create(
            model="claude-haiku-4-5",
            max_tokens=200,
            messages=[{
                "role": "user",
                "content": f"""Clasifica este correo. Devuelve JSON:
{{
  "category": "urgent"/"normal"/"fyi"/"spam",
  "needs_reply": true/false,
  "summary": "una frase"
}}

De: {email['sender']}
Asunto: {email['subject']}
Cuerpo: {email['body'][:500]}"""
            }]
        )
        
        import json
        classification = json.loads(
            "".join(block.text for block in classification_response.content if block.type == "text")
        )
        category = classification["category"]
        
        email_data = {
            **email,
            "summary": classification["summary"],
            "draft": None
        }
        
        # Borrador solo si hace falta responder
        if classification["needs_reply"] and category in ["urgent", "normal"]:
            draft_response = client.messages.create(
                model="claude-sonnet-5-5",
                max_tokens=4000,  # con margen a propósito: el "razonamiento" del modelo cuenta dentro de este límite
                system=f"""Eres un asistente de correo. Sobre la persona para quien escribes:
{your_context}

Estilo de respuesta: corto, al punto, una llamada a la acción concreta al final.""",
                messages=[{
                    "role": "user",
                    "content": f"""Escribe un borrador de respuesta a este correo:

De: {email['sender']}
Asunto: {email['subject']}
Cuerpo: {email['body']}"""
                }]
            )
            # La respuesta puede traer bloques de "razonamiento": nos quedamos solo con el texto
            email_data["draft"] = "".join(
                block.text for block in draft_response.content if block.type == "text"
            )
        
        results[category].append(email_data)
    
    return results


def format_daily_brief(processed: dict) -> str:
    """Da formato al resumen para tu lectura de la mañana"""
    
    lines = [
        f"Resumen de la bandeja del {__import__('datetime').date.today()}",
        f"Urgentes: {len(processed['urgent'])} | "
        f"Normales: {len(processed['normal'])} | "
        f"Para tu información: {len(processed['fyi'])} | "
        f"Spam: {len(processed['spam'])}",
        "",
    ]
    
    if processed["urgent"]:
        lines.append("URGENTES (responder hoy):")
        for email in processed["urgent"]:
            lines.append(f"  De: {email['sender']}")
            lines.append(f"  Resumen: {email['summary']}")
            if email["draft"]:
                lines.append(f"  Borrador:\n  {email['draft'][:200]}...")
            lines.append("")
    
    if processed["normal"]:
        lines.append("NORMALES:")
        for email in processed["normal"]:
            lines.append(f"  - {email['sender']}: {email['summary']}")
    
    return "\n".join(lines)


# Ejemplo de uso (en la vida real los correos llegan por la API de Gmail)
sample_emails = [
    {
        "sender": "carlos@example.com",
        "subject": "¿Trabajamos juntos con un comprador?",
        "body": "¡Hola! Tengo un cliente que se muda desde la Ciudad de México y busca un departamento de alrededor de $150K USD. ¿Podríamos trabajar juntos en este caso?",
        "date": "2026-10-05"
    },
    {
        "sender": "newsletter@realestate-news.com",
        "subject": "Resumen semanal del mercado",
        "body": "El informe de la semana pasada sobre el mercado inmobiliario de Querétaro...",
        "date": "2026-10-05"
    },
]

YOUR_CONTEXT = """
Acme Inmobiliaria ayuda a familias que se mudan a Querétaro a comprar o rentar casa.
Trabajo con clientes de forma directa y a través de inmobiliarias aliadas de la zona.
Estilo de comunicación: cercano, concreto, sin relleno.
"""

processed = process_inbox(sample_emails, YOUR_CONTEXT)
brief = format_daily_brief(processed)
print(brief)

def multilingual_reply(incoming_email: str, your_context: str) -> dict:
    """
    Detecta el idioma del correo y escribe una respuesta en el mismo idioma.
    Devuelve: {detected_language, draft, summary_in_spanish}
    """
    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=4000,  # con margen a propósito: el "razonamiento" del modelo cuenta dentro de este límite
        system=f"""Eres un asistente de correo bilingüe (español + inglés).

Sobre la persona para quien escribes:
{your_context}

Reglas:
1. Detecta el idioma del correo entrante
2. Responde en el MISMO idioma (no cambies sin motivo)
3. Si es español, mantén un tono profesional propio del correo de negocios en América Latina
4. Si es inglés, usa un estilo breve y de negocios

Devuelve JSON:
{{
  "detected_language": "Spanish"/"English"/"Other",
  "draft": "el borrador de respuesta, en el idioma del correo",
  "summary_in_spanish": "una frase sobre de qué trata el correo, siempre en español"
}}""",
        messages=[{
            "role": "user",
            "content": f"Correo:\n{incoming_email}"
        }]
    )
    import json
    # La respuesta puede traer bloques de "razonamiento": nos quedamos solo con el texto
    text = "".join(block.text for block in response.content if block.type == "text")
    return json.loads(text)


# Prueba
english_email = """
Good morning! I'm a real estate agent in Houston, and I have clients
who are moving to Querétaro and looking for a home. Could we work together?
"""

result = multilingual_reply(english_email, YOUR_CONTEXT)
print(f"Idioma: {result['detected_language']}")
print(f"Resumen (en español): {result['summary_in_spanish']}")
print(f"\nBorrador de respuesta:\n{result['draft']}")