AI for email: a smarter inbox, drafts and replies

# For builders: Google's official Gmail server connects to Claude as a custom connector:
# Customize → Connectors → Add custom connector
# Remote MCP server URL: https://gmailmcp.googleapis.com/mcp/v1
# The OAuth Client ID and Secret are created in Google Cloud Console
# (instructions: 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:
    """
    Generates a draft reply to an incoming email.
    Returns the draft. It does NOT send anything automatically.
    You review it and send it yourself.
    """
    response = client.messages.create(
        model="claude-sonnet-5-5",  # current model IDs: see Anthropic's documentation
        max_tokens=4000,  # generous on purpose: the model's "thinking" counts toward this limit
        system="""You are a personal email assistant. You write replies in this style:
        
        - Short and to the point: no more than 100-150 words
        - Start with the substance, no small-talk greetings
        - Always end with a specific call to action: what you need from the person and by when
        - Use a list if there are 3 or more points
        - Tone: professional, not stiff
        
        IMPORTANT: you are proposing a draft, not the final text.
        Never add a signature; I add my own.""",
        messages=[{
            "role": "user",
            "content": f"""Incoming email:
---
{incoming_email}
---

Extra context for the reply: {context if context else 'none'}

Write a draft reply."""
        }]
    )
    # The reply may contain "thinking" blocks: keep only the text
    return "".join(block.text for block in response.content if block.type == "text")


def classify_email(email_text: str) -> dict:
    """
    Classifies an email: does it need a reply, how urgent is it, what type is it.
    Returns a dict with the classification.
    """
    response = client.messages.create(
        model="claude-haiku-4-5",  # Haiku is fast and cheap for classification; Haiku 4.5 may be retired from the API no earlier than October 15, 2026, so check the model ID in the docs
        max_tokens=150,
        messages=[{
            "role": "user",
            "content": f"""Classify this email. Return JSON only:
{{
  "needs_reply": true/false,
  "urgency": "high"/"medium"/"low",
  "type": "client_inquiry"/"follow_up"/"newsletter"/"spam"/"internal"/"other",
  "summary": "one sentence on what the email is about"
}}

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


# Example usage
if __name__ == "__main__":
    incoming = """
    Hi! I'd like to book a consultation about buying a home in San Antonio.
    My wife and I are thinking about moving there from Chicago next year, and we
    want to understand what homes really cost and how buying from out of state works.
    How much is a consultation, and when are you available?
    """
    
    # Step 1: classify
    classification = classify_email(incoming)
    print(f"Type: {classification['type']}")
    print(f"Urgency: {classification['urgency']}")
    print(f"Summary: {classification['summary']}")
    print(f"Needs reply: {classification['needs_reply']}")
    
    # Step 2: if it needs a reply, generate a draft
    if classification["needs_reply"]:
        context = "A consultation is $200/hour. Next openings: tomorrow at 3 p.m. or Friday at 11 a.m."
        draft = draft_reply(incoming, context)
        print(f"\nDraft reply:\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:
    """Finds an email address with Hunter.io from a domain and a name"""
    response = requests.get(
        "https://api.hunter.io/v2/email-finder",
        params={
            "domain": domain,
            "first_name": first_name,
            "last_name": last_name,
        },
        # The key goes in a header, not in the URL, so it doesn't end up in logs and history
        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 = "English"
) -> str:
    """Generates a personalized cold email"""
    
    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=4000,  # generous on purpose: the model's "thinking" counts toward this limit
        system=f"""You write personalized cold emails in this language: {language}.
        
        Rules:
        - 120 words max
        - Mention one specific detail about the person or the company
        - The value in 1-2 sentences: exactly what you can offer
        - One question at the end (not several)
        - No boilerplate like "I hope this email finds you well..."
        - Professional tone, not salesy""",
        messages=[{
            "role": "user",
            "content": f"""Recipient: {recipient_name}
Company: {company}
What I know about them: {context_about_them}

Me: an agent at Acme Realty. I help families relocating to San Antonio buy or rent a home.
I'm open to referral partnerships and co-op deals with other real estate agencies.

Write a cold email."""
        }]
    )
    # The reply may contain "thinking" blocks: keep only the text
    return "".join(block.text for block in response.content if block.type == "text")


# Contact list for outreach
contacts = [
    {
        "name": "Carlos Rodríguez",
        "company": "Example Realty Group",
        "domain": "example.com",
        "first_name": "Carlos",
        "last_name": "Rodriguez",
        "context": "Specializes in historic homes near downtown"
    },
    # ... the rest of your contacts
]

# Generate the emails and save them to a CSV
with open("cold_outreach.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["Name", "Company", "Email", "Message"])
    
    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="English"  # or "Spanish" for Spanish-speaking contacts
            )
            writer.writerow([contact["name"], contact["company"], email, letter])
            print(f"Done: {contact['name']} <{email}>")
        else:
            print(f"Email not found: {contact['name']}")

print("Saved to cold_outreach.csv")

Someone fills out a form on your website
          |
          v
Right away: Welcome email
            (Claude personalizes it from the form data: name, where they're moving from, what they're interested in)
          |
          v
Day 3:   Value email
         (AI picks content from your library: if they're interested in renting → an article about renting)
          |
          v
Day 7:   Case study email
         (the story of a real client similar to this person)
          |
          v
Day 14:  Offer email
         (a specific offer with a call to action to book a consultation)

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,  # "renting" / "buying" / "investing"
    city_of_origin: str
) -> str:
    """Personalized welcome email"""
    
    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=4000,  # generous on purpose: the model's "thinking" counts toward this limit
        system="""You write a welcome email to someone who is interested
        in buying or renting a home in San Antonio.
        
        Style: warm, not formal. It should sound like a real person wrote it.
        Length: 100-120 words.
        Structure: greeting → what they'll get next → one question so you can help them better.""",
        messages=[{
            "role": "user",
            "content": f"""Name: {name}
Interest: {interest}
Moving from: {city_of_origin}

Write a welcome email."""
        }]
    )
    # The reply may contain "thinking" blocks: keep only the text
    return "".join(block.text for block in response.content if block.type == "text")


def select_value_content(interest: str, knowledge_base: dict) -> str:
    """
    Picks the relevant content from the knowledge base for the Value email.
    knowledge_base: a dict of topics → article or tip texts
    """
    response = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=600,
        messages=[{
            "role": "user",
            "content": f"""This person is interested in: {interest}

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

Pick the most relevant content and write a 120-150 word email.
Use specific facts from the content you picked."""
        }]
    )
    return "".join(block.text for block in response.content if block.type == "text")


# Knowledge base (in real life it's read from files or a database; the data below is made up, for illustration only)
KNOWLEDGE_BASE = {
    "renting": "Sample rents in our area: 1-bedroom $1,100-1,400/month, 2-bedroom $1,400-1,900/month. Neighborhoods clients ask about most: Downtown, the North Side...",
    "buying": "Typical steps for a buyer: mortgage pre-approval → offer → inspection → appraisal → closing. Often 30-60 days from accepted offer to closing...",
    "investing": "Rental returns depend on the neighborhood and the property; in a real knowledge base, this is where your own verified numbers and caveats go (not investment advice)...",
}

# Example: generate a welcome email
email = generate_welcome_email(
    name="Mike",
    interest="buying",
    city_of_origin="Chicago"
)
print("Welcome email:")
print(email)
print()

# Value email
value_email = select_value_content("buying", KNOWLEDGE_BASE)
print("Value email (day 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:
    """
    Processes a list of emails: classifies them and writes drafts.
    
    emails: a list of dicts with the fields subject, sender, body, date
    your_context: a description of your work so Claude can write in your style
    """
    
    results = {
        "urgent": [],
        "normal": [],
        "fyi": [],
        "spam": [],
    }
    
    for email in emails:
        # Classification
        classification_response = client.messages.create(
            model="claude-haiku-4-5",
            max_tokens=200,
            messages=[{
                "role": "user",
                "content": f"""Classify this email. Return JSON:
{{
  "category": "urgent"/"normal"/"fyi"/"spam",
  "needs_reply": true/false,
  "summary": "one sentence"
}}

From: {email['sender']}
Subject: {email['subject']}
Body: {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
        }
        
        # Draft only if a reply is needed
        if classification["needs_reply"] and category in ["urgent", "normal"]:
            draft_response = client.messages.create(
                model="claude-sonnet-5-5",
                max_tokens=4000,  # generous on purpose: the model's "thinking" counts toward this limit
                system=f"""You are an email assistant. About the person you write for:
{your_context}

Reply style: short, to the point, a specific call to action at the end.""",
                messages=[{
                    "role": "user",
                    "content": f"""Write a draft reply to this email:

From: {email['sender']}
Subject: {email['subject']}
Body: {email['body']}"""
                }]
            )
            # The reply may contain "thinking" blocks: keep only the text
            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:
    """Formats the brief for your morning read"""
    
    lines = [
        f"Inbox brief for {__import__('datetime').date.today()}",
        f"Urgent: {len(processed['urgent'])} | "
        f"Normal: {len(processed['normal'])} | "
        f"FYI: {len(processed['fyi'])} | "
        f"Spam: {len(processed['spam'])}",
        "",
    ]
    
    if processed["urgent"]:
        lines.append("URGENT (reply today):")
        for email in processed["urgent"]:
            lines.append(f"  From: {email['sender']}")
            lines.append(f"  Summary: {email['summary']}")
            if email["draft"]:
                lines.append(f"  Draft:\n  {email['draft'][:200]}...")
            lines.append("")
    
    if processed["normal"]:
        lines.append("NORMAL:")
        for email in processed["normal"]:
            lines.append(f"  - {email['sender']}: {email['summary']}")
    
    return "\n".join(lines)


# Example usage (in real life the emails come in through the Gmail API)
sample_emails = [
    {
        "sender": "[email protected]",
        "subject": "Working together on a buyer?",
        "body": "Hi! I have a client relocating from Chicago who's looking for a condo around $150K. Could we work on this one together?",
        "date": "2026-10-05"
    },
    {
        "sender": "[email protected]",
        "subject": "Weekly market digest",
        "body": "Last week's San Antonio housing market report...",
        "date": "2026-10-05"
    },
]

YOUR_CONTEXT = """
Acme Realty helps families relocating to San Antonio buy or rent a home.
I work with clients directly and through local partner agencies.
Communication style: friendly, specific, no filler.
"""

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

def multilingual_reply(incoming_email: str, your_context: str) -> dict:
    """
    Detects the email's language and writes a reply in the same language.
    Returns: {detected_language, draft, summary_in_english}
    """
    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=4000,  # generous on purpose: the model's "thinking" counts toward this limit
        system=f"""You are a bilingual email assistant (English + Spanish).

About the person you write for:
{your_context}

Rules:
1. Detect the language of the incoming email
2. Reply in the SAME language (don't switch without a reason)
3. If it's Spanish, keep a professional tone that fits Latin American business email
4. If it's English, use a short, businesslike style

Return JSON:
{{
  "detected_language": "English"/"Spanish"/"Other",
  "draft": "the draft reply, in the email's language",
  "summary_in_english": "one sentence on what the email is about, always in English"
}}""",
        messages=[{
            "role": "user",
            "content": f"Email:\n{incoming_email}"
        }]
    )
    import json
    # The reply may contain "thinking" blocks: keep only the text
    text = "".join(block.text for block in response.content if block.type == "text")
    return json.loads(text)


# Test
spanish_email = """
¡Buenos días! Soy agente inmobiliario en Monterrey y tengo clientes
que se mudan a San Antonio y buscan casa. ¿Podríamos colaborar?
"""

result = multilingual_reply(spanish_email, YOUR_CONTEXT)
print(f"Language: {result['detected_language']}")
print(f"Summary (in English): {result['summary_in_english']}")
print(f"\nDraft reply:\n{result['draft']}")