LangChain v1: Xây dựng Trợ lý Tóm tắt Cuộc họp Tự động

LangChain là một khung nguồn mở để xây dựng ứng dụng AI có tác nhân (agentic) kết hợp LLM với công cụ. Phiên bản 1.0 đánh dấu chuyển dịch sang lõi cấp độ sản xuất với API tối giản, ranh giới rõ ràng và chuẩn hóa cách xử lý thông điệp trên các nhà cung cấp.

Trong hướng dẫn này, chúng ta sẽ xây dựng một Trợ lý Tóm tắt Cuộc họp Tự động bằng Streamlit: nhận ghi chú thô, tạo bản tóm tắt ngắn gọn kèm hạng mục hành động, và sau khi được duyệt bởi con người, sẽ chèn tóm tắt vào một Google Doc. Trong quá trình thực hiện, bạn sẽ thấy quy trình create_agent mới, các khối nội dung chuẩn, và không gian tên v1 gọn nhẹ hoạt động ra sao.

LangChain v1 là gì?

LangChain v1 là bản phát hành được tái cấu trúc, định hướng sản xuất, tập trung vào một bề mặt nhỏ và ổn định để xây dựng agent. Nó giới thiệu:

• create_agent như cách tiêu chuẩn để khởi tạo agent (sạch hơn so với các agent dựng sẵn cũ).

• Nội dung chuẩn hóa qua content_blocks để thông điệp nhất quán giữa các nhà cung cấp.

• Đầu ra có cấu trúc và middleware cho phản hồi có kiểu và hành động an toàn, được con người phê duyệt.

• Gói langchain tập trung vào các khối xây dựng agent, còn các mô-đun cũ chuyển sang langchain-classic, giúp dễ tìm kiếm và nâng cấp.

So với v0.x, v1 giảm tải nhận thức và khác biệt giữa nhà cung cấp bằng cách chuẩn hóa nội dung thông điệp và điều phối agent. Bạn có cùng mô hình tư duy dù dùng OpenAI, Anthropic hay nhà cung cấp khác.

Những cải tiến kỹ thuật chính trong LangChain v1

Bản LangChain v0.x ban đầu có nhiều mẫu để xây dựng agent, tuy nhiên v1 hợp nhất chúng vào một con đường rõ ràng với khối create_agent để agent của bạn dễ suy luận, kiểm thử và triển khai. Nó đi kèm bộ công cụ gọn gàng hơn, gỡ lỗi dễ hơn nhờ nội dung chuẩn hóa và vòng lặp agent có thể dự đoán.

Dưới đây là một số cải tiến kỹ thuật then chốt trong bản phát hành mới nhất:

• Quy trình create_agent: Vòng lặp agent sẵn sàng cho sản xuất cho phép mô hình quyết định khi nào gọi công cụ và khi nào kết thúc. Không còn phải xoay xở nhiều mẫu khác nhau, giúp tùy biến dễ dàng.

• Các khối nội dung chuẩn: Cách đọc thông điệp độc lập nhà cung cấp với dấu vết suy luận, lời gọi công cụ, trích dẫn, thậm chí là đa phương tiện — tất cả thông qua API content_blocks thống nhất. Công cụ và log trông giống nhau giữa các nhà cung cấp. 

• Đầu ra có cấu trúc: Bản phát hành mới hỗ trợ hạng nhất cho schema có kiểu để bạn có thể dựa vào JSON có thể dự đoán mà không cần regex cứng. Điều này giảm lỗi phân tích cú pháp và số lần gọi bổ sung.

• Middleware: Móc vào vòng lặp agent để phê duyệt các hành động rủi ro, tóm tắt lịch sử khi quá dài, và che PII trước khi gọi.

• Không gian tên đơn giản hóa: Gói langchain nay tập trung vào các khối xây dựng agent thiết yếu, trong khi LangGraph cung cấp các tính năng độ tin cậy như lưu trạng thái và “du hành thời gian” ở tầng dưới.

Demo: Xây dựng Trợ lý Tóm tắt Cuộc họp Tự động với LangChain v1

Trong phần này, chúng ta sẽ triển khai một ứng dụng Streamlit tự động hóa tóm tắt cuộc họp từ đầu đến cuối. Ứng dụng nhận ghi chú thô cùng siêu dữ liệu tùy chọn (tiêu đề, ngày, người tham dự). Sau đó tạo một RecapDoc có kiểu, gồm tiêu đề, tóm tắt, quyết định và hạng mục hành động, ở dạng đầu ra có cấu trúc. Chỉ với một cú nhấp, bản tóm tắt đã duyệt (thêm tiền tố ngày họp) sẽ được chèn vào Google Doc đã chỉ định.

Bước 1: Điều kiện tiên quyết

Trước khi xây dựng Trợ lý Tóm tắt Cuộc họp Tự động, chúng ta cần bộ công cụ tối thiểu cho UI, LLM, kiểm tra kiểu và truy cập Google Docs. Các lệnh dưới đây cài đặt mọi thứ cần thiết và thiết lập khóa mô hình để ứng dụng của bạn có thể giao tiếp với nhà cung cấp.

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=...

Ý nghĩa của từng điều kiện tiên quyết:

• Streamlit: Chạy ứng dụng web cục bộ với UI Pythonic đơn giản.

• langchain và langchain-openai: Cung cấp bề mặt tối giản của LangChain v1 (init_chat_model, đầu ra có cấu trúc) và cầu nối đến nhà cung cấp OpenAI.

• pydantic: Thư viện này định nghĩa schema nghiêm ngặt RecapDoc để mô hình trả về các trường có kiểu.

• Python-dotenv: Tải biến môi trường từ tệp .env trong quá trình phát triển.

• google-auth: Dùng để xử lý OAuth và Google Docs API để chúng ta có thể chèn tóm tắt vào tài liệu.

• OPENAI_API_KEY: Khóa API OpenAI xác thực các cuộc gọi LLM của chúng ta — đặt làm biến môi trường (hoặc dùng trình quản lý bí mật).

Lưu ý: Nếu bạn dùng nhà cung cấp khác (Anthropic, Google, hoặc mô hình cục bộ), hãy cài đặt tích hợp langchain-* tương ứng và đặt khóa API của nhà cung cấp đó.

Khi đã cài đặt các phụ thuộc này và đặt OPENAI_API_KEY, môi trường đã sẵn sàng. Ở các bước tiếp theo, chúng ta sẽ thiết lập Google Docs API qua Google Cloud.

Bước 2: Bật Google Docs API

Để lưu mỗi bản tóm tắt cuộc họp vào một tài liệu đang “sống”, ứng dụng cần quyền ghi vào Google Docs. Bước này thiết lập quyền truy cập trọn vẹn. Trước hết, chúng ta:

• Nhận tệp OAuth client (credentials.json) từ Google Cloud

• Sau đó xác định ID Google Doc mà bạn muốn chèn vào

• Cuối cùng, để ứng dụng tạo token.json có thể tái sử dụng trong lần chạy đầu tiên sau khi bạn phê duyệt quyền trong trình duyệt.

Khi đã có đủ ba phần này, ứng dụng có thể chèn tóm tắt vào Google Doc bạn chọn chỉ với một cú nhấp. Bạn có thể thu hồi hoặc gia hạn quyền bất cứ lúc nào bằng cách xóa token.json và chạy lại ứng dụng.

Bước 2.1: Lấy credentials.json từ Google Cloud

Tệp credentials.json là chìa khóa của ứng dụng đến Google Docs API. Bạn tạo nó một lần trong Google Cloud Console dưới dạng OAuth client cho Ứng dụng Máy tính để bàn. Bắt đầu như sau:

Tạo/chọn dự án

• Mở Google Cloud Console và chọn New Project.
• Đặt tên theo nhu cầu, rồi bấm Create.

Bật Google Docs API

Bây giờ dự án đã được tạo. Hãy bật API cần thiết để ghi vào Google Docs.

• Đi tới APIs & Services và tìm Library. Bạn cũng có thể dùng chức năng tìm kiếm.
• Tìm Google Docs API và bấm Enable. Lưu ý bạn nên tắt API sau khi dùng để tránh chi phí không cần thiết.

Cấu hình màn hình đồng ý OAuth

Sau khi bật API, tiếp theo chúng ta cần thiết lập xác thực cho email ưa dùng.

• Vào APIs & Services và bấm OAuth consent screen.
• Chọn External và điền thông tin ứng dụng cơ bản.
• Trong mục Audience / Test users , bấm Add users và thêm các tài khoản Gmail bạn sẽ dùng, rồi lưu.
• Để ứng dụng ở chế độ Testing là ổn cho phát triển.

Tạo thông tin xác thực OAuth client

Bước cuối là tạo và tải tệp credentials.json. Thực hiện như sau:

• Vào APIs & Services và bấm Credentials.

• Bấm + CREATE CREDENTIALS để tới OAuth client ID.

• Trong mục Application type chọn Desktop app và bấm Create.

• Có thể mất tới 5 phút để tạo client ID và secret, cùng tệp JSON có thể tải xuống.

• Lưu tệp JSON thành credentials.json trong cùng thư mục với app.py (hoặc cung cấp đường dẫn trong cài đặt ứng dụng).

Bạn đã có OAuth client cho Ứng dụng Máy tính để bàn mà ứng dụng có thể dùng để khởi tạo đăng nhập qua trình duyệt và yêu cầu quyền truy cập Google Docs thay bạn.

Bước 2.2: Google Doc ID

Ứng dụng cần biết sẽ chèn vào tài liệu nào. Tài liệu đó được định danh bởi ID duy nhất nằm trong URL. Bước này,

• Mở Google Doc mục tiêu trong trình duyệt.

• Sao chép chuỗi trong URL giữa /d/ và /edit, ví dụ: https://docs.google.com/document/d/<THIS_IS_THE_ID>/edit

• Dán Doc ID này vào trường “Google Doc ID” của ứng dụng (hoặc biến cấu hình tương ứng).

Với Doc ID chính xác, ứng dụng sẽ ghi tóm tắt vào đúng tài liệu bạn đã chọn.

Bước 2.3: Token.json

Ở lần chèn đầu tiên, ứng dụng cần bạn phê duyệt rõ ràng để truy cập tài liệu. Sau khi bạn phê duyệt, Google trả về token được ứng dụng lưu cục bộ dưới tên token.json. Cách tệp này được tạo:

• Chạy ứng dụng và bấm Append to Google Doc.

• Một cửa sổ trình duyệt mở ra yêu cầu bạn đăng nhập bằng một trong các test user đã thêm trước đó và phê duyệt phạm vi quyền.

• Sau khi xác nhận, ứng dụng ghi token.json cạnh mã nguồn của bạn. Tệp này chứa access/refresh token có thể tái sử dụng.

Lưu ý: Nếu cần chuyển tài khoản hoặc xin lại quyền, chỉ cần xóa token.json và bấm Append to Google Doc lần nữa.

Bước 3: Import 

Trước khi viết logic, chúng ta import các mô-đun phục vụ UI, hợp đồng dữ liệu có kiểu, gọi mô hình và tích hợp Google Docs. Nhóm import theo mục đích giúp codebase dễ đọc và rõ cần xử lý lớp nào khi có sự cố.

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

Ở bước này, chúng ta chỉ import những gì ứng dụng cần, tức là các tiện ích chuẩn như os, io, json, date, và gợi ý kiểu cho đường dẫn, bộ đệm, và tuần tự hóa nhẹ. Sau đó import Streamlit cho UI, Pydantic cho schema có kiểu RecapDoc, và dotenv để tải biến môi trường. Bề mặt LangChain v1 gồm init_chat_model và create_agent để khởi tạo mô hình chat độc lập nhà cung cấp và cấu trúc prompt, cuối cùng là các thành phần Google Docs API xử lý OAuth và cung cấp client đã xác thực để chèn tóm tắt vào tài liệu đã chọn.

Bước 4: Định nghĩa đầu ra có cấu trúc

Để phản hồi của mô hình đáng tin và dễ dùng, ta định nghĩa hợp đồng có kiểu cho bản tóm tắt. Dùng các mô hình Pydantic đảm bảo LLM trả về các trường có thể dự đoán mà UI có thể hiển thị, API có thể lưu và tự động hóa có thể kiểm tra.

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]

Các thành phần chính của khối mã trên:

• Lớp ActionItem: Nắm bắt các yếu tố cốt lõi của một tác vụ theo dõi như owner, task và due_date với mô tả ngắn gọn, rõ ràng để mô hình điền chính xác. Cho phép ngày ở định dạng ISO hoặc cụm từ tự nhiên giúp đầu vào linh hoạt mà vẫn có thể phân tích ở bước sau.

• Lớp RecapDoc: Đại diện toàn bộ bản tóm tắt dưới dạng một đối tượng duy nhất, gồm title, date, attendees, summary ngắn gọn, decisions rõ ràng và danh sách action_items.

Với LangChain v1, bạn có thể yêu cầu schema này trực tiếp qua with_structured_output(RecapDoc), giảm phân tích chuỗi mong manh, cải thiện kiểm tra và cho phép “fail fast” khi thiếu trường.

Bước 5: System prompt 

System prompt đặt các quy tắc nền cho trợ lý của bạn. Nó chỉ rõ mô hình phải tạo gì, tránh gì, và cấu trúc đầu ra thế nào để các bước sau hoạt động ổn định mỗi lần.

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 khiến trợ lý chính xác và súc tích, nhắm tới tóm tắt giàu thông tin thay vì bản ghi chi tiết. Nó in ra schema gọn gồm tiêu đề, ngày, người tham dự, tóm tắt, quyết định, action_items với các quy tắc như tóm tắt 3–6 câu, quyết định dạng gạch đầu dòng, và hạng mục hành động có người phụ trách, tác vụ và hạn chót.

Với system prompt rõ ràng, mô hình nhất quán tạo ra các bản tóm tắt có cấu trúc, dùng được ngay từ lần đầu.

Bước 6: Trợ giúp OAuth cho Google

Ở bước này, ta định nghĩa một hàm trợ giúp thiết lập kết nối tin cậy, có thể tái sử dụng đến Google Docs để ứng dụng có thể chèn tóm tắt vào tài liệu đã chọn. Nó chỉ yêu cầu phạm vi Docs và xử lý phê duyệt lần đầu, làm mới token, và dựng service.

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)

Hàm get_google_docs_service() xử lý OAuth và tạo service bằng cách:

• Giới hạn phạm vi: Dùng SCOPES được định nghĩa sẵn để giới hạn quyền với Google Docs.

• Nạp thông tin xác thực: Đọc từ credentials.json cục bộ hoặc từ st.secrets["google_credentials_json"] khi use_secrets=True.

• Tái sử dụng token: Nếu có token.json, mã sẽ nạp và nếu token hết hạn thì âm thầm làm mới.

• Phê duyệt lần đầu: Nếu không có token hợp lệ, khởi chạy InstalledAppFlow cho Ứng dụng Máy tính để bàn, nhắc người dùng xác thực trong trình duyệt, rồi lưu token.json cho các lần sau.

• Trả về client: Cuối cùng dựng và trả về Docs client đã xác thực qua hàm build().

Khi cấu hình xong, bạn có thể tái sử dụng cùng token.json cho xác thực hoặc tự động làm mới token. Để đặt lại quyền, chỉ cần xóa token.json và chạy lại ứng dụng.

Bước 7: Tiện ích chèn và bộ kết xuất Markdown

Tiếp theo, ta chuyển một RecapDoc có kiểu thành Markdown gọn gàng để chèn vào Google Doc mục tiêu. Một hàm kết xuất tóm tắt, hàm còn lại thực hiện ghi đã xác thực ở cuối tài liệu.

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)

Hai hàm trợ giúp trên phối hợp như sau:

• Hàm recap_to_markdown() dựng phần tóm tắt dễ đọc. Nó gồm tiêu đề với ngày, người tham dự, tóm tắt ngắn gọn, và hạng mục hành động với người phụ trách, tác vụ, hạn chót. Nó cũng rơi về “Unknown” hoặc “None recorded” khi thiếu trường.

• Hàm append_plaintext_to_doc() lấy tài liệu, tìm chỉ số cuối và gửi một yêu cầu insertText qua documents(). Văn bản được chèn kèm xuống dòng để mục sau bắt đầu ở dòng mới.

Lưu ý: Với tài liệu trống, hãy cân nhắc mặc định chỉ số chèn là 1 nếu endIndex không có.

Khi đã có kết xuất Markdown và chèn, tiếp theo ta thiết lập bộ tạo tóm tắt.

Bước 8: Trình tạo tóm tắt 

Hàm này là trái tim của ứng dụng. Nó nhận ghi chú thô và siêu dữ liệu tùy chọn, gọi mô hình chat, và trả về một RecapDoc có kiểu để mọi thứ phía sau đều có thể dự đoán.

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

Trình tạo tóm tắt gồm ba thành phần chính:

• Khởi tạo mô hình: Hàm init_chat_model() tạo mô hình chat cho nhà cung cấp bạn chọn. Sau đó gọi with_structured_output() để chỉ cho mô hình biết khuôn dạng cần trả về. Nó xuất đối tượng Python khớp các trường RecapDoc.

• Lắp ghép prompt: Chuẩn hóa đầu vào và gửi hai thông điệp, gồm SystemMessage với quy tắc nghiêm (system prompt) và HumanMessage mang tiêu đề, ngày, người tham dự và ghi chú thô.

• Sinh có cấu trúc: Hàm structured_llm.invoke() trả về RecapDoc đã được kiểm tra, tránh phải phân tích chuỗi và giảm tưởng tượng.

Bằng cách đi qua lớp bọc đầu ra có cấu trúc của LangChain, bước tóm tắt trở nên ổn định và sẵn sàng cho kết xuất Markdown mà không cần đổi logic phía sau.

Bước 9: UI Streamlit

Bước này nối toàn bộ demo vào một ứng dụng Streamlit một trang. Người dùng dán ghi chú, thêm siêu dữ liệu tùy chọn, tạo tóm tắt có cấu trúc, xem trước Markdown và chèn vào Google Doc bằng một cú nhấp.

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()

Ứng dụng Streamlit nối một hành động “Generate Recap” tới mô hình và hiển thị trên UI web cục bộ, bằng cách:

• Đầu vào (cột trái/phải): Khung trái là st.text_area lớn cho ghi chú thô. Cột phải thu thập tiêu đề, ngày và người tham dự.

• Đầu ra (khu xem trước): Khi có tóm tắt, ứng dụng hiển thị một đường phân cách và bản xem trước Markdown của tóm tắt có cấu trúc để rà soát nhanh.

• Nối giao diện (hành động): Các hành động này là lõi của ứng dụng. Bao gồm:

• Tạo tóm tắt: Kiểm tra hợp lệ ghi chú, gọi hàm generate_recap() để chuyển sang Markdown, và dùng st.rerun() để làm mới.

• Chèn vào Google Doc: Tạo client đã xác thực bằng get_google_docs_service(), thêm tiêu đề kèm ngày và chèn vào tài liệu đích.

• Trạng thái: st.session_state lưu RecapDoc và markdown_text mới nhất để UI ổn định qua các lần chạy lại.

• Thiết lập ứng dụng: Cuối cùng, load_dotenv() đọc biến môi trường, st.set_page_config() thiết lập bố cục và đường dẫn thông tin xác thực lấy từ env hoặc mặc định.

Lưu thành app.py và chạy lệnh sau trong terminal. 

streamlit run app.py

Giờ bạn đã có công cụ tóm tắt cuộc họp end-to-end như sau: