LangChain v1: Otomatik Toplantı Özeti Asistanı Oluşturun

LangChain, LLM'leri araçlarla birleştirerek ajan temelli yapay zeka uygulamaları geliştirmek için açık kaynaklı bir çerçevedir. Sürüm 1.0, basitleştirilmiş bir API, daha net sınırlar ve sağlayıcılar arasında standartlaştırılmış mesaj işleme ile üretim düzeyinde bir çekirdeğe geçişi işaret eder. 

Bu eğitimde, ham notları alan, eylem maddeleriyle birlikte öz bir özet üreten ve insan onayından sonra özeti bir Google Dokümanına ekleyen bir Streamlit Otomatik Toplantı Özeti Asistanı oluşturacağız. Bu süreçte yeni create_agent akışını, standart içerik bloklarını ve daha yalın v1 ad alanını uygulamada göreceksiniz.

LangChain v1 Nedir?

LangChain v1, ajanlar oluşturmak için küçük ve kararlı bir yüzeye odaklanan, yeniden yapılandırılmış ve üretim odaklı bir yayındır. Şunları sunar:

• Ajanları çalıştırmanın standart yolu olarak create_agent (eski hazır ajanlardan daha temiz).

• Sağlayıcılar arasında mesajların tutarlı olması için content_blocks ile standartlaştırılmış içerik.

• Tipli yanıtlar ve güvenli, insan onaylı eylemler için yapılandırılmış çıktı ve ara katman yazılımı.

• langchain paketi, eski modüllerin langchain-classic'e taşınmasıyla ajan yapı taşlarına odaklanır; bu da keşfedilebilirliği ve yükseltmeleri kolaylaştırır.

v0.x ile karşılaştırıldığında, v1 mesaj içeriğini ve ajan orkestrasyonunu standartlaştırarak bilişsel yükü ve sağlayıcı tuhaflıklarını azaltır. OpenAI, Anthropic veya diğerlerinde olsanız da aynı zihinsel modele sahip olursunuz.

LangChain v1’deki Temel Teknik İyileştirmeler

Orijinal LangChain v0.x sürümü ajanlar oluşturmak için birçok desen sundu, ancak v1 bunları create_agent bloğunu kullanarak tek ve net bir yolda birleştirir; böylece ajanlarınız hakkında düşünmek, test etmek ve yayınlamak daha kolay hale gelir. Daha temiz araç entegrasyonu, standartlaştırılmış içerik ve öngörülebilir ajan döngüsü sayesinde daha kolay hata ayıklama ile birlikte gelir. 

Bu son sürümün parçası olan bazı temel teknik iyileştirmeler şunlardır:

• create_agent iş akışı: Bu üretime hazır ajan döngüsü, modelin ne zaman araç çağıracağına ve ne zaman bitireceğine karar vermesini sağlar. Artık birden çok deseni jongle etmiyoruz; bu da kolay özelleştirmeye yol açıyor.

• Standart içerik blokları: Sağlayıcıdan bağımsız bir şekilde mesajları okumak; akıl yürütme izleri, araç çağrıları, atıflar ve hatta çoklu ortam parçaları için birleşik content_blocks API'si üzerinden mümkündür. Araçlar ve günlükler sağlayıcılar arasında aynı görünür. 

• Yapılandırılmış çıktı: Son sürüm, sağlam JSON'a tahmin edilebilir şekilde güvenebilmeniz için tipli şemalara birinci sınıf destek getirir; sert regex'lere gerek kalmaz. Bu, ayrıştırma hatalarını ve ekstra çağrıları azaltır.

• Ara katman yazılımı (Middleware): Riskli eylemleri onaylamak, uzun olduğunda geçmişi özetlemek ve çağrılardan önce KVK/PII'yi maskelemek için ajan döngüsüne kancalanır.

• Basitleştirilmiş ad alanı: langchain paketi artık temel ajan yapı taşlarına odaklanır; LangGraph ise perde arkasında kalıcılık ve zaman yolculuğu gibi güvenilirlik özelliklerini sağlar.

Demo: LangChain v1 ile Otomatik Toplantı Özeti Asistanı Oluşturma

Bu bölümde, toplantı özetlerini uçtan uca otomatikleştiren bir Streamlit uygulaması gerçekleştireceğiz. Uygulama ham toplantı notlarını, isteğe bağlı meta verilerle (başlık, tarih ve katılımcılar) birlikte kabul eder. Ardından başlık, özet, kararlar ve eylem maddelerini içeren tipli bir RecapDoc üretir ve yapılandırılmış bir çıktıya döker. Tek bir tıklamayla, onaylanan özet (toplantı tarihi öne eklenmiş şekilde) belirlenmiş bir Google Dokümanına eklenir.

Adım 1: Önkoşullar

Otomatik Toplantı Özeti Asistanını oluşturmadan önce, arayüz, LLM, tipli doğrulama ve Google Docs erişimi için asgari bir araç takımına ihtiyacımız var. Aşağıdaki komutlar gerekli her şeyi kurar ve uygulamanızın sağlayıcıyla konuşabilmesi için model anahtarını ayarlar.

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=...Altyapı:

Her bir önkoşulun ne yaptığına bakalım:

• Streamlit: Basit, Pythonik bir arayüzle web uygulamasını yerel olarak çalıştırır.

• langchain ve langchain-openai: Bunlar LangChain v1’in basitleştirilmiş yüzeyini (init_chat_model, yapılandırılmış çıktı) ve OpenAI sağlayıcı köprüsünü sunar.

• pydantic: Modelin tipli alanlar döndürmesi için katı RecapDoc şemasını tanımlar.

• Python-dotenv: Geliştirme sırasında ortam değişkenlerini bir .env dosyasından yükler.

• google-auth: Google Docs API'sini ve OAuth'u ele almak için kullanılır; böylece özeti bir belgeye ekleyebiliriz.

• OPENAI_API_KEY: OpenAI API Anahtarı LLM çağrılarımızı kimlik doğrular; bunu bir ortam değişkeni olarak ayarlayın (veya bir gizli yönetici kullanın).

Not: Başka bir sağlayıcı (Anthropic, Google veya yerel bir model) kullanıyorsanız, eşleşen langchain-* entegrasyonunu kurun ve o sağlayıcının API anahtarını ayarlayın.

Bu bağımlılıklar kurulduktan ve OPENAI_API_KEY ayarlandıktan sonra ortam hazırdır. Sonraki adımlarda, Google Cloud üzerinden Google Docs API'yi yapılandıracağız.

Adım 2: Google Docs API’yi etkinleştirin

Her toplantı özetini yaşayan bir belgeye kaydetmek için uygulamanın Google Docs’a yazma iznine ihtiyacı var. Bu adım, uçtan uca bu erişimi ayarlar. Önce şunları yaparız:

• Google Cloud’dan bir OAuth istemci dosyası (credentials.json) edinin

• Ardından, eklemek istediğiniz Google Dokümanı kimliğini belirleyin

• Son olarak, tarayıcınızda erişimi onayladıktan sonra uygulamanın ilk çalıştırmada yeniden kullanılabilir bir token.json oluşturmasına izin verin.

Bu üç parça yerli yerine oturduğunda, uygulama tek tıkla seçtiğiniz Google Dokümanına özetleri ekleyebilir. token.json'u silip uygulamayı yeniden çalıştırarak erişimi istediğiniz zaman iptal edebilir veya yenileyebilirsiniz.

Adım 2.1: Google Cloud’dan credentials.json alın

credentials.json dosyası, uygulamanızın Google Docs API’sine anahtarıdır. Bunu Google Cloud Console’da bir Masaüstü Uygulaması OAuth istemcisi olarak bir kez oluşturursunuz. Başlamak için:

Proje oluşturun/seçin

• Google Cloud Console'u açın ve New Project'i seçin.
• İhtiyacınıza göre adlandırabilir, ardından Create'e tıklayabilirsiniz.

Google Docs API’yi etkinleştirin

Artık projemiz oluşturuldu. Google Dokümanlarına yazmak için gereken API’yi etkinleştirelim.

• APIs & Services’a gidin ve Library’yi arayın. Arama özelliğini de kullanabilirsiniz.
• Google Docs API’yi arayın ve Enable’a tıklayın. Gereksiz ücretlerden kaçınmak için kullanım sonrası API’yi devre dışı bırakmanız gerekebileceğini unutmayın.

OAuth onay ekranını yapılandırın

API etkinleştirildikten sonra, tercih ettiğimiz e-posta için kimlik doğrulamayı ayarlamamız gerekir.

• APIs & Services’a gidin ve OAuth consent screen’e tıklayın.
• External’ı seçin ve temel uygulama bilgilerini doldurun.
• Audience / Test users bölümünde, Add users’a tıklayın ve kullanacağınız Gmail hesabını/hesaplarını ekleyin, ardından kaydedin.
• Geliştirme için uygulamanın Testing modunda kalması uygundur.

OAuth istemci kimlik bilgilerini oluşturun

Son adım credentials.json dosyasını üretip indirmektir. Bunun için:

• APIs & Services’a gidin ve Credentials’a tıklayın.

• + CREATE CREDENTIALS’a tıklayın; bu sizi OAuth client ID oluşturmaya yönlendirir.

• Application type altında Desktop app seçin ve Create’e tıklayın.

• İstemci kimliği ve gizli anahtarın oluşturulması ve indirilebilir bir JSON dosyasının sunulması 5 dakikaya kadar sürebilir.

• JSON dosyasını app.py ile aynı klasörde credentials.json olarak kaydedin (veya uygulama ayarlarınızda yolunu belirtin).

Artık uygulamanın tarayıcı tabanlı bir oturum açma başlatmak ve sizin adınıza Google Docs’a erişim izni istemek için kullanabileceği bir Masaüstü OAuth istemciniz var.

Adım 2.2: Google Doküman Kimliği

Uygulamanın hangi belgeye ekleneceğini bilmesi gerekir. Bu belge, URL’ye gömülü benzersiz bir kimlikle tanımlanır. Bu adım için,

• Hedef Google Dokümanınızı bir tarayıcıda açın.

• URL’deki /d/ ile /edit arasındaki dizgeyi kopyalayın; örneğin: https://docs.google.com/document/d/<THIS_IS_THE_ID>/edit

• Bu Doküman Kimliğini uygulamanın “Google Doc ID” alanına (veya ilgili yapılandırma değişkenine) yapıştırın.

Doğru Doküman Kimliği ile uygulama, özetleri tam olarak seçtiğiniz belgeye yazacaktır.

Adım 2.3: Token.json

İlk eklemede uygulamanın belgeye erişmesi için açık onayınıza ihtiyaç vardır. Onayladıktan sonra Google, uygulamanın yerel olarak token.json olarak sakladığı bir belirteç döndürür. Bu dosya şu şekilde oluşturulur:

• Uygulamayı çalıştırın ve Append to Google Doc’a tıklayın.

• Bir tarayıcı penceresi açılır; önceki adımda eklediğiniz test kullanıcılarından biriyle oturum açmanızı ve kapsamı onaylamanızı ister.

• Onayladıktan sonra uygulama token.json dosyasını kodunuzun yanına yazar. Bu dosya, yeniden kullanılabilir erişim/yenileme belirteçlerinizi içerir.

Not: Hesap değiştirmek veya onayı yeniden almak isterseniz, token.json dosyasını silip tekrar Append to Google Doc’a tıklamanız yeterlidir.

Adım 3: İçe aktarımlar 

Herhangi bir mantık yazmadan önce, arayüzü, tipli veri sözleşmelerini, model çağrılarını ve Google Docs entegrasyonunu çalıştıran modülleri içe aktarıyoruz. İçe aktarımları amacına göre gruplamak kod tabanını okunabilir kılar ve bir şey bozulduğunda hangi katmanın sorun giderileceğini açıkça gösterir.

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 buildAltyapı:

Bu adımda yalnızca uygulamanın ihtiyaç duyduğu şeyleri içe aktarıyoruz; yani os, io, json, date gibi standart yardımcılar ve yollar, tamponlar, hafif serileştirme için tür ipuçları. Ardından arayüz için Streamlit, tipli RecapDoc şemaları için Pydantic ve ortam değişkenlerini yüklemek için dotenv. LangChain v1 yüzeyi olan init_chat_model ve create_agent sağlayıcıdan bağımsız bir sohbet modelini başlatmak ve istemleri yapılandırmak için; son olarakGoogle Docs API parçaları OAuth’u ele alır ve özetleri seçilen belgeye eklemek için kimliği doğrulanmış bir istemci sağlar.

Adım 4: Yapılandırılmış çıktıyı tanımlayın

Modelin yanıtını güvenilir ve kullanımı kolay kılmak için özet için tipli bir sözleşme tanımlarız. Pydantic modellerini kullanmak, LLM'in arayüzümüzün işleyebileceği, API’nin saklayabileceği ve otomasyonların doğrulayabileceği tahmin edilebilir alanlar döndürmesini sağlar.

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]Altyapı:

Yukarıdaki kod bloğunun kilit bileşenleri şunlardır:

• ActionItem sınıfı: owner, task ve due_date gibi bir takip görevinin özünü yakalar ve modelin bu alanları temiz şekilde doldurması için kısa, açık açıklamalar içerir. ISO tarihine veya doğal ifadelere izin vermek girdiyi esnek kılar, aynı zamanda aşağı akışta ayrıştırılabilir tutar.

• RecapDoc sınıfı: Bu sınıf, title, date, attendees, öz bir summary, açık decisions ve bir action_items listesi dahil olmak üzere tüm özeti tek bir nesne olarak temsil eder.

LangChain v1 ile bu şemayı doğrudan with_structured_output(RecapDoc) üzerinden isteyebilirsiniz; bu da kırılgan dize ayrıştırmayı azaltır, doğrulamayı iyileştirir ve alanlar eksik olduğunda hızlıca hata vermenizi sağlar.

Adım 5: Sistem istemi 

Sistem istemi, asistanınız için temel kuralları belirler. Modele tam olarak ne üreteceğini, nelerden kaçınacağını ve çıktısını nasıl yapılandıracağını söyler; böylece aşağı akış adımları her seferinde güvenilir çalışır.

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.
"""Altyapı:

Sistem istemi, asistanı kesin ve öz yapar; döküm yerine sinyal yoğun özetleri hedefler. Başlık, tarih, katılımcılar, özet, kararlar ve eylem maddeleri gibi net bir şema üretir; 3–6 cümlelik özet, madde işaretli kararlar ve sahibi, görevi, teslim tarihi olan eylem maddeleri gibi kuralları içerir.

Net bir sistem istemiyle model, ilk denemede kullanılabilir, yapılandırılmış özetler üretir. 

Adım 6: Google OAuth yardımcısı

Bu adımda, uygulamanın seçtiğiniz Google Dokümanına özetleri ekleyebilmesi için Google Docs’a güvenilir, yeniden kullanılabilir bir bağlantı kuran yardımcı bir işlev tanımlarız. Yalnızca Docs kapsamını ister ve ilk onayı, belirteç yenilemeyi ve hizmet oluşturmayı ele alır.

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)Altyapı:

get_google_docs_service() işlevi OAuth’u ve hizmet oluşturmayı şu şekilde ele alır:

• Erişim kapsamını belirleme: Yukarıdaki işlev, izinleri Google Docs ile sınırlamak için önceden tanımlı SCOPES kullanır.

• Kimlik bilgilerini yükleme: Yerel bir credentials.json dosyasından veya use_secrets=True iken Streamlit’in gizli alanı olan st.secrets["google_credentials_json"] üzerinden okur.

• Belirteçleri yeniden kullanma: token.json mevcutsa, kod bunu yükler ve belirteç süresi dolmuşsa sessizce yeniler.

• İlk onay: Geçerli bir belirteç bulunamazsa, Masaüstü InstalledAppFlow başlatılır; bu, kullanıcıyı tarayıcıda kimlik doğrulamaya yönlendirir ve ardından gelecekteki çalıştırmalar için token.json kaydedilir.

• İstemci döndürme: Son olarak, build() işlevi aracılığıyla kimliği doğrulanmış bir Docs istemcisi oluşturur ve döndürür.

Yapılandırıldıktan sonra kimlik doğrulama için aynı token.json dosyasını yeniden kullanabilir veya belirteci otomatik olarak yenileyebilirsiniz. Erişimi sıfırlamak için token.json dosyasını silip uygulamayı yeniden çalıştırın.

Adım 7: Ekleme yardımcıları ve Markdown oluşturucu

Sonraki adımda, tipli bir RecapDoc'u hedef Google Dokümanına eklenecek temiz bir Markdown'a dönüştürüyoruz. Bir işlev özeti oluştururken diğeri belgenin sonunda kimliği doğrulanmış yazmayı gerçekleştirir.

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)Altyapı:

Yukarıdaki iki yardımcı, aşağıdaki şekilde birlikte çalışır:

• recap_to_markdown() işlevi okunabilir bir özet oluşturur. Tarihli başlık, katılımcılar, öz bir özet ve sahibi, görevi ve teslim tarihi olan eylem maddelerini içerir. Alanlar eksik olduğunda “Unknown” veya “None recorded” geri dönüşlerini kullanır.

• append_plaintext_to_doc() işlevi belgeyi getirir, mevcut bitiş indeksini bulur ve documents() üzerinden tek bir insertText isteği gönderir. Metin, sonraki girişlerin yeni satırda başlaması için sonda bir satır sonu ile eklenir.

Not: Boş belgeler için, endIndex kullanılamadığında ekleme indeksini 1'e varsayılan olarak ayarlamayı düşünün.

Markdown oluşturma ve ekleme hazır olduğuna göre, şimdi özet oluşturucumuzu kuruyoruz.

Adım 8: Özet oluşturucu 

Bu işlev, uygulamanın kalbidir. Ham notları ve isteğe bağlı meta verileri alır, bir sohbet modelini çağırır ve aşağı akışın öngörülebilir kalması için tipli bir RecapDoc döndürür.

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 recapAltyapı:

Özet oluşturucu üç ana bileşen içerir:

• Model başlatma: init_chat_model() işlevi, seçtiğiniz sağlayıcı için bir sohbet modeli oluşturur. Ardından, modele tam olarak hangi biçimde çıktı döndüreceğini söylemek için with_structured_output() işlevini çağırırız. Bu, RecapDoc alanlarıyla eşleşen bir Python nesnesi döndürür.

• İstem derleme: Girdileri normalleştirir ve iki mesaj göndeririz: katı kurallara sahip bir SystemMessage (sistem istemi) ve başlık, tarih, katılımcılar ve ham notları taşıyan bir HumanMessage.

• Yapılandırılmış üretim: structured_llm.invoke() işlevi, ayrıştırmayı önleyen ve hayal ürünü çıktıları azaltan doğrulanmış bir RecapDoc döndürür.

GPT modelinizi LangChain’in yapılandırılmış çıktı sarmalayıcısından geçirerek özet adımını güvenilir ve aşağı akış mantığını değiştirmeden Markdown’a hazır hale getirirsiniz.

Adım 9: Streamlit arayüzü

Bu adım, tüm demoyu tek sayfalık bir Streamlit uygulamasına bağlar. Kullanıcı notları yapıştırır, isteğe bağlı meta veriler ekler, yapılandırılmış bir özet üretir, bunu Markdown olarak önizler ve tek tıkla bir Google Dokümanına ekler.

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()Altyapı:

Streamlit uygulaması “Generate Recap” eylemini modele bağlar ve bunu yerel bir web arayüzüne sunar; şu şekilde:

• Girdiler (sol/sağ sütunlar): Sol panel ham notlar için geniş bir st.text_area. Sağ panel ise başlık, tarih ve katılımcıları alır.

• Çıktılar (önizleme alanı): Bir özet mevcut olduğunda, uygulama bir ayraç ve yapılandırılmış özetin hızlı inceleme için bir Markdown önizlemesini gösterir.

• Arayüz bağlama (eylemler): Bu eylemler uygulamamızın çekirdeğini oluşturur. Şunları içerir:

• Özet oluşturma: Notları doğrular, generate_recap() işlevini çağırır; bu da Markdown’a dönüştürür ve yenilemek için st.rerun() çağrısı yapar.

• Google Dokümanına ekle: Ardından get_google_docs_service() ile kimliği doğrulanmış bir istemci oluşturulur; tarihli bir başlık eklenir ve hedef belgeye eklenir.

• Durum: st.session_state son RecapDoc ve markdown_text’i saklar; böylece arayüz yeniden çalıştırmalarda da stabil kalır.

• Uygulama kurulumu: Son olarak load_dotenv() ortam değişkenlerini okurken st.set_page_config() yerleşimi ayarlar ve kimlik bilgisi yolları ortamdan veya varsayılanlardan gelir.

Dosyayı app.py olarak kaydedin ve terminalde aşağıdaki komutu çalıştırın. 

streamlit run app.pyAltyapı:

Artık uçtan uca bir toplantı özeti aracına sahipsiniz; şöyle görünür: