Cara Membina Google NotebookLM anda sendiri

Dengan peningkatan populariti penggunaan kandungan audio, keupayaan untuk menukar dokumen atau kandungan bertulis anda kepada format audio yang realistik telah menjadi arah aliran baru-baru ini.

Walaupun NotebookLM Google telah mendapat perhatian dalam ruang ini, saya ingin meneroka membina sistem serupa menggunakan perkhidmatan awan moden. Dalam artikel ini, saya akan membimbing anda melalui cara saya mencipta sistem awan-asli berskala yang menukar dokumen kepada podcast berkualiti tinggi menggunakan FastAPI, Firebase, Google Cloud Pub/Sub dan perkhidmatan Text-to-Speech Azure.

Berikut ialah showcase yang anda boleh rujuk untuk keputusan sistem ini: MyPodify Showcase

Cabaran

Menukar dokumen kepada podcast tidak semudah menjalankan teks melalui enjin teks ke pertuturan. Ia memerlukan pemprosesan yang teliti, pemahaman bahasa semula jadi dan keupayaan untuk mengendalikan pelbagai format dokumen sambil mengekalkan pengalaman pengguna yang lancar. Sistem perlu:

• Proses berbilang format dokumen dengan cekap
• Jana audio bunyi semula jadi dengan berbilang suara
• Kendalikan pemprosesan dokumen berskala besar tanpa menjejaskan pengalaman pengguna
• Sediakan kemas kini status masa nyata kepada pengguna
• Kekalkan ketersediaan dan kebolehskalaan yang tinggi

Architecture Deep Dive

Mari kita pecahkan komponen utama dan fahami cara ia berfungsi bersama:

1. Bahagian Belakang FastAPI

FastAPI berfungsi sebagai rangka kerja bahagian belakang kami, dipilih atas beberapa sebab yang menarik:

• Sokongan Async: Dibina di atas Starlette, keupayaan async FastAPI membolehkan pengendalian permintaan serentak yang cekap
• Dokumentasi OpenAPI Automatik: Menjana dokumentasi API interaktif di luar kotak
• Keselamatan Jenis: Memanfaatkan pembayang jenis Python untuk pengesahan masa jalan
• Prestasi Tinggi: Setanding dengan Node.js dan Go dari segi kelajuan

Berikut ialah pandangan terperinci pada titik akhir muat naik kami:

@app.post('/upload')
async def upload_files(
    token: Annotated[ParsedToken, Depends(verify_firebase_token)],
    project_name: str,
    description: str,
    website_link: str,
    host_count: int,
    files: Optional[List[UploadFile]] = File(None)
):
    # Validate token
    user_id = token['uid']

    # Generate unique identifiers
    project_id = str(uuid.uuid4())
    podcast_id = str(uuid.uuid4())

    # Process and store files
    file_urls = await process_uploads(files, user_id, project_id)

    # Create Firestore document
    await create_project_document(user_id, project_id, {
        'status': 'pending',
        'created_at': datetime.now(),
        'project_name': project_name,
        'description': description,
        'file_urls': file_urls
    })

    # Trigger async processing
    await publish_to_pubsub(user_id, project_id, podcast_id, file_urls)

    return {'project_id': project_id, 'status': 'processing'}

2. Penyepaduan Firebase

Firebase menyediakan dua perkhidmatan penting untuk aplikasi kami:

Storan Firebase

• Mengendalikan muat naik fail selamat dengan penskalaan automatik
• Menyediakan pengedaran bersandarkan CDN untuk fail audio yang dijana
• Menyokong muat naik yang boleh disambung semula untuk fail besar

Firestore

• Pangkalan data masa nyata untuk penjejakan status projek
• Struktur berasaskan dokumen sesuai untuk metadata projek
• Penskalaan automatik tanpa serpihan manual diperlukan

Begini cara kami melaksanakan kemas kini status masa nyata:

async def update_status(user_id: str, project_id: str, status: str, metadata: dict = None):
    doc_ref = db.collection('projects').document(f'{user_id}/{project_id}')

    update_data = {
        'status': status,
        'updated_at': datetime.now()
    }

    if metadata:
        update_data.update(metadata)

    await doc_ref.update(update_data)

3. Google Cloud Pub/Sub

Pub/Sub berfungsi sebagai tulang belakang pemesejan kami, membolehkan:

• Seni bina yang dipisahkan untuk kebolehskalaan yang lebih baik
• Jaminan penghantaran sekurang-kurangnya sekali
• Pengekalan dan main semula mesej automatik
• Barisan surat mati untuk mesej yang gagal

Contoh struktur mesej:

@app.post('/upload')
async def upload_files(
    token: Annotated[ParsedToken, Depends(verify_firebase_token)],
    project_name: str,
    description: str,
    website_link: str,
    host_count: int,
    files: Optional[List[UploadFile]] = File(None)
):
    # Validate token
    user_id = token['uid']

    # Generate unique identifiers
    project_id = str(uuid.uuid4())
    podcast_id = str(uuid.uuid4())

    # Process and store files
    file_urls = await process_uploads(files, user_id, project_id)

    # Create Firestore document
    await create_project_document(user_id, project_id, {
        'status': 'pending',
        'created_at': datetime.now(),
        'project_name': project_name,
        'description': description,
        'file_urls': file_urls
    })

    # Trigger async processing
    await publish_to_pubsub(user_id, project_id, podcast_id, file_urls)

    return {'project_id': project_id, 'status': 'processing'}

4. Penjanaan Suara dengan Perkhidmatan Pertuturan Azure

Inti penjanaan audio kami menggunakan SDK Pertuturan Perkhidmatan Kognitif Azure. Mari lihat cara kami melaksanakan sintesis suara yang berbunyi semula jadi:

async def update_status(user_id: str, project_id: str, status: str, metadata: dict = None):
    doc_ref = db.collection('projects').document(f'{user_id}/{project_id}')

    update_data = {
        'status': status,
        'updated_at': datetime.now()
    }

    if metadata:
        update_data.update(metadata)

    await doc_ref.update(update_data)

Salah satu ciri unik sistem kami ialah keupayaan untuk menjana podcast berbilang suara menggunakan AI. Begini cara kami mengendalikan penjanaan skrip untuk hos yang berbeza:

{
    'user_id': 'uid_123',
    'project_id': 'proj_456',
    'podcast_id': 'pod_789',
    'file_urls': ['gs://bucket/file1.pdf'],
    'description': 'Technical blog post about cloud architecture',
    'host_count': 2,
    'action': 'CREATE_PROJECT'
}

Untuk sintesis suara, kami memetakan pembesar suara yang berbeza kepada suara Azure tertentu:

import azure.cognitiveservices.speech as speechsdk
from pathlib import Path

class SpeechGenerator:
    def __init__(self):
        self.speech_config = speechsdk.SpeechConfig(
            subscription=os.getenv("AZURE_SPEECH_KEY"),
            region=os.getenv("AZURE_SPEECH_REGION")
        )

    async def create_speech_segment(self, text, voice, output_file):
        try:
            self.speech_config.speech_synthesis_voice_name = voice
            synthesizer = speechsdk.SpeechSynthesizer(
                speech_config=self.speech_config,
                audio_config=None
            )

            # Generate speech from text
            result = synthesizer.speak_text_async(text).get()

            if result.reason == speechsdk.ResultReason.SynthesizingAudioCompleted:
                with open(output_file, "wb") as audio_file:
                    audio_file.write(result.audio_data)
                return True

            return False

        except Exception as e:
            logger.error(f"Speech synthesis failed: {str(e)}")
            return False

5. Pekerja Pemprosesan Latar Belakang

Komponen pekerja mengendalikan pengangkatan berat:

1. Analisis Dokumen

   • Ekstrak teks daripada pelbagai format dokumen
   • Analisis struktur dan kandungan dokumen
   • Kenal pasti topik dan bahagian utama

2. Pemprosesan Kandungan

   • Jana aliran perbualan semula jadi
   • Pisah kandungan kepada segmen pembesar suara
   • Buat peralihan antara topik

3. Penjanaan Audio

   • Tukar teks kepada pertuturan menggunakan suara saraf Azure
   • Kendalikan berbilang suara pembesar suara
   • Gunakan pemprosesan pasca audio

Berikut ialah pandangan ringkas tentang logik pekerja kami:

async def generate_podcast_script(outline: str, analysis: str, host_count: int):
    # System instructions for different podcast formats
    system_instructions = TWO_HOST_SYSTEM_PROMPT if host_count > 1 else ONE_HOST_SYSTEM_PROMPT

    # Example of how we structure the AI conversation
    if host_count > 1:
        script_format = """
        **Alex**: "Hello and welcome to MyPodify! I'm your host Alex, joined by..."
        **Jane**: "Hi everyone! I'm Jane, and today we're diving into {topic}..."
        """
    else:
        script_format = """
        **Alex**: "Welcome to MyPodify! Today we're exploring {topic}..."
        """

    # Generate the complete script using AI
    script = await generate_content_from_openai(
        content=f"{outline}\n\nContent Details:{analysis}",
        system_instructions=system_instructions,
        purpose="Podcast Script"
    )

    return script

Pengendalian Ralat dan Kebolehpercayaan

Sistem melaksanakan pengendalian ralat menyeluruh:

1. Cuba semula Logik

   • Penyingkiran eksponen untuk panggilan API yang gagal
   • Konfigurasi percubaan cuba semula maksimum
   • Barisan surat mati untuk mesej gagal

2. Penjejakan Status

   • Mesej ralat terperinci disimpan dalam Firestore
   • Kemas kini status masa nyata kepada pengguna
   • Ralat pengagregatan untuk pemantauan

3. Pembersihan Sumber

   • Pemadaman fail sementara automatik
   • Pembersihan muat naik yang gagal
   • Pengesanan sumber yatim piatu

Penskalaan dan Pengoptimuman Prestasi

Untuk mengendalikan beban pengeluaran, kami telah melaksanakan beberapa pengoptimuman:

1. Penskalaan Pekerja

   • Penskalaan mendatar berdasarkan panjang baris gilir
   • Penskalaan automatik berasaskan sumber
   • Pengaturan serantau untuk kependaman yang lebih rendah

2. Pengoptimuman Storan

   • Penyahduplikasi kandungan
   • Storan audio termampat
   • Penyepaduan CDN untuk penghantaran

3. Pengoptimuman Pemprosesan

   • Pemprosesan kelompok untuk dokumen yang serupa
   • Caching untuk kandungan berulang
   • Pemprosesan selari jika boleh

Pemantauan dan Kebolehmerhatian

Sistem ini termasuk pemantauan menyeluruh:

@app.post('/upload')
async def upload_files(
    token: Annotated[ParsedToken, Depends(verify_firebase_token)],
    project_name: str,
    description: str,
    website_link: str,
    host_count: int,
    files: Optional[List[UploadFile]] = File(None)
):
    # Validate token
    user_id = token['uid']

    # Generate unique identifiers
    project_id = str(uuid.uuid4())
    podcast_id = str(uuid.uuid4())

    # Process and store files
    file_urls = await process_uploads(files, user_id, project_id)

    # Create Firestore document
    await create_project_document(user_id, project_id, {
        'status': 'pending',
        'created_at': datetime.now(),
        'project_name': project_name,
        'description': description,
        'file_urls': file_urls
    })

    # Trigger async processing
    await publish_to_pubsub(user_id, project_id, podcast_id, file_urls)

    return {'project_id': project_id, 'status': 'processing'}

Penambahbaikan Masa Depan

Walaupun sistem semasa berfungsi dengan baik, terdapat beberapa kemungkinan menarik untuk penambahbaikan pada masa hadapan:

1. Pemprosesan Audio Dipertingkat

   • Penyatuan muzik latar belakang
   • Kesan audio lanjutan
   • Latihan suara tersuai

2. Peningkatan Kandungan

   • Penanda bab automatik
   • Transkrip interaktif
   • Sokongan berbilang bahasa

3. Penyatuan Platform

   • Penerbitan platform podcast langsung
   • Penjanaan suapan RSS
   • Perkongsian media sosial

---

Membina penukar dokumen-ke-podcast telah menjadi satu perjalanan yang menarik ke dalam seni bina awan moden. Gabungan perkhidmatan FastAPI, Firebase, Google Cloud Pub/Sub dan Azure's Text-to-Speech menyediakan asas yang kukuh untuk mengendalikan pemprosesan dokumen yang kompleks pada skala.

Seni bina dipacu peristiwa memastikan sistem kekal responsif di bawah beban, manakala penggunaan perkhidmatan terurus mengurangkan overhed operasi. Sama ada anda sedang membina sistem yang serupa atau hanya meneroka seni bina asli awan, saya harap penyelaman mendalam ini telah memberikan cerapan berharga dalam membina aplikasi yang boleh skala dan sedia pengeluaran.

---

Ingin mengetahui lebih lanjut tentang seni bina awan dan pembangunan aplikasi moden? Ikuti saya untuk lebih banyak tutorial teknikal dan praktikal.

Atas ialah kandungan terperinci Cara Membina Google NotebookLM anda sendiri. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!