Agent Run:Bangun pakar analisis opini publik menggunakan AgentRun

Persiapan

Sebelum memulai, lengkapi persiapan berikut:

1. Aktifkan layanan Alibaba Cloud dan berikan izin:

   • Pastikan Anda memiliki Akun Alibaba Cloud.

   • Akses dan aktifkan layanan berikut. Saat pertama kali mengakses layanan ini, ikuti petunjuk di layar untuk menyelesaikan aktivasi layanan dan otorisasi peran RAM.

     • Function Compute (FC)

     • AgentRun

2. Dapatkan kredensial akses model (Kunci API):

   • Aplikasi ini bergantung pada large language model untuk memahami percakapan. Masuk ke Konsol Model Studio, lalu di halaman Key Management, buat atau salin Kunci API. Anda akan memerlukan kunci ini untuk langkah selanjutnya.

3. Anda dapat membuat Large Language Model (LLM) di Model Management.

   Contoh berikut mengonfigurasi model qwen3-max di Model Studio. Untuk informasi lebih lanjut tentang konfigurasi model lain atau model kustom, lihat Large language models.

   • Di halaman Model Management, klik Add Model.

   • Pilih API Model dan konfigurasikan parameter berikut:

     • Name: qwen3-model.

     • Untuk Service provider, pilih Alibaba Cloud dari daftar drop-down.

     • API destination: Pertahankan nilai default.

     • Specific model: Cari dan pilih qwen3-max.

     • Credential management: Pilih API key dan tempel Model Studio API key yang diperoleh pada langkah sebelumnya. Atau, pilih Use existing credential dan pilih kredensial yang telah dikonfigurasi dari daftar drop-down. Untuk informasi lebih lanjut, lihat Credential management.

4. Buat instans sandbox browser di Sandbox.

   Contoh berikut menggunakan konfigurasi cepat di konsol. Untuk informasi lebih lanjut tentang parameter spesifik atau cara menggunakan API sandbox, lihat BrowserTool browser.

   • Buka halaman Sandbox dan klik tombol Create Sandbox Template.

   • Pilih Browser dan klik Create Now. Di halaman konfigurasi, masukkan parameter berikut dan biarkan semua parameter lain tetap pada nilai default:

     • Name: sandbox-in-opinion_analysis.

     • Execution role ARN: AliyunAgentRunDefaultRole.

   • Klik Create Browser dan tunggu hingga sandbox selesai dibuat.

Pilih templat dan deploy

1. Di Konsol AgentRun, klik Agent Template di bagian atas halaman. Dari daftar templat agen populer, temukan Public Opinion Analysis Expert dan klik Deploy. Anda juga dapat mengklik Details pada kartu untuk melihat ikhtisar templat.

2. Di halaman deployment, konfigurasikan parameter seperti pada contoh berikut:

   • Application name: Masukkan nama deskriptif untuk aplikasi, misalnya opinion_analysis.

   • Description (optional): Jelaskan secara singkat fungsi aplikasi, misalnya Agent created from the Public Opinion Analysis Expert template.

   • Permission configuration: Berikan otorisasi kepada aplikasi AgentRun untuk mengakses resource cloud seperti model dan tool.

     • (Direkomendasikan) Klik Quick Create. Sistem akan membuat peran default bernama AliyunAgentRunDefaultRole dengan semua izin yang diperlukan.

     • Untuk menyesuaikan izin secara manual, klik tombol Add di samping daftar drop-down, lalu klik Create Role untuk mengonfigurasi peran secara manual. Lampirkan kebijakan akses yang sesuai. Untuk informasi lebih lanjut, lihat Configure execution roles as needed.

   • Large language model: Dari daftar drop-down, pilih qwen3-model yang telah Anda konfigurasi, lalu pilih model qwen3-max. Jika belum dikonfigurasi, klik tombol add di samping daftar drop-down dan ikuti langkah 3 di Persiapan.

   • Browser Sandbox: Dari daftar drop-down, pilih sandbox-in-opinion_analysis yang baru saja Anda konfigurasi. Jika belum dikonfigurasi, klik tombol add di samping daftar drop-down dan ikuti langkah 4 di Persiapan untuk segera mengonfigurasinya.

   • Klik Confirm Creation dan tunggu hingga deployment selesai.

   • Setelah deployment berhasil, tautan akses untuk aplikasi Anda akan ditampilkan. Klik tautan tersebut untuk membuka WebUI. Atau, Anda dapat menemukan aplikasi di Konsol Agent. Klik Details dan temukan titik akhir di bawah Integration Configuration di sisi kanan halaman Overview and Configuration.

Coba aplikasi

1. Di Web UI aplikasi, Anda akan melihat antarmuka sistem analisis opini publik. Masukkan kata kunci atau topik untuk memulai analisis. Misalnya, Anda dapat memasukkan new energy vehicles. Selama analisis, sistem memanggil sandbox browser sandbox-in-opinion_analysis yang telah Anda konfigurasi, dan AI mengontrol browser berbasis cloud untuk mengambil data.

2. Setelah analisis selesai, sistem mengorganisasi data yang dikumpulkan dan menghasilkan laporan visual yang menggabungkan teks dan grafik.

Lihat detail aplikasi

Setelah aplikasi di-deploy, Anda dapat mengelola serta melakukan operasi dan pemeliharaan (O&M) di Konsol AgentRun. Di daftar aplikasi, temukan aplikasi yang Anda buat dan klik namanya untuk membuka halaman Details. Panel navigasi di sebelah kiri menyediakan fitur inti berikut:

• Overview and Configuration: Lihat informasi dasar aplikasi dan konfigurasi runtime, seperti model dan spesifikasi memori. Anda juga dapat mengelola variabel lingkungan di halaman ini.

• Code and Debugging: Lihat, edit, dan debug kode secara online. Anda juga dapat melakukan pengembangan kustom secara online.

• Versions and Phased Releases: Gunakan fitur kontrol versi. Anda dapat menggunakan rilis bertahap untuk mengalihkan sebagian kecil trafik ke versi baru untuk pengujian sebelum rilis penuh. Setiap versi memiliki nama domain sementara untuk pengujian.

• Integration and Publishing: Integrasikan agen yang dikembangkan ke halaman web frontend, aplikasi backend, atau layanan lainnya. Untuk informasi lebih lanjut, lihat Agent integration and publishing.

• Elasticity and Instances: Lihat daftar dan status instans yang sedang berjalan. Anda dapat mengonfigurasi kebijakan Auto Scaling fleksibel untuk secara otomatis menambah atau menghapus instans berdasarkan beban kerja bisnis.

• Observability: Integrasikan dengan Alibaba Cloud Application Real-Time Monitoring Service (ARMS) untuk mendapatkan diagnostik kinerja tingkat kode, pelacakan permintaan, pemantauan exception, dan kemampuan peringatan guna memastikan stabilitas aplikasi.

Desain arsitektur sistem

Seluruh sistem analisis opini publik menggunakan arsitektur berlapis. Prinsip intinya adalah kontrol alur eksekusi yang ketat melalui kode, bukan mengandalkan pengambilan keputusan otonom oleh LLM.

Keunggulan utama

1. Lingkungan eksekusi terisolasi secara aman

   Sistem opini publik tradisional biasanya menjalankan program crawler langsung di server, yang menimbulkan risiko keamanan dan konflik dependensi. Ketika mekanisme anti-crawling di situs web dipicu, stabilitas seluruh server dapat terganggu. AgentRun Sandbox menyediakan lingkungan browser yang sepenuhnya terisolasi. Bahkan jika satu tugas pengumpulan data gagal, sistem secara keseluruhan tetap tidak terpengaruh.

   async def create_browser_sandbox() -> Optional[BrowserSandbox]:
       """Create an isolated browser environment to avoid environmental contamination"""
       try:
           sandbox = await Sandbox.create_async(
               template_type=TemplateType.BROWSER,
               template_name=agentrun_browser_sandbox_name,
           )
           _sandboxes[sandbox.sandbox_id] = sandbox
           return sandbox
       except Exception as e:
           # Failure of a single Sandbox does not affect other instances
           raise SandboxCreationError(f"Failed to create Sandbox: {e}")

2. Simulasi lingkungan browser nyata

   Crawler tradisional sering menggunakan library permintaan HTTP sederhana, yang mudah dideteksi dan diblokir oleh situs web modern. AgentRun Sandbox menyediakan lingkungan browser Chrome nyata yang sepenuhnya mengeksekusi JavaScript dan menangani interaksi halaman kompleks, sehingga secara signifikan meningkatkan tingkat keberhasilan pengumpulan data. Seperti yang ditunjukkan dalam kode, sistem terhubung ke instans Chrome nyata menggunakan Playwright.

   async with async_playwright() as playwright:
       browser = await playwright.chromium.connect_over_cdp(sandbox.get_cdp_url())
       context = browser.contexts[0] if browser.contexts else await browser.new_context()
       page = context.pages[0] if context.pages else await context.new_page()

3. Kemampuan debugging visual

   Keunggulan unik Function Compute AgentRun adalah fitur pratinjau VNC real-time. Developer dan pengguna dapat mengamati operasi browser secara real-time. Transparansi ini, yang tidak dapat dicapai oleh solusi tradisional, membantu dalam debugging dan optimasi logika pengumpulan serta memungkinkan pengguna memahami dengan jelas status operasional sistem.

4. Skalabilitas elastis dan pemulihan kesalahan

   Sistem tradisional memerlukan arsitektur terdistribusi kompleks untuk tugas pengumpulan skala besar. Function Compute AgentRun secara native mendukung pemrosesan paralel di beberapa Sandbox. Sistem secara dinamis membuat dan menghapus instans browser sesuai kebutuhan. Lebih penting lagi, sistem secara otomatis mendeteksi dan membangun kembali instans yang gagal.

   async def recreate_sandbox_if_closed(sandbox_id: str, error_message: str):
       """Intelligent fault detection and automatic reconstruction mechanism"""
       closed_error_patterns = [
           "Target page, context or browser has been closed",
           "Browser has been closed",
           "Connection closed",
       ]
       
       is_closed_error = any(pattern.lower() in error_message.lower()
                             for pattern in closed_error_patterns)
       
       if is_closed_error:
           await remove_sandbox(sandbox_id)
           new_sandbox = await create_browser_sandbox()
           return new_sandbox

Implementasi integrasi VNC frontend

1. Mekanisme pemuatan library dinamis

   Klien VNC frontend memuat library noVNC secara dinamis. Sistem menerapkan mekanisme pemuatan cerdas yang mendukung resource lokal dengan fallback CDN.

   function loadScript(url) {
       return new Promise(function(resolve, reject) {
           var script = document.createElement('script');
           script.src = baseUrl + url;
           script.onload = resolve;
           script.onerror = function() {
               // Local loading failed, try CDN
               var fallbackUrl = url.includes('wordcloud') ?
                   'https://cdn.jsdelivr.net/npm/echarts-wordcloud@2.1.0/dist/echarts-wordcloud.min.js' :
                   'https://cdn.jsdelivr.net/npm/echarts@5.4.3/dist/echarts.min.js';
               var fallbackScript = document.createElement('script');
               fallbackScript.src = fallbackUrl;
               fallbackScript.onload = resolve;
               fallbackScript.onerror = reject;
               document.head.appendChild(fallbackScript);
           };
           document.head.appendChild(script);
       });
   }

2. Adaptasi multi-protokol

   Mengingat kompleksitas lingkungan deployment, komponen VNC menerapkan adaptasi protokol WebSocket otomatis untuk lingkungan HTTP dan HTTPS.

   import { useCallback } from 'react';
   
   const adjustWebSocketUrl = useCallback((url: string): string => {
       const isHttps = window.location.protocol === 'https:';
   
       if (!isHttps && url.startsWith('wss://')) {
           return url.replace('wss://', 'ws://');
       }
   
       if (isHttps && url.startsWith('ws://')) {
           return url.replace('ws://', 'wss://');
       }
   
       return url;
   }, []);

Implementasi inti backend

1. Desain rantai alat agen

   Inti sistem adalah agen berbasis PydanticAI yang berisi empat tool utama, masing-masing menangani fase berbeda dalam analisis opini publik. Agen mengikuti urutan eksekusi ketat untuk memastikan kelengkapan data dan akurasi analisis.

   opinion_agent = Agent(
       agentrun_model,
       deps_type=StateDeps,
       system_prompt="""You are the executor of the public opinion analysis system. Your task is to perform public opinion analysis strictly in the following sequence:
   【Process】
   1. After receiving a keyword, call the collect_data tool to gather data
   2. After data collection, call the analyze_data tool to analyze data
   3. After analysis, call the write_report tool to draft a report
   4. After report drafting, call the render_html tool to generate HTML
   
   【Important rules】
   - Call tools strictly in order
   - Call each tool only once
   - Do not skip any steps
   - Do not fabricate data""",
       retries=3,
   )

2. Keluaran streaming dan umpan balik real-time

   Sistem opini publik tradisional biasanya menggunakan pemrosesan batch, yang mengharuskan pengguna menunggu lama untuk hasilnya. Sistem berbasis Function Compute AgentRun memberikan keluaran streaming, sehingga pengguna dapat mengamati progres secara real-time. Kecepatan respons ini meningkatkan pengalaman pengguna dan memungkinkan deteksi serta penyelesaian masalah secara tepat waktu.

   import time
   
   async def push_state_event(run_id: str, state: OpinionState):
       """Push state updates in real time so users don't need to wait"""
       event = StateSnapshotEvent(
           type=EventType.STATE_SNAPSHOT,
           snapshot=state.model_dump(),
           timestamp=int(time.time() * 1000)
       )
       await event_manager.push_event(run_id, event)

3. Kontrol kualitas data cerdas

   Sistem menerapkan kontrol kualitas data ketat melalui evaluasi multidimensi untuk memastikan relevansi dan nilai tinggi dari data yang dikumpulkan. Sistem tradisional sering kali tidak memiliki kontrol kualitas semacam ini, sehingga menghasilkan data berisik yang menurunkan kualitas analisis.

   async def evaluate_relevance(keyword: str, title: str, snippet: str) -> float:
       """Multi-dimensional relevance evaluation to ensure data quality"""
       text = f"{title} {snippet}"
       text_lower = text.lower()
   
       # Detect keyword match level
       has_chinese_keyword = any('\u4e00' <= char <= '鿿' for char in keyword)
       result_has_chinese = any('\u4e00' <= char <= '鿿' for char in text)
   
       # Chinese keywords must have Chinese content in results
       if has_chinese_keyword and not result_has_chinese:
           return 0.0
   
       # Exclude clearly irrelevant sites
       irrelevant_patterns = [
           "calculator", "deepseek", "chegg", "stackoverflow",
           "translation", "dictionary", "lexicon"
       ]
       if any(pattern in text_lower for pattern in irrelevant_patterns):
           return 0.0
   
       # Calculate relevance score
       score = 0.0
       if keyword in text:
           score += 0.6  # Base score
   
       # Timeliness bonus
       time_keywords = ["latest", "today", "recently", "2024", "2025"]
       if any(tk in text for tk in time_keywords):
           score += 0.1
   
       return max(0.0, min(1.0, score))

Teknologi scraping konten mendalam

1. Strategi adaptasi spesifik platform

   Platform media sosial berbeda memiliki struktur halaman dan organisasi konten yang berbeda. Sistem tradisional sering menggunakan strategi scraping seragam, yang menghasilkan kualitas data tidak konsisten. Sistem AgentRun menerapkan logika scraping khusus untuk platform berbeda.

   async def explore_page_with_llm(page, keyword: str, url: str, source: str, initial_content: str):
       """Intelligent content scraping based on platform characteristics"""
       if "weibo.com" in url:
           # Weibo-specific comment and repost scraping
           available_actions = [
               {"action": "view_comments", "selector": ".WB_feed_expand, [class*='comment']"},
               {"action": "view_retweets", "selector": ".WB_feed_expand, [class*='repost']"},
           ]
       elif "zhihu.com" in url:
           # Zhihu answer and comment scraping
           available_actions = [
               {"action": "view_more_answers", "selector": ".AnswerItem, .List-item"},
               {"action": "view_comments", "selector": ".Comments-container, .CommentItem"},
           ]
       elif "bilibili.com" in url:
           # Bilibili video comment scraping
           available_actions = [
               {"action": "view_comments", "selector": ".reply-item, .root-reply"},
               {"action": "view_related", "selector": ".video-page-card, .recommend-list"},
           ]

2. Eksplorasi cerdas berbasis LLM

   Sistem secara inovatif memperkenalkan mekanisme eksplorasi cerdas berbasis LLM. AI menentukan apakah perlu melakukan scraping konten tambahan dari halaman, seperti komentar atau rekomendasi terkait. Pengambilan keputusan cerdas ini sangat meningkatkan efisiensi dan presisi pengumpulan data.

   import json
   
   async def llm_decide_exploration(keyword: str, page_url: str, page_content: str, source: str):
       """LLM intelligent decision on whether to perform deep exploration"""
       prompt = f"""Decide whether further page exploration is needed to obtain more public opinion data based on the following information.
   【Search keyword】{keyword}
   【Current page】{page_url}
   【Collected content preview】{page_content[:500]}
   【Decision criteria】
   1. If current content is already sufficient, further exploration may not be needed
   2. For platforms like Weibo/Bilibili, comment sections usually contain important public opinion information
   3. Balance time cost—explore at most 1–2 actions per page
   
   Return the decision result in JSON format."""
   
       result = await explorer.run(prompt)
       return json.loads(result.output)
   

Analisis cerdas dan pembuatan laporan

1. Analisis sentimen terstandarisasi

   Sistem menerapkan algoritma analisis sentimen berbasis kamus kata kunci. Dibandingkan model pembelajaran mesin tradisional, pendekatan ini lebih transparan dan terkendali.

   class SentimentStandards:
       """Standardized sentiment calculation"""
   
       POSITIVE_KEYWORDS = [
           "excellent", "outstanding", "innovative", "leading", "breakthrough", "successful", "praise", "positive review", "support",
           "recognition", "satisfied", "trust", "expectation", "optimistic", "worthwhile", "recommend", "like"
       ]
   
       NEGATIVE_KEYWORDS = [
           "poor", "terrible", "failure", "backward", "problem", "defect", "criticism", "questioning", "concern",
           "disappointment", "dissatisfaction", "complaint", "complaint", "negative review", "garbage", "scam"
       ]
   
       @staticmethod
       def calculate_sentiment_score(text: str) -> float:
           """Calculate sentiment score (-1.0 to 1.0)"""
           positive_count = sum(1 for word in SentimentStandards.POSITIVE_KEYWORDS if word in text)
           negative_count = sum(1 for word in SentimentStandards.NEGATIVE_KEYWORDS if word in text)
   
           total_count = positive_count + negative_count
           if total_count == 0:
               return 0.0
   
           return (positive_count - negative_count) / total_count

2. Pembuatan laporan streaming

   Proses pembuatan laporan menggunakan keluaran streaming. Pengguna dapat menyaksikan laporan sedang ditulis secara real-time, pengalaman yang tidak dapat diberikan oleh sistem tradisional.

   import asyncio
   
   async with writer.run_stream(report_prompt) as result:
       async for text in result.stream_text():
           report_content = text
           state.report_text = report_content
   
           current_time = asyncio.get_event_loop().time()
           content_delta = len(report_content) - last_event_length
           time_delta = current_time - last_event_time
   
           # Send an update every 100 characters or every 0.3 seconds
           if content_delta >= 100 or time_delta >= 0.3:
               await push_state_event(run_id, state)

Keunggulan deployment dan O&M

1. Proses deployment yang disederhanakan

   Dibandingkan sistem opini publik tradisional yang memerlukan deployment kluster crawler terdistribusi kompleks, deployment sistem AgentRun relatif sederhana. Anda hanya perlu mengonfigurasi variabel lingkungan dan templat AgentRun Sandbox, dan sistem secara otomatis mengelola pembuatan dan penghapusan instans browser.

   # Core configuration
   AGENTRUN_MODEL_NAME=your_model_name
   MODEL_NAME=qwen3-max
   AGENTRUN_BROWSER_SANDBOX_NAME=your_browser_template
   TIMEOUT=180

2. Kemampuan O&M otomatis

   Sistem mencakup mekanisme pemantauan dan self-healing komprehensif yang sangat mengurangi kompleksitas operasional. Saat anomali terdeteksi, sistem secara otomatis membangun kembali resource untuk menjaga kelangsungan layanan.

   import { useEffect, useRef } from 'react';
   
   // Automatically reconnect on connection failure (retry every 10 seconds)
   useEffect(() => {
       if (status === 'error' && active && rfbLoaded) {
           reconnectTimerRef.current = setTimeout(() => {
               cleanupRfb();
               lastUrlRef.current = null;
               fetchVncUrl(true);
           }, RECONNECT_INTERVAL);
       }
   }, [status, active, rfbLoaded]);

Analisis kinerja dan skalabilitas

1. Kemampuan pemrosesan konkuren

   Sistem tradisional sering kali dibatasi oleh resource mesin tunggal. Sistem Function Compute AgentRun secara dinamis membuat beberapa instans Sandbox sesuai kebutuhan, yang memungkinkan skalabilitas horizontal. Melalui pemrograman asinkron dan manajemen kolam koneksi, sistem secara efisien menangani permintaan high-concurrency.

   import uvicorn
   
   uvicorn.run(
       "main:app",
       host="0.0.0.0",
       port=8000,
       log_level="info",
       timeout_keep_alive=120,
       limit_concurrency=100,  # Supports high concurrency
   )

2. Elastic Resource Management

   Sistem menerapkan manajemen resource cerdas yang secara dinamis menyesuaikan jumlah instans Sandbox berdasarkan beban tugas. Kemampuan skalabilitas elastis ini sulit dicapai dengan arsitektur tetap tradisional.

   from typing import Any, Dict, List
   
   async def get_all_sandboxes() -> List[Dict[str, Any]]:
       """Dynamically retrieve all available Sandbox instances"""
       result = []
       async with _sandbox_lock:
           for sandbox_id, sandbox in _sandboxes.items():
               try:
                   # Check instance health status
                   vnc_url = sandbox.get_vnc_url()
                   result.append({
                       "sandbox_id": sandbox_id,
                       "vnc_url": vnc_url,
                       "active": True,
                   })
               except Exception:
                   # Automatically clean up failed instances
                   result.append({
                       "sandbox_id": sandbox_id,
                       "active": False,
                   })
       return result

Rangkuman

Sistem analisis opini publik yang dibangun di atas Function Compute AgentRun menunjukkan keunggulan signifikan dibandingkan solusi tradisional dalam hal keamanan, keandalan, observabilitas, dan skalabilitas. Sistem ini menyelesaikan titik sakit inti terkait keamanan dan konflik dependensi melalui lingkungan Sandbox terisolasi. Pratinjau VNC real-time memberikan transparansi proses yang belum pernah ada sebelumnya. Mekanisme deteksi kesalahan dan self-healing bawaan sangat mengurangi kompleksitas operasional. Yang paling penting, sistem mencapai otomatisasi end-to-end, mulai dari pengumpulan data, analisis cerdas, hingga pembuatan laporan streaming. Pengguna dapat mengamati seluruh proses analisis secara real-time, yang memberikan pengalaman jauh lebih baik dibandingkan pemrosesan batch tradisional. Kemampuan mengotomatisasi alur kerja kompleks secara tinggi, dikombinasikan dengan kemajuan AI berkelanjutan, akan sangat meningkatkan wawasan opini publik dan dukungan pengambilan keputusan bagi perusahaan dan institusi.