LangChain v1: Bangun Asisten Ringkasan Rapat Otomatis

LangChain adalah kerangka kerja open-source untuk membangun aplikasi AI agentic yang menggabungkan LLM dengan tool. Versi 1.0 menandai peralihan ke inti berkelas produksi dengan API yang disederhanakan, batasan yang lebih jelas, dan penanganan pesan yang terstandarisasi di berbagai penyedia.

Dalam tutorial ini, kita akan membangun Streamlit Auto Meeting Recap Assistant yang menerima catatan mentah, menghasilkan ringkasan singkat beserta item tindakan, dan setelah disetujui manusia, menambahkan ringkasan tersebut ke Google Doc. Sepanjang proses, Anda akan melihat alur create_agent yang baru, content blocks standar, dan namespace v1 yang lebih ramping saat digunakan.

Apa Itu LangChain v1?

LangChain v1 adalah rilis yang direstrukturisasi dan berorientasi produksi, berfokus pada permukaan kecil yang stabil untuk membangun agen. Rilis ini memperkenalkan:

• create_agent sebagai cara standar untuk memulai agen (lebih bersih dibanding agen bawaan lama).

• Konten yang distandardisasi melalui content_blocks sehingga pesan konsisten di semua penyedia.

• Structured output dan middleware untuk respons bertipe serta tindakan aman yang disetujui manusia.

• Paket langchain berfokus pada building block agen sehingga modul lama dipindahkan ke langchain-classic, memudahkan penemuan dan peningkatan.

Dibandingkan v0.x, v1 mengurangi beban kognitif dan keanehan penyedia dengan menstandarkan konten pesan dan orkestrasi agen. Anda mendapatkan model mental yang sama terlepas dari apakah Anda menggunakan OpenAI, Anthropic, atau lainnya.

Peningkatan Teknis Utama di LangChain v1

Versi asli Langchain v0.x menawarkan banyak pola untuk membangun agen, namun v1 mengonsolidasikannya menjadi satu jalur yang jelas menggunakan blok create_agent sehingga agen Anda lebih mudah dipahami, diuji, dan dikirimkan. Rilis ini hadir dengan tool yang lebih bersih, debugging yang lebih mudah melalui konten standar dan loop agen yang dapat diprediksi. 

Berikut adalah beberapa peningkatan teknis utama yang menjadi bagian dari rilis terbaru ini:

• Alur kerja create_agent: Loop agen siap produksi ini memungkinkan model memutuskan kapan memanggil tool dan kapan selesai. Jadi, kita tidak lagi harus menyeimbangkan banyak pola, yang membuat kustomisasi menjadi mudah.

• Content blocks standar: Cara yang tidak bergantung penyedia untuk membaca pesan adalah dengan jejak penalaran, panggilan tool, sitasi, bahkan multimodal, semuanya melalui API content_blocks yang terpadu. Tooling dan log terlihat sama di semua penyedia. 

• Structured output: Rilis terbaru hadir dengan dukungan kelas satu untuk skema bertipe sehingga Anda dapat bergantung pada JSON yang dapat diprediksi tanpa regex rapuh. Ini mengurangi kesalahan parsing dan panggilan tambahan.

• Middleware: Hook yang masuk ke loop agen untuk menyetujui tindakan berisiko, merangkum riwayat saat panjang, dan menyunting PII sebelum panggilan.

• Namespace yang disederhanakan: Paket langchain kini berfokus pada building block agen yang esensial, sementara LangGraph menyokong fitur keandalan seperti persistensi dan time-travel di balik layar.

Demo: Membangun Auto Meeting Recap Assistant dengan LangChain v1

Di bagian ini, kita akan mengimplementasikan aplikasi Streamlit yang mengotomatisasi ringkasan rapat dari awal hingga akhir. Aplikasi menerima catatan rapat mentah beserta metadata opsional (judul, tanggal, dan peserta). Lalu menghasilkan RecapDoc bertipe, termasuk judul, ringkasan, keputusan, dan item tindakan, dalam keluaran terstruktur. Dengan satu klik, ringkasan yang disetujui (dengan awalan tanggal rapat) ditambahkan ke Google Doc yang ditetapkan.

Langkah 1: Prasyarat

Sebelum membangun Auto Meeting Recap Assistant, kita memerlukan perangkat minimal untuk UI, LLM, validasi bertipe, dan akses Google Docs. Perintah di bawah ini memasang semua yang diperlukan dan menetapkan kunci model agar aplikasi Anda dapat berkomunikasi dengan penyedia.

pip install -U streamlit langchain langchain-openai pydantic python-dotenv
pip install -U google-api-python-client google-auth google-auth-oauthlib google-auth-httplib2
export OPENAI_API_KEY=...

Berikut fungsi masing-masing prasyarat:

• Streamlit: Menjalankan aplikasi web secara lokal dengan UI Pythonic yang sederhana.

• langchain dan langchain-openai: Menyediakan permukaan LangChain v1 yang disederhanakan (init_chat_model, structured output) dan jembatan ke penyedia OpenAI.

• pydantic: Pustaka ini mendefinisikan skema ketat RecapDoc sehingga model mengembalikan field bertipe.

• Python-dotenv: Memuat variabel lingkungan dari file .env selama pengembangan.

• google-auth: Digunakan untuk menangani OAuth dan Google Docs API sehingga kita dapat menambahkan ringkasan ke dokumen.

• OPENAI_API_KEY: Kunci API OpenAI mengautentikasi panggilan LLM kita dan ditetapkan sebagai variabel lingkungan (atau gunakan pengelola rahasia).

Catatan: Jika Anda menggunakan penyedia lain (Anthropic, Google, atau model lokal), pasang integrasi langchain-* yang sesuai dan tetapkan kunci API penyedia tersebut.

Dengan dependensi ini terpasang dan OPENAI_API_KEY ditetapkan, lingkungan siap digunakan. Pada langkah berikutnya, kita akan menyiapkan Google Docs API melalui Google Cloud.

Langkah 2: Aktifkan Google Docs API

Untuk menyimpan setiap ringkasan rapat ke dokumen yang terus diperbarui, aplikasi memerlukan izin untuk menulis ke Google Docs. Langkah ini menyiapkan akses tersebut secara menyeluruh. Pertama, kita:

• Mendapatkan file OAuth client (credentials.json) dari Google Cloud

• Kemudian, mengidentifikasi ID Google Doc yang ingin Anda tambahkan

• Terakhir, membiarkan aplikasi membuat token.json yang dapat digunakan kembali pada run pertama setelah Anda menyetujui akses di browser.

Setelah ketiga komponen ini tersedia, aplikasi dapat menambahkan ringkasan ke Google Doc pilihan Anda dengan satu klik. Anda dapat mencabut atau memperbarui akses kapan saja dengan menghapus token.json dan menjalankan aplikasi lagi.

Langkah 2.1: Dapatkan credentials.json dari Google Cloud

File credentials.json adalah kunci aplikasi Anda ke Google Docs API. Anda membuatnya sekali di Google Cloud Console sebagai OAuth client untuk Aplikasi Desktop. Untuk memulai:

Buat/pilih proyek

• Buka Google Cloud Console dan pilih New Project.
• Anda dapat menamainya sesuai kebutuhan, lalu klik Create.

Aktifkan Google Docs API

Sekarang proyek sudah dibuat. Mari aktifkan API yang diperlukan untuk menulis ke Google Docs.

• Buka APIs & Services dan cari Library. Anda juga bisa menggunakan fitur pencarian.
• Cari Google Docs API dan klik Enable. Perlu dicatat Anda juga harus menonaktifkan API setelah digunakan untuk menghindari biaya yang tidak perlu.

Konfigurasikan layar persetujuan OAuth

Setelah API diaktifkan, berikutnya kita perlu menetapkan autentikasi untuk email pilihan kita.

• Buka APIs & Services dan klik OAuth consent screen.
• Pilih External dan isi info dasar aplikasi.
• Di bagian Audience / Test users, klik Add users dan tambahkan akun Gmail yang akan Anda gunakan, lalu simpan.
• Membiarkan aplikasi dalam mode Testing tidak masalah untuk pengembangan.

Buat kredensial OAuth client

Langkah terakhir adalah menghasilkan dan mengunduh file credentials.json. Untuk ini:

• Buka APIs & Services dan klik Credentials.

• Klik + CREATE CREDENTIALS yang akan mengarahkan Anda ke OAuth client ID.

• Pada Application type pilih Desktop app dan klik Create.

• Mungkin perlu hingga 5 menit untuk menghasilkan client ID dan secret, beserta file JSON yang dapat diunduh.

• Simpan file JSON sebagai credentials.json di folder yang sama dengan app.py Anda (atau berikan path-nya di pengaturan aplikasi Anda).

Sekarang Anda memiliki OAuth client untuk Desktop yang dapat digunakan aplikasi untuk memulai login berbasis browser dan meminta izin untuk mengakses Google Docs atas nama Anda.

Langkah 2.2: Google Doc ID

Aplikasi perlu mengetahui dokumen mana yang akan ditambahkan. Dokumen tersebut diidentifikasi oleh ID unik yang tertanam dalam URL. Untuk langkah ini,

• Buka Google Doc target Anda di browser.

• Salin string dalam URL di antara /d/ dan /edit, contoh: https://docs.google.com/document/d/<THIS_IS_THE_ID>/edit

• Tempel Doc ID ini ke kolom aplikasi “Google Doc ID” (atau variabel konfigurasi yang sesuai).

Dengan Doc ID yang benar, aplikasi akan menulis ringkasan ke dokumen yang tepat yang Anda pilih.

Langkah 2.3: Token.json

Pada penambahan pertama, aplikasi memerlukan persetujuan eksplisit Anda untuk mengakses dokumen. Setelah Anda menyetujui, Google mengembalikan token yang disimpan aplikasi secara lokal sebagai token.json. Berikut cara file ini dibuat:

• Jalankan aplikasi dan klik Append to Google Doc.

• Jendela browser terbuka meminta Anda login dengan salah satu test user yang Anda tambahkan pada langkah sebelumnya dan untuk menyetujui cakupan.

• Setelah Anda mengonfirmasi, aplikasi menulis token.json di samping kode Anda. File ini berisi access/refresh token yang dapat digunakan kembali.

Catatan: Jika Anda perlu mengganti akun atau menjalankan ulang persetujuan, cukup hapus token.json dan klik Append to Google Doc lagi.

Langkah 3: Imports 

Sebelum menulis logika apa pun, kita mengimpor modul yang menjalankan UI, kontrak data bertipe, panggilan model, dan integrasi Google Docs. Mengelompokkan import berdasarkan tujuan membuat basis kode mudah dibaca dan memudahkan mengidentifikasi lapisan mana yang perlu diatasi saat terjadi masalah.

import os
import io
import json
from datetime import date
from typing import List, Optional
import streamlit as st
from pydantic import BaseModel, Field
from dotenv import load_dotenv
# ---- LangChain v1 surface ----
from langchain.agents import create_agent
from langchain.messages import SystemMessage, HumanMessage
from langchain.chat_models import init_chat_model
# ---- Google Docs API ----
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build

Pada langkah ini, kita hanya mengimpor yang diperlukan aplikasi, yakni utilitas standar seperti os, io, json, date, dan petunjuk typing untuk path, buffer, serta serialisasi ringan. Lalu kita impor Streamlit untuk UI, Pydantic untuk skema RecapDoc bertipe, dan dotenv untuk memuat variabel lingkungan. Permukaan LangChain v1 init_chat_model dan create_agent untuk menginisialisasi model chat yang tidak bergantung penyedia dan menyusun prompt, dan terakhir, komponen Google Docs API yang menangani OAuth dan memberi kita klien terautentikasi untuk menambahkan ringkasan ke dokumen pilihan.

Langkah 4: Definisikan structured output

Agar respons model andal dan mudah digunakan, kita mendefinisikan kontrak bertipe untuk ringkasan. Menggunakan model Pydantic memastikan LLM mengembalikan field yang dapat diprediksi sehingga UI kita dapat merendernya, API dapat menyimpannya, dan otomatisasi dapat memvalidasinya.

class ActionItem(BaseModel):
    owner: str = Field(..., description="Person responsible")
    task: str = Field(..., description="Short, specific task")
    due_date: str = Field(..., description="ISO date (YYYY-MM-DD) or natural language like 'next Friday'")
class RecapDoc(BaseModel):
    title: str
    date: str
    attendees: List[str]
    summary: str
    decisions: List[str]
    action_items: List[ActionItem]

Berikut komponen kunci dari blok kode di atas:

• Kelas ActionItem: Menangkap inti tugas tindak lanjut seperti owner, task, dan due_date dengan deskripsi singkat dan eksplisit agar model mengisinya dengan rapi. Mengizinkan tanggal ISO atau frasa alami membuat input tetap fleksibel namun tetap dapat diurai di tahap berikutnya.

• Kelas RecapDoc: Mewakili seluruh ringkasan sebagai satu objek, termasuk title, date, attendees, summary yang ringkas, decisions yang eksplisit, dan daftar action_items.

Dengan LangChain v1, Anda dapat meminta skema ini langsung melalui with_structured_output(RecapDoc), yang mengurangi parsing string yang rapuh, meningkatkan validasi, dan memungkinkan Anda gagal lebih cepat saat field hilang.

Langkah 5: System prompt 

System prompt menetapkan aturan dasar untuk asisten Anda. Prompt ini memberi tahu model secara tepat apa yang harus dihasilkan, apa yang harus dihindari, dan bagaimana menyusun keluarannya agar langkah berikutnya berjalan andal setiap saat.

SYSTEM_PROMPT = """You are a precise assistant that produces concise, high-signal meeting recaps.
Return a structured RecapDoc with:
- title, date, attendees
- a brief summary (3–6 sentences)
- explicit decisions (bullet-style)
- action_items (each has owner, task, due_date)
Rules:
- Only include info supported by the notes or explicit user inputs.
- Keep action items specific with clear owners and due dates.
- If something is unknown, say "Unknown" rather than inventing details.
"""

System prompt membuat asisten menjadi tepat dan ringkas, menargetkan ringkasan bernilai tinggi alih-alih transkrip. Prompt ini mencetak skema yang tegas termasuk judul, tanggal, peserta, ringkasan, keputusan, item tindakan dengan aturan seperti ringkasan 3–6 kalimat, keputusan berpoin, dan item tindakan dengan penanggung jawab, tugas, dan tenggat.

Dengan system prompt yang jelas, model secara konsisten menghasilkan ringkasan terstruktur yang dapat digunakan pada percobaan pertama. 

Langkah 6: Google OAuth helper

Pada langkah ini, kita mendefinisikan fungsi helper yang membangun koneksi tepercaya dan dapat digunakan kembali ke Google Docs agar aplikasi dapat menambahkan ringkasan ke dokumen pilihan Anda. Fungsi ini hanya meminta cakupan Docs dan menangani persetujuan pertama kali, penyegaran token, serta konstruksi layanan.

SCOPES = ["https://www.googleapis.com/auth/documents"]  
def get_google_docs_service(
    credentials_path: Optional[str],
    token_path: str = "token.json",
    use_secrets: bool = False
):
    creds = None
    if use_secrets:
        try:
            if "google_credentials_json" in st.secrets:
                with open("credentials_temp.json", "w") as f:
                    f.write(st.secrets["google_credentials_json"])
                credentials_path = "credentials_temp.json"
        except Exception:
            pass
    if os.path.exists(token_path):
        creds = Credentials.from_authorized_user_file(token_path, SCOPES)
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            try:
                creds.refresh(Request())  
            except Exception:
                pass
        if not creds or not creds.valid:
            if not credentials_path or not os.path.exists(credentials_path):
                raise RuntimeError(
                    "Missing Google OAuth credentials. Provide 'credentials.json' "
                    "or set st.secrets['google_credentials_json']."
                )
            flow = InstalledAppFlow.from_client_secrets_file(credentials_path, SCOPES)
            creds = flow.run_local_server(port=0)
            with open(token_path, "w") as token:
                token.write(creds.to_json())
    return build("docs", "v1", credentials=creds)

Fungsi get_google_docs_service() menangani OAuth dan pembuatan layanan dengan:

• Pembatasan akses: Fungsi di atas menggunakan SCOPES yang telah ditentukan untuk membatasi izin ke Google Docs.

• Memuat kredensial: Membaca dari credentials.json lokal atau dari st.secrets["google_credentials_json"] yang merupakan penyimpan rahasia Streamlit saat use_secrets=True.

• Penggunaan ulang token: Jika token.json ada, kode memuatnya dan jika token kedaluwarsa, diam-diam menyegarkannya.

• Persetujuan pertama kali: Jika tidak ditemukan token yang valid, kita meluncurkan InstalledAppFlow Desktop, yang meminta pengguna melakukan autentikasi di browser, lalu menyimpan token.json untuk run berikutnya.

• Mengembalikan klien: Terakhir, kita membangun dan mengembalikan klien Docs terautentikasi melalui fungsi build().

Setelah dikonfigurasi, Anda dapat menggunakan ulang token.json yang sama untuk autentikasi atau menyegarkan token secara otomatis. Untuk mereset akses, cukup hapus token.json dan jalankan aplikasi lagi.

Langkah 7: Utilitas append dan perender Markdown

Berikutnya, kita mengubah RecapDoc bertipe menjadi Markdown bersih yang ditambahkan ke Google Doc target. Satu fungsi merender ringkasan sementara fungsi lainnya melakukan penulisan terautentikasi di akhir dokumen.

def append_plaintext_to_doc(docs_service, document_id: str, text: str):
    doc = docs_service.documents().get(documentId=document_id).execute()
    end_index = doc.get("body", {}).get("content", [])[-1]["endIndex"]
    requests = [
        {
            "insertText": {
                "location": {"index": end_index - 1},
                "text": text + "\n"
            }
        }
    ]
    return docs_service.documents().batchUpdate(
        documentId=document_id,
        body={"requests": requests}
    ).execute()
def recap_to_markdown(recap: RecapDoc) -> str:
    lines = [
        f"# {recap.title} — {recap.date}",
        "",
        f"**Attendees:** {', '.join(recap.attendees) if recap.attendees else 'Unknown'}",
        "",
        "## Summary",
        recap.summary.strip(),
        "",
        "## Decisions",
    ]
    if recap.decisions:
        for d in recap.decisions:
            lines.append(f"- {d}")
    else:
        lines.append("- None recorded")
    lines.append("")
    lines.append("## Action Items")
    if recap.action_items:
        for ai in recap.action_items:
            lines.append(f"- **{ai.owner}** — {ai.task} _(Due: {ai.due_date})_")
    else:
        lines.append("- None recorded")
    return "\n".join(lines)

Kedua helper di atas bekerja bersama sebagai berikut:

• Fungsi recap_to_markdown() membangun ringkasan yang mudah dibaca. Termasuk judul dengan tanggal, peserta, ringkasan yang ringkas, dan item tindakan dengan penanggung jawab, tugas, dan tenggat. Juga menggunakan fallback “Unknown” atau “None recorded” saat field tidak ada.

• Sementara fungsi append_plaintext_to_doc() mengambil dokumen, menemukan end index saat ini, dan mengeluarkan satu permintaan insertText melalui documents(). Teks ditambahkan dengan baris baru di akhir agar entri berikutnya dimulai di baris baru.

Catatan: Untuk dokumen kosong, pertimbangkan menetapkan indeks penyisipan default ke 1 jika endIndex tidak tersedia.

Dengan perenderan Markdown dan append yang siap, berikutnya kita menyiapkan generator ringkasan.

Langkah 8: Generator ringkasan 

Fungsi ini adalah inti aplikasi. Fungsi menerima catatan mentah dan metadata opsional, memanggil model chat, dan mengembalikan RecapDoc bertipe sehingga semua langkah berikutnya tetap dapat diprediksi.

def generate_recap(model_name: str, notes: str, title: str, date_str: str, attendees_csv: str) -> RecapDoc:
    model = init_chat_model(model=model_name)
    structured_llm = model.with_structured_output(RecapDoc)
    attendees_hint = [a.strip() for a in attendees_csv.split(",")] if attendees_csv.strip() else []
    user_prompt = (
        "You will receive meeting notes and metadata.\n\n"
        f"Title: {title or 'Unknown'}\n"
        f"Date: {date_str or 'Unknown'}\n"
        f"Attendees: {attendees_hint if attendees_hint else 'Unknown'}\n\n"
        "Notes:\n"
        f"{notes.strip()}\n"
    )
    messages = [
        SystemMessage(content=SYSTEM_PROMPT),
        HumanMessage(content=user_prompt)
    ] 
    try:
        recap = structured_llm.invoke(messages)
    except Exception as e:
        st.error(f"Error generating recap: {e}")
        recap = RecapDoc(
            title=title or "Unknown",
            date=date_str or "Unknown",
            attendees=attendees_hint or [],
            summary=f"Error generating summary: {str(e)}",
            decisions=[],
            action_items=[]
        )  
    return recap

Generator ringkasan mencakup tiga komponen kunci:

• Inisialisasi model: Fungsi init_chat_model() membuat model chat untuk penyedia pilihan Anda. Lalu kita panggil fungsi with_structured_output() untuk memberi tahu model bentuk keluaran yang tepat. Fungsi ini menghasilkan objek Python yang sesuai dengan field RecapDoc.

• Penyusunan prompt: Kita menormalkan input dan mengirim dua pesan, termasuk SystemMessage dengan aturan ketat (system prompt) dan HumanMessage yang membawa judul, tanggal, peserta, dan catatan mentah.

• Generasi terstruktur: Fungsi structured_llm.invoke() mengembalikan RecapDoc yang tervalidasi, menghindari parsing dan mengurangi halusinasi.

Dengan mengalirkan model GPT Anda melalui pembungkus structured-output LangChain, langkah ringkasan menjadi andal dan siap dirender ke Markdown tanpa mengubah logika berikutnya.

Langkah 9: UI Streamlit

Langkah ini menyambungkan seluruh demo ke aplikasi Streamlit satu halaman. Pengguna menempelkan catatan, menambahkan metadata opsional, menghasilkan ringkasan terstruktur, meninjau pratinjau dalam Markdown, dan menambahkannya ke Google Doc dengan sekali klik.

def main():
    load_dotenv()
    st.set_page_config(page_title="Meeting Recap Assistant (LangChain v1)", page_icon=" ", layout="wide")
    st.markdown("<h1 style='text-align: center;'>Meeting Recap Assistant With LangChain v1</h1>", unsafe_allow_html=True)
    model_name = os.getenv("LC_MODEL", "gpt-4o-mini")
    document_id = "10G1k8-2JG_phkpjWM3xZEy2wNg5trUO0SJ2WN7kR3po"
    cred_mode = "credentials.json file"
    credentials_path = os.getenv("GOOGLE_CREDENTIALS_JSON", "credentials.json")
    st.subheader(" Add your meeting notes")
    colL, colR = st.columns([2, 1])
    with colL:
        notes = st.text_area(" ", height=300, placeholder="Paste your raw notes here...")
    with colR:
        title = st.text_input("Meeting Title", value="")
        date_str = st.date_input("Meeting Date", value=date.today())
        attendees_csv = st.text_input("Attendees (comma-separated)", value="")
    if "recap" not in st.session_state:
        st.session_state.recap = None
    if "markdown_text" not in st.session_state:
        st.session_state.markdown_text = None
    col1, col2, col3 = st.columns([1, 1, 2])    
    with col1:
        generate_btn = st.button("Generate Recap")    
    with col2:
        append_btn = st.button("Append to Google Doc", disabled=(st.session_state.recap is None))    
    if generate_btn:
        if not notes.strip():
            st.error("Please paste some notes.")
            st.stop()
        try:
            recap = generate_recap(
                model_name=model_name,
                notes=notes,
                title=title,
                date_str=str(date_str),
                attendees_csv=attendees_csv,
            )
            st.session_state.recap = recap
            st.session_state.markdown_text = recap_to_markdown(recap)
            st.rerun()
        except Exception as e:
            st.exception(e)
            st.stop()
    if append_btn and st.session_state.recap is not None:
        try:
            use_secrets = (cred_mode == "Streamlit secrets")
            service = get_google_docs_service(
                credentials_path=credentials_path if cred_mode == "credentials.json file" else None,
                use_secrets=use_secrets
            )
            final_text = f"\n\n===== {st.session_state.recap.title} — {st.session_state.recap.date} =====\n\n" + st.session_state.markdown_text
            append_plaintext_to_doc(service, document_id, final_text)
            st.success("Recap appended to the Google Doc")
        except Exception as e:
            st.exception(e)

    if st.session_state.recap is not None:
        st.markdown("---")
        st.markdown(st.session_state.markdown_text)
if __name__ == "__main__":
    main()

Aplikasi Streamlit menyambungkan satu aksi “Generate Recap” ke model dan mengeksposnya ke UI web lokal, dengan menggunakan:

• Input (kolom kiri/kanan): Panel kiri adalah st.text_area besar untuk catatan mentah. Sementara panel kanan menangkap judul, tanggal, dan peserta.

• Output (area pratinjau): Saat ringkasan tersedia, aplikasi menampilkan pemisah dan pratinjau Markdown dari ringkasan terstruktur untuk ditinjau cepat.

• Pengkabelan antarmuka (aksi): Aksi-aksi ini membentuk komponen inti aplikasi kita. Mencakup:

• Generate recap: Memvalidasi catatan, memanggil fungsi generate_recap() yang mengonversi ke Markdown, dan st.rerun() untuk menyegarkan.

• Append to Google Doc: Berikutnya, kita membuat klien terautentikasi dengan get_google_docs_service() yang menambahkan header bertanggal, dan menambahkannya ke dokumen tujuan.

• State: Metode st.session_state menyimpan RecapDoc dan markdown_text terbaru agar UI tetap stabil di setiap rerun.

• Penyiapan aplikasi: Terakhir, metode load_dotenv() membaca variabel lingkungan sementara st.set_page_config() mengatur tata letak dan path kredensial berasal dari env atau default.

Simpan sebagai app.py dan jalankan perintah berikut di terminal. 

streamlit run app.py

Sekarang Anda memiliki alat ringkasan rapat end-to-end yang terlihat seperti ini: