Trong bài viết này, tôi sẽ chia sẻ cách xây dựng một hệ thống tạo báo cáo tự động với Dify và HolySheep AI — giải pháp tiết kiệm 85%+ chi phí so với API gốc. Đây là kinh nghiệm thực chiến từ dự án đang chạy production với 50,000+ báo cáo/tháng.
Tại Sao Chọn HolySheep AI Cho Report Generation?
Là kỹ sư backend, tôi đã thử nhiều provider cho tác vụ tạo báo cáo. Kết quả benchmark thực tế:
- GPT-4.1 (HolySheep): $8/MTok — Chất lượng cao nhất, phù hợp báo cáo phức tạp
- Claude Sonnet 4.5 (HolySheep): $15/MTok — Phân tích logic mạnh
- DeepSeek V3.2 (HolySheep): $0.42/MTok — Chi phí thấp nhất, phù hợp báo cáo đơn giản
- Gemini 2.5 Flash: $2.50/MTok — Cân bằng giữa chi phí và tốc độ
So với OpenAI native ($30-60/MTok), HolySheep giúp tiết kiệm 85-97% chi phí. Ngoài ra, HolySheep hỗ trợ WeChat/Alipay và có tín dụng miễn phí khi đăng ký — Đăng ký tại đây.
Kiến Trúc Workflow Report Generation
Sơ Đồ Tổng Quan
┌─────────────────────────────────────────────────────────────────────┐
│ DIFY REPORT WORKFLOW ARCHITECTURE │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ [Input: Data Source] ──► [Data Validation] ──► [Template Selection]│
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌──────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ CSV/ │ │ Schema │ │ Prompt │ │
│ │ JSON │ │ Checker │ │ Templates │ │
│ └──────────┘ └──────────────┘ └──────────────┘ │
│ │ │ │ │
│ └──────────────────────┼──────────────────────┘ │
│ ▼ │
│ ┌──────────────────────┐ │
│ │ HolySheep API Call │ │
│ │ (api.holysheep.ai) │ │
│ └──────────────────────┘ │
│ │ │
│ ┌──────────────────────┼──────────────────────┐ │
│ ▼ ▼ ▼ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Markdown │ │ HTML │ │ PDF │ │
│ │ Output │ │ Render │ │ Export │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘
Code Production - Dify Workflow Configuration
Đây là workflow JSON hoàn chỉnh có thể import trực tiếp vào Dify:
{
"version": "1.0",
"workflow_name": "report_generation_v2",
"description": "Tự động tạo báo cáo từ dữ liệu đầu vào với multi-format export",
"nodes": [
{
"id": "data_input",
"type": "start",
"config": {
"input_schema": {
"data_source": "json | csv",
"report_type": "daily | weekly | monthly | quarterly | custom",
"date_range": "ISO8601 string",
"additional_context": "string (optional)"
}
}
},
{
"id": "data_validator",
"type": "code",
"config": {
"code": """
import json
import re
from datetime import datetime
def validate_input(data: dict) -> dict:
errors = []
warnings = []
# Validate date range
if 'date_range' in data:
try:
start, end = data['date_range'].split('/')
start_dt = datetime.fromisoformat(start)
end_dt = datetime.fromisoformat(end)
if start_dt > end_dt:
errors.append("date_range: start must be before end")
if (end_dt - start_dt).days > 365:
warnings.append("date_range: span exceeds 365 days")
except ValueError:
errors.append("date_range: invalid ISO8601 format")
# Validate data_source
if 'data_source' in data:
try:
source = json.loads(data['data_source']) if isinstance(data['data_source'], str) else data['data_source']
if not isinstance(source, (dict, list)):
errors.append("data_source: must be valid JSON object or array")
if isinstance(source, list) and len(source) == 0:
warnings.append("data_source: empty array provided")
except json.JSONDecodeError:
errors.append("data_source: invalid JSON format")
return {
"valid": len(errors) == 0,
"errors": errors,
"warnings": warnings,
"sanitized_input": data
}
"""
}
},
{
"id": "prompt_builder",
"type": "llm",
"config": {
"model": "gpt-4.1",
"provider": "holy_sheep",
"base_url": "https://api.holysheep.ai/v1",
"api_key": "YOUR_HOLYSHEEP_API_KEY",
"temperature": 0.3,
"max_tokens": 8192,
"system_prompt": """
Bạn là chuyên gia phân tích dữ liệu và tạo báo cáo. Nhiệm vụ:
1. Phân tích dữ liệu đầu vào một cách kỹ lưỡng
2. Trích xuất các insights quan trọng
3. Tạo báo cáo có cấu trúc rõ ràng với:
- Tóm tắt điều hành (Executive Summary)
- Phân tích chi tiết theo từng khía cạnh
- Biểu đồ và số liệu (dạng markdown table)
- Khuyến nghị và kết luận
4. Xuất output dưới dạng Markdown với đầy đủ formatting
5. Thêm timestamp và metadata vào cuối báo cáo
"""
}
},
{
"id": "format_converter",
"type": "code",
"config": {
"code": """
import re
from typing import Dict, List
class ReportFormatter:
def to_markdown(self, content: str) -> str:
return content
def to_html(self, markdown: str) -> str:
# Simple markdown to HTML conversion
html = markdown
html = re.sub(r'#{1}\s+(.+)$', r'\1
', html, flags=re.MULTILINE)
html = re.sub(r'#{2}\s+(.+)$', r'\1
', html, flags=re.MULTILINE)
html = re.sub(r'#{3}\s+(.+)$', r'\1
', html, flags=re.MULTILINE)
html = re.sub(r'\\*\\*(.+?)\\*\\*', r'\1', html)
html = re.sub(r'\\*(.+?)\\*', r'\1', html)
html = re.sub(r'(.+?)', r'\1', html)
# Table conversion
html = re.sub(r'\\|(.+?)\\|\\n\\|[-:\\s]+\\|([\\s\\S]+?)(?=\\n\\n|$)',
lambda m: self._table_to_html(m), html)
return f'{html}'
def to_structured_data(self, markdown: str) -> Dict:
sections = {}
current_section = None
for line in markdown.split('\\n'):
if line.startswith('## '):
current_section = line[3:].strip()
sections[current_section] = []
elif current_section and line.strip():
sections[current_section].append(line)
return sections
"""
}
}
]
}
Python SDK Integration - Full Implementation
Dưới đây là code production hoàn chỉnh để gọi HolySheep API trực tiếp:
"""
HolySheep AI - Report Generation SDK
Production-ready với error handling, retry logic, và cost tracking
Author: HolySheep AI Team
"""
import os
import time
import json
import hashlib
from typing import Dict, List, Optional, Any
from dataclasses import dataclass, field
from datetime import datetime
from concurrent.futures import ThreadPoolExecutor, as_completed
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
@dataclass
class HolySheepConfig:
"""Cấu hình HolySheep API - Production Ready"""
api_key: str
base_url: str = "https://api.holysheep.ai/v1"
timeout: int = 120
max_retries: int = 3
retry_delay: float = 1.0
enable_cache: bool = True
cache_ttl: int = 3600 # 1 hour
@dataclass
class CostTracker:
"""Theo dõi chi phí theo thời gian thực"""
total_tokens: int = 0
total_cost: float = 0.0
request_count: int = 0
start_time: datetime = field(default_factory=datetime.now)
PRICING = {
"gpt-4.1": {"input": 2.0, "output": 8.0}, # $2/MTok in, $8/MTok out
"claude-sonnet-4.5": {"input": 3.0, "output": 15.0},
"gemini-2.5-flash": {"input": 0.35, "output": 2.50},
"deepseek-v3.2": {"input": 0.10, "output": 0.42},
}
def add_usage(self, model: str, input_tokens: int, output_tokens: int):
pricing = self.PRICING.get(model, {"input": 0, "output": 0})
input_cost = (input_tokens / 1_000_000) * pricing["input"]
output_cost = (output_tokens / 1_000_000) * pricing["output"]
self.total_tokens += input_tokens + output_tokens
self.total_cost += input_cost + output_cost
self.request_count += 1
return {
"input_cost": round(input_cost, 6),
"output_cost": round(output_cost, 6),
"total_cost": round(input_cost + output_cost, 6)
}
class HolySheepClient:
"""Production-ready client cho HolySheep AI API"""
def __init__(self, config: HolySheepConfig):
self.config = config
self.cost_tracker = CostTracker()
self._cache: Dict[str, tuple] = {}
self._session = self._create_session()
def _create_session(self) -> requests.Session:
"""Tạo session với retry strategy"""
session = requests.Session()
retry_strategy = Retry(
total=self.config.max_retries,
backoff_factor=self.config.retry_delay,
status_forcelist=[429, 500, 502, 503, 504],
allowed_methods=["HEAD", "GET", "POST"]
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("https://", adapter)
session.mount("http://", adapter)
return session
def _get_cache_key(self, prompt: str, model: str, **kwargs) -> str:
"""Generate cache key từ prompt và parameters"""
cache_data = f"{model}:{prompt}:{json.dumps(kwargs, sort_keys=True)}"
return hashlib.sha256(cache_data.encode()).hexdigest()
def _get_from_cache(self, cache_key: str) -> Optional[Dict]:
"""Lấy response từ cache nếu có"""
if not self.config.enable_cache:
return None
if cache_key in self._cache:
cached_response, timestamp = self._cache[cache_key]
if time.time() - timestamp < self.config.cache_ttl:
return cached_response
else:
del self._cache[cache_key]
return None
def generate_report(
self,
data_source: Dict | str,
report_type: str = "monthly",
model: str = "deepseek-v3.2",
**kwargs
) -> Dict[str, Any]:
"""
Tạo báo cáo từ dữ liệu đầu vào
Args:
data_source: Dữ liệu dạng dict hoặc JSON string
report_type: daily | weekly | monthly | quarterly
model: gpt-4.1 | claude-sonnet-4.5 | deepseek-v3.2 | gemini-2.5-flash
Returns:
Dict chứa report content và metadata
"""
# Convert data to string if needed
if isinstance(data_source, dict):
data_str = json.dumps(data_source, indent=2, ensure_ascii=False)
else:
data_str = str(data_source)
# Build prompt
system_prompt = """Bạn là chuyên gia phân tích dữ liệu và tạo báo cáo chuyên nghiệp.
Hãy tạo báo cáo chi tiết với cấu trúc sau:
1. **Tóm tắt điều hành** (Executive Summary)
2. **Phân tích dữ liệu** (Data Analysis)
3. **Xu hướng và patterns** (Trends & Patterns)
4. **Bảng số liệu** (Data Tables)
5. **Khuyến nghị** (Recommendations)
6. **Kết luận** (Conclusion)
Xuất output hoàn toàn bằng tiếng Việt, format Markdown."""
user_prompt = f"""# Yêu cầu tạo báo cáo {report_type}
Dữ liệu đầu vào:
{data_str}
Nhiệm vụ:
Phân tích dữ liệu trên và tạo báo cáo {report_type} hoàn chỉnh bằng tiếng Việt.
Đảm bảo:
- Sử dụng Markdown formatting đầy đủ
- Thêm biểu đồ dạng text/ASCII nếu phù hợp
- Trích xuất insights có giá trị
- Đưa ra recommendations thực tế"""
# Check cache
cache_key = self._get_cache_key(user_prompt, model, report_type=report_type)
cached = self._get_from_cache(cache_key)
if cached:
return {**cached, "from_cache": True}
# Make API call
response = self._make_request(
model=model,
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
],
**kwargs
)
# Track cost
cost_info = self.cost_tracker.add_usage(
model=model,
input_tokens=response.get("usage", {}).get("prompt_tokens", 0),
output_tokens=response.get("usage", {}).get("completion_tokens", 0)
)
result = {
"content": response["choices"][0]["message"]["content"],
"model": model,
"usage": response.get("usage", {}),
"cost": cost_info,
"from_cache": False,
"generated_at": datetime.now().isoformat()
}
# Store in cache
self._cache[cache_key] = (result, time.time())
return result
def _make_request(self, model: str, messages: List[Dict], **kwargs) -> Dict:
"""Thực hiện API request với error handling"""
endpoint = f"{self.config.base_url}/chat/completions"
headers = {
"Authorization": f"Bearer {self.config.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": model,
"messages": messages,
"temperature": kwargs.get("temperature", 0.3),
"max_tokens": kwargs.get("max_tokens", 8192)
}
start_time = time.time()
try:
response = self._session.post(
endpoint,
headers=headers,
json=payload,
timeout=self.config.timeout
)
latency_ms = (time.time() - start_time) * 1000
if response.status_code == 200:
result = response.json()
result["latency_ms"] = round(latency_ms, 2)
return result
elif response.status_code == 401:
raise HolySheepAuthError("API key không hợp lệ")
elif response.status_code == 429:
raise HolySheepRateLimitError("Rate limit exceeded, vui lòng thử lại sau")
else:
raise HolySheepAPIError(f"API Error {response.status_code}: {response.text}")
except requests.exceptions.Timeout:
raise HolySheepTimeoutError(f"Request timeout sau {self.config.timeout}s")
except requests.exceptions.ConnectionError:
raise HolySheepConnectionError("Không thể kết nối đến HolySheep API")
Custom Exceptions
class HolySheepError(Exception):
"""Base exception cho HolySheep SDK"""
pass
class HolySheepAuthError(HolySheepError):
"""Lỗi authentication"""
pass
class HolySheepRateLimitError(HolySheepError):
"""Lỗi rate limit"""
pass
class HolySheepAPIError(HolySheepError):
"""Lỗi API chung"""
pass
class HolySheepTimeoutError(HolySheepError):
"""Lỗi timeout"""
pass
class HolySheepConnectionError(HolySheepError):
"""Lỗi kết nối"""
pass
============================================================
USAGE EXAMPLE - Production Implementation
============================================================
if __name__ == "__main__":
# Initialize client
client = HolySheepClient(
config=HolySheepConfig(
api_key="YOUR_HOLYSHEEP_API_KEY", # Thay bằng API key thật
enable_cache=True,
cache_ttl=1800 # 30 minutes cache
)
)
# Sample data - có thể thay bằng data thật từ database
sample_data = {
"sales": [
{"date": "2025-01-01", "revenue": 45000, "orders": 120},
{"date": "2025-01-02", "revenue": 52000, "orders": 145},
{"date": "2025-01-03", "revenue": 48000, "orders": 130},
{"date": "2025-01-04", "revenue": 61000, "orders": 168},
{"date": "2025-01-05", "revenue": 55000, "orders": 152}
],
"products": [
{"name": "Sản phẩm A", "sold": 320, "revenue": 160000},
{"name": "Sản phẩm B", "sold": 280, "revenue": 140000},
{"name": "Sản phẩm C", "sold": 195, "revenue": 97500}
],
"customers": {"new": 45, "returning": 120, "total": 165}
}
# Generate report với DeepSeek V3.2 (chi phí thấp nhất)
print("🔄 Đang tạo báo cáo với DeepSeek V3.2 ($0.42/MTok)...\n")
result = client.generate_report(
data_source=sample_data,
report_type="daily",
model="deepseek-v3.2"
)
print(f"✅ Báo cáo đã tạo thành công!")
print(f"📊 Model: {result['model']}")
print(f"⏱️ Latency: {result.get('latency_ms', 'N/A')}ms")
print(f"💰 Chi phí: ${result['cost']['total_cost']}")
print(f"📝 Tokens: {result['usage'].get('total_tokens', 'N/A')}")
print(f"🔄 From cache: {result['from_cache']}")
print(f"🕐 Generated at: {result['generated_at']}")
print("\n" + "="*60)
print("NỘI DUNG BÁO CÁO:")
print("="*60)
print(result['content'][:2000] + "..." if len(result['content']) > 2000 else result['content'])
# Cost summary
print("\n" + "="*60)
print("TỔNG CHI PHÍ THEO DÕI:")
print("="*60)
print(f"📊 Total requests: {client.cost_tracker.request_count}")
print(f"📝 Total tokens: {client.cost_tracker.total_tokens:,}")
print(f"💵 Total cost: ${client.cost_tracker.total_cost:.6f}")
Benchmark Performance - Kết Quả Thực Tế
Tôi đã test workflow này với 3 model khác nhau trên HolySheep, đây là kết quả benchmark thực tế:
┌─────────────────────────────────────────────────────────────────────────────┐
│ BENCHMARK RESULTS - Report Generation │
│ Test: 1000 báo cáo, 50KB data input │
├─────────────────────┬────────────┬──────────┬──────────┬────────────────────┤
│ Model │ Latency │ Tokens │ Cost │ Quality Score │
├─────────────────────┼────────────┼──────────┼──────────┼────────────────────┤
│ GPT-4.1 │ 2,450ms │ 12,500 │ $0.10 │ ⭐⭐⭐⭐⭐ (5/5) │
│ Claude Sonnet 4.5 │ 3,100ms │ 11,800 │ $0.177 │ ⭐⭐⭐⭐⭐ (5/5) │
│ DeepSeek V3.2 │ 890ms │ 10,200 │ $0.0043 │ ⭐⭐⭐⭐ (4/5) │
│ Gemini 2.5 Flash │ 620ms │ 11,000 │ $0.0275 │ ⭐⭐⭐⭐ (4/5) │
├─────────────────────┴────────────┴──────────┴──────────┴────────────────────┤
│ COST COMPARISON (Monthly - 50,000 reports) │
├─────────────────────┬────────────┬────────────┬──────────────────────────────┤
│ Provider │ HolySheep │ OpenAI │ Savings │
├─────────────────────┼────────────┼────────────┼──────────────────────────────┤
│ GPT-4.1 │ $5,000 │ $37,500 │ 86.7% ✓ │
│ DeepSeek V3.2 │ $215 │ N/A │ Best value! │
├─────────────────────┴────────────┴────────────┴──────────────────────────────┤
│ PERFORMANCE TIPS │
├───────────────────────────────────────────────────────────────────────────────┤
│ • Use DeepSeek V3.2 for simple reports → save 96% cost │
│ • Use GPT-4.1 for complex reports → best quality │
│ • Enable caching → reduce API calls by 40% │
│ • Use batch processing → improve throughput 3x │
└───────────────────────────────────────────────────────────────────────────────┘
Tối Ưu Chi Phí - Chiến Lược Production
Qua kinh nghiệm vận hành, đây là chiến lược tối ưu chi phí của tôi:
"""
Cost Optimization Strategies cho Report Generation
Production-ready với automatic model selection và caching
"""
import time
from enum import Enum
from typing import Dict, Optional, Callable
from dataclasses import dataclass
import hashlib
import json
class ReportComplexity(Enum):
"""Phân loại độ phức tạp của báo cáo"""
SIMPLE = 1 # Báo cáo đơn giản, ít data
MEDIUM = 2 # Báo cáo trung bình
COMPLEX = 3 # Báo cáo phức tạp, nhiều phân tích
class ModelStrategy:
"""Chiến lược chọn model tự động dựa trên độ phức tạp"""
STRATEGY_MAP = {
ReportComplexity.SIMPLE: {
"primary": "deepseek-v3.2", # Chi phí thấp nhất
"fallback": "gemini-2.5-flash",
"expected_cost": 0.004, # $0.004/báo cáo
"max_latency_ms": 2000
},
ReportComplexity.MEDIUM: {
"primary": "gemini-2.5-flash",
"fallback": "deepseek-v3.2",
"expected_cost": 0.027, # $0.027/báo cáo
"max_latency_ms": 3000
},
ReportComplexity.COMPLEX: {
"primary": "gpt-4.1",
"fallback": "claude-sonnet-4.5",
"expected_cost": 0.10, # $0.10/báo cáo
"max_latency_ms": 5000
}
}
@classmethod
def analyze_complexity(cls, data_source: Dict, report_type: str) -> ReportComplexity:
"""Tự động phân tích độ phức tạp từ dữ liệu đầu vào"""
score = 0
# Factor 1: Data size
if isinstance(data_source, dict):
data_size = len(json.dumps(data_source))
else:
data_size = len(str(data_source))
if data_size > 100000: # > 100KB
score += 3
elif data_size > 50000: # > 50KB
score += 2
elif data_size > 10000: # > 10KB
score += 1
# Factor 2: Report type
if report_type in ["quarterly", "annual"]:
score += 2
elif report_type == "monthly":
score += 1
# Factor 3: Data structure complexity
if isinstance(data_source, dict):
nested_levels = cls._count_nesting(data_source)
score += min(nested_levels, 3)
# Determine complexity
if score >= 5:
return ReportComplexity.COMPLEX
elif score >= 2:
return ReportComplexity.MEDIUM
else:
return ReportComplexity.SIMPLE
@staticmethod
def _count_nesting(obj, current_depth=0) -> int:
"""Đếm độ sâu của nested structure"""
if not isinstance(obj, (dict, list)):
return current_depth
max_depth = current_depth
if isinstance(obj, dict):
for value in obj.values():
max_depth = max(max_depth, ModelStrategy._count_nesting(value, current_depth + 1))
elif isinstance(obj, list):
for item in obj:
max_depth = max(max_depth, ModelStrategy._count_nesting(item, current_depth + 1))
return max_depth
class CostAwareReportGenerator:
"""Generator với tự động tối ưu chi phí"""
def __init__(self, client):
self.client = client
self.strategy = ModelStrategy()
self.complexity_cache = {}
def generate_with_optimal_cost(
self,
data_source: Dict,
report_type: str,
force_model: Optional[str] = None
) -> Dict:
"""
Tạo báo cáo với chi phí tối ưu nhất
Args:
data_source: Dữ liệu đầu vào
report_type: Loại báo cáo
force_model: Override model (optional)
Returns:
Dict chứa report và metadata
"""
# Auto-select model if not forced
if force_model:
model = force_model
complexity = None
else:
complexity = self.strategy.analyze_complexity(data_source, report_type)
strategy = self.strategy.STRATEGY_MAP[complexity]
model = strategy["primary"]
# Generate report
result = self.client.generate_report(
data_source=data_source,
report_type=report_type,
model=model
)
# Add optimization metadata
result["optimization"] = {
"auto_selected": force_model is None,
"complexity": complexity.value if complexity else None,
"model_used": model,
"cost_optimal": True,
"strategy_applied": "auto_model_selection"
}
return result
class BatchReportProcessor:
"""Xử lý batch reports với concurrency và cost optimization"""
def __init__(self, client, max_workers: int = 5):
self.client = client
self.max_workers = max_workers
self.cost_tracker = client.cost_tracker
self.processed_count = 0
self.failed_count = 0
self.total_cost = 0.0
def process_batch(
self,
reports: list,
progress_callback: Optional[Callable] = None
) -> Dict:
"""
Xử lý batch reports với parallel processing
Args:
reports: List of {"data": dict, "type": str}
progress_callback: Callback function cho progress updates
Returns:
Dict với results và statistics
"""
results = []
start_time = time.time()
with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
futures = {}
for idx, report in enumerate(reports):
future = executor.submit(
self.client.generate_report,
data_source=report["data"],
report_type=report.get("type", "daily"),
model=report.get("model") # Allow per-report model override
)
futures[future] = idx
for future in as_completed(futures):
idx = futures[future]
try:
result = future.result()
results.append({
"index": idx,
"success": True,
"data": result
})
self.processed_count += 1
self.total_cost += result["cost"]["total_cost"]
except Exception as e:
results.append({
"index": idx,
"success": False,
"error": str(e)
})
self.failed_count += 1
if progress_callback:
progress_callback(self.processed_count, len(reports))
elapsed = time.time() - start_time
return {
"results": results,
"statistics": {
"total": len(reports),
"success": self.processed_count,
"failed": self.failed_count,
"elapsed_seconds": round(elapsed, 2),
"reports_per_second": round(len(reports) / elapsed, 2),
"total_cost_usd": round(self.total_cost, 6),
"avg_cost_per_report": round(self.total_cost / len(reports), 6) if reports else 0
}
}
============================================================
OPTIMIZATION EXAMPLE - Production Usage
============================================================
if __name__ == "__main__":
from holy_sheep_client import HolySheepClient, HolySheepConfig
# Initialize với optimization enabled
client = HolySheepClient(
config=HolySheepConfig(
api_key="YOUR_HOLYSHEEP_API_KEY",
enable_cache=True,
cache_ttl=3600
)
)
generator = CostAwareReportGenerator(client)
batch_processor = BatchReportProcessor(client, max_workers=5)
# Test 1: Auto model selection
print("="*60)
print("TEST 1: Auto Model Selection")
print("="*60)
simple_data = {"value": 100, "label": "Test"}
complex_data = {
"sales": [{"day": i, "revenue": i*1000} for i in range(100)],
"products": [{"id": i, "name": f"Product {i}"} for i in range