AI в переписке — умная почта, черновики писем, ответы с помощью AI

# Для тех, кто строит: официальный сервер Gmail от Google подключается в Claude как свой коннектор:
# Customize → Connectors → Add custom connector
# Remote MCP server URL: https://gmailmcp.googleapis.com/mcp/v1
# OAuth Client ID и Secret создаются в Google Cloud Console
# (инструкция: 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:
    """
    Генерирует черновик ответа на входящее письмо.
    Возвращает черновик — НЕ отправляет автоматически.
    Ты проверяешь и отправляешь сам.
    """
    response = client.messages.create(
        model="claude-sonnet-5-5",  # актуальные идентификаторы моделей: документация Anthropic
        max_tokens=4000,  # с запасом: в этот лимит входит и «размышление» модели
        system="""Ты личный помощник по почте. Пишешь ответы в таком стиле:
        
        - Краткий и по делу: не больше 100-150 слов
        - Начинай сразу с содержания, без светских приветствий
        - В конце всегда конкретный призыв к действию: чего ждёшь от человека и когда
        - Используй списки, если пунктов три и больше
        - Тон: профессиональный, но не казённый
        
        ВАЖНО: ты предлагаешь черновик, не финальный текст.
        Никогда не добавляй подпись — владелец добавит сам.""",
        messages=[{
            "role": "user",
            "content": f"""Входящее письмо:
---
{incoming_email}
---

Дополнительный контекст для ответа: {context if context else 'нет'}

Составь черновик ответа."""
        }]
    )
    # В ответе могут быть блоки «размышления»: берём только текст
    return "".join(block.text for block in response.content if block.type == "text")


def classify_email(email_text: str) -> dict:
    """
    Сортирует письмо: нужен ли ответ, срочность, тип.
    Возвращает dict с результатом.
    """
    response = client.messages.create(
        model="claude-haiku-4-5",  # Haiku — быстро и дёшево для сортировки; Haiku 4.5 может быть выведена из API не раньше 15.10.2026, сверь идентификатор в документации
        max_tokens=150,
        messages=[{
            "role": "user",
            "content": f"""Классифицируй это письмо. Верни только JSON:
{{
  "needs_reply": true/false,
  "urgency": "high"/"medium"/"low",
  "type": "client_inquiry"/"follow_up"/"newsletter"/"spam"/"internal"/"other",
  "summary": "одно предложение о чём письмо"
}}

Письмо:
{email_text}"""
        }]
    )
    import json
    text = "".join(block.text for block in response.content if block.type == "text")
    return json.loads(text)


# Пример использования
if __name__ == "__main__":
    incoming = """
    Привет! Меня интересует консультация по недвижимости в Куэнке.
    Мы с женой думаем о переезде в следующем году, хотим понять
    реальную стоимость жилья и что нужно для покупки иностранцем.
    Сколько стоит ваша консультация и когда можете?
    """
    
    # Шаг 1: сортируем
    classification = classify_email(incoming)
    print(f"Тип: {classification['type']}")
    print(f"Срочность: {classification['urgency']}")
    print(f"Суть: {classification['summary']}")
    print(f"Нужен ответ: {classification['needs_reply']}")
    
    # Шаг 2: если нужен ответ — генерируем черновик
    if classification["needs_reply"]:
        context = "Консультация стоит $200/час. Ближайшее окно: завтра 15:00 или пятница 11:00"
        draft = draft_reply(incoming, context)
        print(f"\nЧерновик ответа:\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:
    """Находит email через Hunter.io по домену и имени"""
    response = requests.get(
        "https://api.hunter.io/v2/email-finder",
        params={
            "domain": domain,
            "first_name": first_name,
            "last_name": last_name,
        },
        # Ключ идёт в заголовке, а не в адресе запроса: так он не попадает в журналы и историю
        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 = "Spanish"
) -> str:
    """Генерирует личное холодное письмо"""
    
    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=4000,  # с запасом: в этот лимит входит и «размышление» модели
        system=f"""Ты пишешь личные холодные письма на языке: {language}.
        
        Правила:
        - Максимум 120 слов
        - Упомяни конкретную деталь о человеке или компании
        - Польза в 1-2 предложениях: что конкретно можешь дать
        - В конце один вопрос (не несколько)
        - Без шаблонных фраз «Надеюсь, письмо вас застанет...»
        - Профессиональный тон, без напора продавца""",
        messages=[{
            "role": "user",
            "content": f"""Получатель: {recipient_name}
Компания: {company}
Что я знаю о них: {context_about_them}

Я: агент Acme Realty, помогаю русскоязычным найти недвижимость в Эквадоре.
Могу предлагать совместные сделки агентствам недвижимости.

Напиши холодное письмо."""
        }]
    )
    # В ответе могут быть блоки «размышления»: берём только текст
    return "".join(block.text for block in response.content if block.type == "text")


# Список контактов для первых писем
contacts = [
    {
        "name": "Carlos Rodríguez",
        "company": "InmoCuenca",
        "domain": "example.com",
        "first_name": "Carlos",
        "last_name": "Rodriguez",
        "context": "Специализируются на элитной недвижимости в историческом центре"
    },
    # ... остальные контакты
]

# Генерируем письма и сохраняем в CSV
with open("cold_outreach.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["Имя", "Компания", "Email", "Письмо"])
    
    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="Spanish"
            )
            writer.writerow([contact["name"], contact["company"], email, letter])
            print(f"Готово: {contact['name']} <{email}>")
        else:
            print(f"Email не найден: {contact['name']}")

print("Сохранено в cold_outreach.csv")

Человек оставил заявку на сайте
          |
          v
Сразу:   Приветственное письмо
         (Claude подставляет данные из формы: имя, откуда человек, чем интересуется)
          |
          v
День 3:  Полезное письмо
         (AI выбирает материал из базы: если интерес «аренда» → статья об аренде)
          |
          v
День 7:  Письмо с историей клиента
         (история реального клиента, похожего на этого человека)
          |
          v
День 14: Письмо с предложением
         (конкретное предложение и призыв записаться на консультацию)

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,  # "аренда" / "покупка" / "инвестиции"
    city_of_origin: str
) -> str:
    """Приветственное письмо с данными человека"""
    
    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=4000,  # с запасом: в этот лимит входит и «размышление» модели
        system="""Пишешь приветственное письмо русскоязычному человеку,
        который заинтересовался недвижимостью в Эквадоре.
        
        Стиль: тёплый, не официальный. Как будто пишет живой человек.
        Длина: 100-120 слов.
        Структура: приветствие → что он получит дальше → один вопрос, чтобы лучше помочь.""",
        messages=[{
            "role": "user",
            "content": f"""Имя: {name}
Интерес: {interest}
Откуда: {city_of_origin}

Напиши приветственное письмо."""
        }]
    )
    # В ответе могут быть блоки «размышления»: берём только текст
    return "".join(block.text for block in response.content if block.type == "text")


def select_value_content(interest: str, knowledge_base: dict) -> str:
    """
    Выбирает подходящий материал из базы знаний для полезного письма.
    knowledge_base — словарь тем → тексты статей/советов
    """
    response = client.messages.create(
        model="claude-haiku-4-5",
        max_tokens=600,
        messages=[{
            "role": "user",
            "content": f"""Человек интересуется: {interest}

Доступные материалы:
{chr(10).join([f"- {topic}: {text[:100]}..." for topic, text in knowledge_base.items()])}

Выбери самый подходящий материал и напиши письмо на 120-150 слов.
Используй конкретные факты из выбранного материала."""
        }]
    )
    return "".join(block.text for block in response.content if block.type == "text")


# База знаний (в реальности — читается из файлов или БД; данные ниже условные, для примера)
KNOWLEDGE_BASE = {
    "аренда": "Средняя стоимость аренды в Куэнке: 1-комнатная $350-500, 2-комнатная $500-800. Лучшие районы: El Centro, Ordóñez Lasso...",
    "покупка": "Процесс покупки для иностранца: RUC → счёт в банке → promesa de compraventa → escritura. Занимает 45-90 дней...",
    "инвестиции": "Доходность аренды зависит от района и объекта; в реальной базе здесь лежат твои проверенные данные и оговорки (не инвестиционная рекомендация)...",
}

# Пример: генерируем приветственное письмо
email = generate_welcome_email(
    name="Михаил",
    interest="покупка",
    city_of_origin="Москва"
)
print("Приветственное письмо:")
print(email)
print()

# Полезное письмо
value_email = select_value_content("покупка", KNOWLEDGE_BASE)
print("Полезное письмо (день 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:
    """
    Обрабатывает список писем: сортирует и составляет черновики.
    
    emails: список dict с полями subject, sender, body, date
    your_context: описание твоей работы, чтобы Claude писал в твоём стиле
    """
    
    results = {
        "urgent": [],
        "normal": [],
        "fyi": [],
        "spam": [],
    }
    
    for email in emails:
        # Сортировка
        classification_response = client.messages.create(
            model="claude-haiku-4-5",
            max_tokens=200,
            messages=[{
                "role": "user",
                "content": f"""Классифицируй письмо. Верни JSON:
{{
  "category": "urgent"/"normal"/"fyi"/"spam",
  "needs_reply": true/false,
  "summary": "одно предложение"
}}

От: {email['sender']}
Тема: {email['subject']}
Текст: {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
        }
        
        # Черновик только если нужен ответ
        if classification["needs_reply"] and category in ["urgent", "normal"]:
            draft_response = client.messages.create(
                model="claude-sonnet-5-5",
                max_tokens=4000,  # с запасом: в этот лимит входит и «размышление» модели
                system=f"""Ты помощник по почте. Контекст о владельце:
{your_context}

Стиль ответов: краткий, по делу, конкретный призыв к действию в конце.""",
                messages=[{
                    "role": "user",
                    "content": f"""Составь черновик ответа на это письмо:

От: {email['sender']}
Тема: {email['subject']}
Текст: {email['body']}"""
                }]
            )
            # В ответе могут быть блоки «размышления»: берём только текст
            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:
    """Собирает сводку для утреннего чтения"""
    
    lines = [
        f"Сводка по почте — {__import__('datetime').date.today()}",
        f"Срочных: {len(processed['urgent'])} | "
        f"Обычных: {len(processed['normal'])} | "
        f"К сведению: {len(processed['fyi'])} | "
        f"Спам: {len(processed['spam'])}",
        "",
    ]
    
    if processed["urgent"]:
        lines.append("СРОЧНЫЕ (ответить сегодня):")
        for email in processed["urgent"]:
            lines.append(f"  От: {email['sender']}")
            lines.append(f"  Суть: {email['summary']}")
            if email["draft"]:
                lines.append(f"  Черновик:\n  {email['draft'][:200]}...")
            lines.append("")
    
    if processed["normal"]:
        lines.append("ОБЫЧНЫЕ:")
        for email in processed["normal"]:
            lines.append(f"  - {email['sender']}: {email['summary']}")
    
    return "\n".join(lines)


# Пример использования (в реальности письма приходят через Gmail API)
sample_emails = [
    {
        "sender": "[email protected]",
        "subject": "Совместная сделка",
        "body": "Добрый день! У меня есть клиент из России, который ищет квартиру за $150 тысяч. Можем ли мы поработать вместе?",
        "date": "2026-10-05"
    },
    {
        "sender": "[email protected]",
        "subject": "Еженедельный обзор рынка",
        "body": "Отчёт о рынке недвижимости Эквадора за прошлую неделю...",
        "date": "2026-10-05"
    },
]

YOUR_CONTEXT = """
Acme Realty — помогает русскоязычным купить или арендовать недвижимость в Эквадоре.
Работаю с клиентами напрямую и через местные агентства-партнёры.
Стиль общения: дружелюбный, конкретный, без лишних слов.
"""

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

def multilingual_reply(incoming_email: str, your_context: str) -> dict:
    """
    Определяет язык письма и составляет ответ на том же языке.
    Возвращает: {detected_language, draft, summary_in_russian}
    """
    response = client.messages.create(
        model="claude-sonnet-5-5",
        max_tokens=4000,  # с запасом: в этот лимит входит и «размышление» модели
        system=f"""Ты двуязычный помощник по почте (русский + испанский).

Контекст о владельце:
{your_context}

Правила:
1. Определи язык входящего письма
2. Ответь на ТОМ ЖЕ языке (не переключай без причины)
3. Если испанский — сохрани профессиональный латиноамериканский тон
4. Если русский — краткий деловой стиль

Верни JSON:
{{
  "detected_language": "Russian"/"Spanish"/"Other",
  "draft": "черновик ответа на языке письма",
  "summary_in_russian": "одно предложение о чём письмо — всегда на русском"
}}""",
        messages=[{
            "role": "user",
            "content": f"Письмо:\n{incoming_email}"
        }]
    )
    import json
    # В ответе могут быть блоки «размышления»: берём только текст
    text = "".join(block.text for block in response.content if block.type == "text")
    return json.loads(text)


# Проверка
spanish_email = """
Buenos días! Soy agente inmobiliario en Cuenca y tengo clientes 
de Rusia que buscan apartamentos. ¿Podríamos colaborar?
"""

result = multilingual_reply(spanish_email, YOUR_CONTEXT)
print(f"Язык: {result['detected_language']}")
print(f"Суть (по-русски): {result['summary_in_russian']}")
print(f"\nЧерновик ответа:\n{result['draft']}")