PricingLoginStart free
Ejen AI · Pelajaran

Membina Ejen Pembantu E-mel Ringkas

Hujung ke hujung: baca peti masuk → ringkaskan → draf balasan → tunggu kelulusan.

Pelajaran 4 daripada 413 langkah

Membina Ejen Pembantu E-mel Ringkas ialah pelajaran Ejen AI percuma di CoddyKit. Ini ialah pelajaran 4 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Ejen AI, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Ejen AI merangkumi sejumlah 4 pelajaran.

Seni Bina Ejen Pembantu E-mel

Ejen pembantu e-mel mengikuti aliran kerja standard: Ambil → Kelaskan → Putuskan → Draf → Luluskan → Hantar. Ejen membaca e-mel yang belum dibaca, menggunakan LLM untuk mengelaskan e-mel dan menyediakan respons draf, kemudian menunggu kelulusan manusia sebelum menghantarnya. Reka bentuk yang melibatkan manusia dalam gelung ini mencegah kesilapan besar akibat penghantaran e-mel yang sepenuhnya autonomi.

# Email Assistant Pipeline:
#
# 1. FETCH: Pull unread emails from Gmail API
# 2. CLASSIFY: LLM labels each email
#    - 'action_needed': requires a reply
#    - 'fyi': informational, no reply needed
#    - 'spam': should be archived
# 3. DRAFT: LLM generates reply for 'action_needed' emails
# 4. APPROVE: Human reviews drafts in Gmail UI
# 5. SEND: Agent sends approved drafts
#
# Tools: Gmail API, Anthropic/OpenAI API, json, base64

print('Email assistant pipeline: fetch -> classify -> draft -> approve -> send')

Mentakrifkan Alat Ejen

Susun ejen dengan takrif alat yang jelas. Setiap alat ialah fungsi Python dengan tanggungjawab tertentu. Modulariti ini menjadikan ejen mudah diuji, dinyahpepijat dan dikembangkan dengan keupayaan baharu.

class EmailAssistantTools:
    def __init__(self, gmail_service, llm_client):
        self.gmail = gmail_service
        self.llm = llm_client

    def fetch_unread(self, max_emails=10):
        '''Fetch unread emails from inbox.'''
        pass

    def classify_email(self, subject, body, sender):
        '''Ask LLM to classify: action_needed / fyi / spam.'''
        pass

    def draft_reply(self, subject, body, sender, context):
        '''Ask LLM to draft a reply to an email.'''
        pass

    def create_draft(self, message_id, reply_text):
        '''Save draft reply in Gmail for human review.'''
        pass

    def send_approved_drafts(self):
        '''Send all drafts marked as approved.'''
        pass

print('Tool-based architecture enables testing each step independently')

Langkah 1: Mengambil dan Menghurai E-mel

Alat pertama mengambil e-mel yang belum dibaca dan mengekstrak medan utama yang diperlukan oleh LLM: subjek, pengirim dan isi teks biasa. Pastikan isi e-mel ringkas — pangkas sehingga 2,000 aksara pertama untuk kekal dalam had konteks LLM dan mengurangkan kos API.

import base64

def fetch_emails_for_classification(gmail_service, max_emails=10):
    messages_list = gmail_service.users().messages().list(
        userId='me',
        q='is:unread label:inbox',
        maxResults=max_emails
    ).execute().get('messages', [])

    emails = []
    for ref in messages_list:
        msg = gmail_service.users().messages().get(
            userId='me', id=ref['id'], format='full'
        ).execute()

        headers = {h['name'].lower(): h['value']
                   for h in msg['payload'].get('headers', [])}
        body = extract_plain_text_body(msg)[:2000]  # trim for LLM

        emails.append({
            'id': msg['id'],
            'thread_id': msg['threadId'],
            'from': headers.get('from', ''),
            'subject': headers.get('subject', '(no subject)'),
            'body': body
        })

    print(f'Fetched {len(emails)} unread emails')
    return emails

Langkah 2: Pengelasan oleh LLM

Hantar setiap e-mel kepada LLM untuk dikelaskan. Gunakan gesaan berstruktur yang meminta model mengembalikan objek JSON dengan kategori dan alasan. Minta output JSON secara jelas — kaedah ini lebih boleh dipercayai berbanding menghuraikan teks bebas.

import json
import anthropic
import os

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

def classify_email(subject, sender, body):
    prompt = (
        'Classify this email as exactly one of: action_needed, fyi, spam.\n'
        'Return JSON only: {"category": "...", "reason": "..."}\n\n'
        f'From: {sender}\n'
        f'Subject: {subject}\n\n'
        f'Body:\n{body[:1500]}'
    )

    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=200,
        messages=[{'role': 'user', 'content': prompt}]
    )

    try:
        result = json.loads(response.content[0].text)
        return result.get('category', 'fyi'), result.get('reason', '')
    except json.JSONDecodeError:
        return 'fyi', 'Could not parse LLM response'

Langkah 3: Menjana Draf Respons

Untuk e-mel yang dikelaskan sebagai action_needed, minta LLM menjana draf respons. Berikan konteks tentang peranan dan nada ejen. Minta respons yang profesional tetapi ringkas — sertakan ruang letak bagi apa-apa maklumat yang perlu diisi oleh manusia.

def draft_reply(subject, sender, body, agent_context):
    prompt = (
        'You are an email assistant drafting a professional reply.\n'
        'Guidelines:\n'
        '- Be concise and professional\n'
        '- Use [FILL IN] for any info you don\'t know\n'
        '- Start with a greeting, end with a sign-off\n\n'
        f'Context about the recipient\'s work: {agent_context}\n\n'
        f'Original email from {sender}:\n'
        f'Subject: {subject}\n\n'
        f'{body[:1500]}\n\n'
        'Draft a reply:'
    )

    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=500,
        messages=[{'role': 'user', 'content': prompt}]
    )

    return response.content[0].text.strip()

Langkah 4: Menyimpan Draf untuk Semakan Manusia

Jangan hantar e-mel yang dijana AI tanpa semakan manusia. Simpan e-mel tersebut sebagai draf Gmail supaya manusia boleh membuka Gmail, menyemak, mengedit jika perlu dan menghantarnya. API penciptaan draf sama seperti API penghantaran, cuma menggunakan drafts().create().

import base64
from email.mime.text import MIMEText

def save_draft_reply(gmail_service, original_message, reply_text):
    sender_header = next(
        (h['value'] for h in original_message['payload'].get('headers', [])
         if h['name'].lower() == 'from'), ''
    )
    subject = next(
        (h['value'] for h in original_message['payload'].get('headers', [])
         if h['name'].lower() == 'subject'), ''
    )
    msg_id_header = next(
        (h['value'] for h in original_message['payload'].get('headers', [])
         if h['name'].lower() == 'message-id'), ''
    )

    mime_msg = MIMEText(reply_text, 'plain', 'utf-8')
    mime_msg['To'] = sender_header
    mime_msg['Subject'] = 'Re: ' + subject
    mime_msg['In-Reply-To'] = msg_id_header
    mime_msg['References'] = msg_id_header

    raw = base64.urlsafe_b64encode(mime_msg.as_bytes()).decode()
    draft = gmail_service.users().drafts().create(
        userId='me',
        body={'message': {'raw': raw, 'threadId': original_message['threadId']}}
    ).execute()

    print(f'Draft saved: {draft["id"]}')
    return draft['id']

# --- demo: minimal stand-in for the Gmail API's service object ---
class _Exec:
    def __init__(self, result):
        self._result = result
    def execute(self):
        return self._result

class _FakeDrafts:
    def create(self, userId, body):
        return _Exec({'id': 'r9000abc'})

class _FakeUsers:
    def drafts(self):
        return _FakeDrafts()

class _FakeGmailService:
    def users(self):
        return _FakeUsers()

original_message = {
    'threadId': 'thread_1',
    'payload': {'headers': [
        {'name': 'From', 'value': 'customer@example.com'},
        {'name': 'Subject', 'value': 'Question about my order'},
        {'name': 'Message-ID', 'value': '<abc123@mail.example.com>'}
    ]}
}
save_draft_reply(_FakeGmailService(), original_message, 'Thanks for reaching out, we will look into it.')

Langkah 5: Menandai E-mel yang Telah Diproses

Selepas memproses e-mel (dikelaskan + draf dicipta atau diarkibkan), tandainya untuk mengelakkan pemprosesan semula. Tambahkan label tersuai seperti AgentProcessed dan alih keluar label UNREAD. Cipta label tersebut sekali sahaja jika belum wujud.

def get_or_create_label(gmail_service, label_name):
    labels = gmail_service.users().labels().list(userId='me').execute()
    for label in labels.get('labels', []):
        if label['name'] == label_name:
            return label['id']

    # Create the label
    new_label = gmail_service.users().labels().create(
        userId='me',
        body={
            'name': label_name,
            'labelListVisibility': 'labelShow',
            'messageListVisibility': 'show'
        }
    ).execute()
    print(f'Created label: {label_name}')
    return new_label['id']

def mark_processed(gmail_service, message_id, agent_label_id):
    gmail_service.users().messages().modify(
        userId='me',
        id=message_id,
        body={
            'addLabelIds': [agent_label_id],
            'removeLabelIds': ['UNREAD']
        }
    ).execute()

# --- demo: minimal stand-in for the Gmail API's service object ---
class _Exec:
    def __init__(self, result):
        self._result = result
    def execute(self):
        return self._result

class _FakeUsers:
    def __init__(self):
        self._labels = [{'id': 'Label_1', 'name': 'Processed'}]
    def labels(self):
        return self
    def list(self, userId):
        return _Exec({'labels': self._labels})
    def create(self, userId, body):
        print(f'Created label: {body["name"]}')
        return _Exec({'id': 'Label_2', 'name': body['name']})
    def messages(self):
        return self
    def modify(self, userId, id, body):
        print(f'Marked {id} processed with {body}')
        return _Exec({'id': id})

class _FakeGmailService:
    def users(self):
        return _FakeUsers()

gmail_service = _FakeGmailService()
label_id = get_or_create_label(gmail_service, 'Processed')
print(f'Label id: {label_id}')
new_label_id = get_or_create_label(gmail_service, 'AgentHandled')
mark_processed(gmail_service, 'msg_99', new_label_id)

Gelung Pelaksanaan Penuh Ejen

Gabungkan semua langkah ke dalam satu kaedah run(). Ejen menggelung melalui e-mel, mengelaskan setiap satu, mencipta draf untuk item yang memerlukan tindakan, mengarkibkan spam dan menandai semuanya sebagai telah diproses. Catat ringkasan pada akhir proses.

def run_email_agent(gmail_service, agent_context, max_emails=10):
    processed_label = get_or_create_label(gmail_service, 'AgentProcessed')
    emails = fetch_emails_for_classification(gmail_service, max_emails)

    summary = {'action_needed': 0, 'fyi': 0, 'spam': 0, 'drafts_created': 0}

    for email in emails:
        category, reason = classify_email(
            email['subject'], email['from'], email['body']
        )
        summary[category] += 1
        print(f'[{category}] {email["subject"][:60]} - {reason[:50]}')

        if category == 'action_needed':
            # Fetch full message for reply context
            full_msg = gmail_service.users().messages().get(
                userId='me', id=email['id'], format='full'
            ).execute()
            reply = draft_reply(
                email['subject'], email['from'],
                email['body'], agent_context
            )
            save_draft_reply(gmail_service, full_msg, reply)
            summary['drafts_created'] += 1

        mark_processed(gmail_service, email['id'], processed_label)

    print('\nAgent run complete:')
    for k, v in summary.items():
        print(f'  {k}: {v}')
    return summary

Pengendalian Ralat dan Ketahanan

Bungkus setiap langkah pemprosesan e-mel dalam try/except. Kegagalan pada satu e-mel tidak sepatutnya menghentikan ejen daripada memproses e-mel yang lain. Catat ralat bersama ID dan subjek e-mel supaya anda boleh menyemaknya kemudian.

from googleapiclient.errors import HttpError

def process_email_safely(gmail_service, email, agent_context, label_id):
    try:
        category, reason = classify_email(
            email['subject'], email['from'], email['body']
        )

        if category == 'action_needed':
            full_msg = gmail_service.users().messages().get(
                userId='me', id=email['id'], format='full'
            ).execute()
            reply = draft_reply(
                email['subject'], email['from'],
                email['body'], agent_context
            )
            save_draft_reply(gmail_service, full_msg, reply)

        mark_processed(gmail_service, email['id'], label_id)
        return category

    except HttpError as e:
        print(f'Gmail API error on {email["id"]}: {e.resp.status}')
        return 'error'
    except Exception as e:
        print(f'Unexpected error on {email["subject"][:50]}: {e}')
        return 'error'

Menjadualkan Ejen untuk Berjalan Secara Berkala

Jalankan ejen e-mel mengikut jadual menggunakan gelung ringkas dengan time.sleep() antara setiap pelaksanaan. Untuk penggunaan produksi, gunakan penjadual tugas seperti cron, APScheduler atau fungsi awan. Sentiasa tambahkan semakan untuk mengelakkan ejen berjalan di luar waktu kerja demi menghormati zon waktu penerima.

import time
import datetime

def is_business_hours():
    now = datetime.datetime.now()
    # Mon-Fri, 9am-6pm local time
    return (now.weekday() < 5 and 9 <= now.hour < 18)

def run_scheduler(gmail_service, agent_context,
                  interval_minutes=30, max_emails=20):
    print(f'Email agent started. Checking every {interval_minutes} min.')

    while True:
        if is_business_hours():
            print(f'\n[{datetime.datetime.now().strftime("%H:%M")}] Running agent...')
            try:
                run_email_agent(gmail_service, agent_context, max_emails)
            except Exception as e:
                print(f'Agent run failed: {e}')
        else:
            print('Outside business hours, skipping run')

        time.sleep(interval_minutes * 60)

Pencatatan dan Jejak Audit

Simpan log JSON bagi setiap e-mel yang diproses oleh ejen. Ini mewujudkan jejak audit yang boleh anda semak untuk mengesahkan tingkah laku ejen, mendiagnosis pengelasan yang salah dan menambah baik gesaan dari semasa ke semasa.

import json
import datetime
from pathlib import Path

LOG_FILE = Path('agent_audit.jsonl')

def log_action(email_id, subject, sender, category, action, draft_id=None):
    entry = {
        'timestamp': datetime.datetime.now().isoformat(),
        'email_id': email_id,
        'subject': subject[:100],
        'from': sender,
        'category': category,
        'action': action,
        'draft_id': draft_id
    }
    with open(LOG_FILE, 'a', encoding='utf-8') as f:
        f.write(json.dumps(entry) + '\n')

# Usage in the main loop:
log_action(
    email_id='18abc123',
    subject='Invoice #1234',
    sender='billing@vendor.com',
    category='action_needed',
    action='draft_created',
    draft_id='r9000abc'
)

# --- demo ---
print('Audit log contents:')
print(LOG_FILE.read_text(encoding='utf-8'))

Semakan Ringkas: Manusia dalam Gelung

Uji pemahaman anda tentang reka bentuk ejen pembantu e-mel.

Jawab dalam pelajaran interaktif

Ringkasan Ejen Pembantu E-mel

Anda telah membina aliran kerja lengkap ejen pembantu e-mel:

  • Ambil: ambil e-mel yang belum dibaca dengan pertanyaan carian API Gmail
  • Kelaskan: LLM mengategorikan setiap e-mel sebagai action_needed/fyi/spam dengan output JSON
  • Draf: LLM menjana respons dengan nada profesional dan ruang letak [FILL IN]
  • Simpan draf: simpan dalam Gmail untuk semakan manusia — jangan hantar secara automatik
  • Tandai telah diproses: tambahkan label tersuai + alih keluar UNREAD untuk mengelakkan pemprosesan semula
  • Pengasingan ralat: bungkus setiap e-mel dalam try/except supaya satu kegagalan tidak menghentikan kelompok
  • Log audit: fail JSONL yang merekodkan setiap tindakan untuk semakan dan penambahbaikan
Percuma untuk bermula

Pelajari Ejen AI dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus
60
Pelajaran
239
Mula belajar secara percumaLihat kursus penuh

Soalan Lazim

Adakah pelajaran “Membina Ejen Pembantu E-mel Ringkas” percuma?

Ya — teks penuh “Membina Ejen Pembantu E-mel Ringkas” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Ejen AI, tingkat taraf kepada CoddyKit PRO. Kursus Ejen AI merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Membina Ejen Pembantu E-mel Ringkas”?

Hujung ke hujung: baca peti masuk → ringkaskan → draf balasan → tunggu kelulusan. Anda berlatih Ejen AI menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Ejen AI?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Ejen AI di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 4 daripada 4.

Berapa lamakah pelajaran “Membina Ejen Pembantu E-mel Ringkas” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Ejen AI ini?

Ya. Setiap pelajaran Ejen AI menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

  1. Menyambung ke Gmail melalui API
  2. Membaca dan Menghantar E-mel Secara Terprogram
  3. Penciptaan dan Pertanyaan Acara Kalendar
  4. Membina Ejen Pembantu E-mel Ringkas
← Kembali ke Ejen AI