MiniMax M2.7 API 批量调用：Tối ưu hóa yêu cầu đồng thời bất đồng bộ Python — Playbook di chuyển từ Relay sang HolySheep AI

Thời gian đọc ước tính: 12 phút | Độ khó: Trung cấp-Nâng cao | Công nghệ: Python, asyncio, aiohttp, MiniMax M2.7

Bối cảnh và câu chuyện thực chiến

Trong dự án xử lý ngôn ngữ tự nhiên của đội ngũ tôi, chúng tôi cần gọi MiniMax M2.7 để phân tích sentiment cho khoảng 50,000 đánh giá sản phẩm mỗi ngày. Với cách gọi tuần tự truyền thống, mỗi request mất trung bình 800ms, nghĩa là cần hơn 11 giờ để xử lý toàn bộ batch. Điều này là không thể chấp nhận được khi deadline của sản phẩm chỉ còn 3 ngày.

Chúng tôi đã thử qua 3 giải pháp relay khác nhau, nhưng gặp phải:

• Rate limiting cực kỳ nghiêm ngặt (10 req/phút)
• Độ trễ trung bình >2000ms với peak hours
• Chi phí API chính hãng: $127/ngày (theo bảng giá GPT-4.1 $8/MTok)
• Không hỗ trợ thanh toán quốc tế ổn định

May mắn thay, đồng nghiệp trong team ML giới thiệu HolySheep AI — một API gateway tối ưu cho thị trường châu Á với tỷ giá ¥1 = $1 (tiết kiệm 85%+), hỗ trợ WeChat/Alipay, và độ trễ trung bình chỉ <50ms. Sau 2 tuần thực chiến, đội ngũ đã giảm thời gian xử lý từ 11 giờ xuống 23 phút và tiết kiệm $3,600/tháng. Bài viết này là playbook đầy đủ về cách tôi thực hiện cuộc di chuyển này.

Vấn đề với API tuần tự và tại sao cần bất đồng bộ

Phân tích nút thắt cổ chai

Khi gọi API theo cách tuần tự, mỗi request phải đợi request trước hoàn thành. Với độ trễ mạng trung bình 150ms và thời gian xử lý model 650ms, tổng thời gian cho N request là:

# Công thức tính thời gian tuần tự
total_time = N * (network_latency + processing_time)
Với N = 50,000: 50,000 * (0.15 + 0.65) = 40,000 giây = 11.1 giờ

Tại sao async là giải pháp tối ưu

Với asyncio và aiohttp, chúng ta có thể gửi hàng trăm request đồng thời mà chỉ chờ đợi thời gian của request chậm nhất trong batch:

# Công thức tính thời gian bất đồng bộ
Với concurrency = 200, batch_time = ceil(N / concurrency) * max_latency
batch_time = ceil(50000 / 200) * 0.8  # = 200 * 0.8 = 160 giây ≈ 2.7 phút

Kiến trúc giải pháp trên HolySheep AI

Tại sao chọn HolySheep thay vì relay khác

Trong quá trình đánh giá, tôi đã so sánh 4 giải pháp và đây là bảng so sánh chi tiết:

Tiêu chí	API chính hãng	Relay A	Relay B	HolySheep AI
Giá MiniMax M2.7	$0.42/MTok	$0.38/MTok	$0.45/MTok	$0.42/MTok
Tỷ giá	1:1 USD	¥1=$0.14	¥1=$0.12	¥1=$1
Độ trễ P50	650ms	1200ms	980ms	<50ms
Rate limit	500 RPM	60 RPM	100 RPM	2000 RPM
Thanh toán	Visa/Master	WeChat only	Alipay	WeChat/Alipay/Visa
Tín dụng miễn phí	$5	$0	$2	Có

Với tỷ giá ¥1=$1, việc nạp tiền qua WeChat/Alipay trở nên cực kỳ tiết kiệm — $100 chỉ tốn ~¥100. Đặc biệt với team có thành viên ở Trung Quốc, đây là lợi thế không thể bỏ qua.

Triển khai chi tiết: Async Client cho MiniMax M2.7

Cài đặt dependencies

pip install aiohttp asyncio-limiter python-dotenv pydantic

HolySheep Async Client — Code đầy đủ

import asyncio
import aiohttp
import json
import time
from typing import List, Dict, Any, Optional
from dataclasses import dataclass
from asyncio import Semaphore
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)


@dataclass
class HolySheepConfig:
    """Cấu hình HolySheep AI API"""
    api_key: str
    base_url: str = "https://api.holysheep.ai/v1"
    model: str = "minimax/abab6.5s-chat"
    max_concurrency: int = 200
    timeout: int = 60
    retry_attempts: int = 3
    retry_delay: float = 1.0


class HolySheepMiniMaxClient:
    """Async client cho MiniMax M2.7 qua HolySheep AI Gateway"""
    
    def __init__(self, config: HolySheepConfig):
        self.config = config
        self.semaphore = Semaphore(config.max_concurrency)
        self.session: Optional[aiohttp.ClientSession] = None
        self._request_count = 0
        self._error_count = 0
        self._total_latency = 0.0
    
    async def __aenter__(self):
        timeout = aiohttp.ClientTimeout(total=self.config.timeout)
        connector = aiohttp.TCPConnector(limit=self.config.max_concurrency * 2)
        self.session = aiohttp.ClientSession(
            timeout=timeout,
            connector=connector,
            headers={
                "Authorization": f"Bearer {self.config.api_key}",
                "Content-Type": "application/json"
            }
        )
        return self
    
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        if self.session:
            await self.session.close()
    
    async def _make_request(
        self, 
        prompt: str, 
        temperature: float = 0.7,
        max_tokens: int = 1024
    ) -> Dict[str, Any]:
        """Thực hiện một request với retry logic"""
        url = f"{self.config.base_url}/chat/completions"
        payload = {
            "model": self.config.model,
            "messages": [{"role": "user", "content": prompt}],
            "temperature": temperature,
            "max_tokens": max_tokens
        }
        
        for attempt in range(self.config.retry_attempts):
            try:
                async with self.semaphore:
                    start_time = time.perf_counter()
                    
                    async with self.session.post(url, json=payload) as response:
                        latency = time.perf_counter() - start_time
                        self._request_count += 1
                        self._total_latency += latency
                        
                        if response.status == 200:
                            data = await response.json()
                            return {
                                "success": True,
                                "content": data["choices"][0]["message"]["content"],
                                "latency_ms": round(latency * 1000, 2),
                                "tokens_used": data.get("usage", {}).get("total_tokens", 0)
                            }
                        elif response.status == 429:
                            # Rate limit - chờ và thử lại
                            await asyncio.sleep(self.config.retry_delay * (attempt + 1))
                            continue
                        else:
                            error_text = await response.text()
                            self._error_count += 1
                            return {
                                "success": False,
                                "error": f"HTTP {response.status}: {error_text}",
                                "latency_ms": round(latency * 1000, 2)
                            }
                            
            except asyncio.TimeoutError:
                self._error_count += 1
                if attempt == self.config.retry_attempts - 1:
                    return {"success": False, "error": "Timeout"}
                await asyncio.sleep(self.config.retry_delay)
                
            except Exception as e:
                self._error_count += 1
                if attempt == self.config.retry_attempts - 1:
                    return {"success": False, "error": str(e)}
                await asyncio.sleep(self.config.retry_delay)
        
        return {"success": False, "error": "Max retries exceeded"}
    
    async def batch_process(
        self, 
        prompts: List[str],
        progress_callback: Optional[callable] = None
    ) -> List[Dict[str, Any]]:
        """Xử lý batch prompts với concurrent requests"""
        logger.info(f"Bắt đầu xử lý batch {len(prompts)} prompts...")
        start_time = time.perf_counter()
        
        tasks = [self._make_request(prompt) for prompt in prompts]
        
        results = []
        for i, coro in enumerate(asyncio.as_completed(tasks)):
            result = await coro
            results.append(result)
            
            if progress_callback and (i + 1) % 100 == 0:
                progress_callback(i + 1, len(prompts))
        
        total_time = time.perf_counter() - start_time
        
        # Thống kê
        successful = sum(1 for r in results if r["success"])
        avg_latency = self._total_latency / max(self._request_count, 1)
        
        logger.info(f"""
╔══════════════════════════════════════════════════════╗
║  THỐNG KÊ XỬ LÝ BATCH                                ║
╠══════════════════════════════════════════════════════╣
║  Tổng prompts:     {len(prompts):>8}                        ║
║  Thành công:       {successful:>8} ({100*successful/len(prompts):.1f}%)               ║
║  Thất bại:         {len(prompts) - successful:>8}                        ║
║  Tổng thời gian:   {total_time:>8.2f} giây                ║
║  Độ trễ TB:        {avg_latency * 1000:>8.2f} ms                  ║
║  Throughput:       {len(prompts)/total_time:>8.1f} req/s              ║
╚══════════════════════════════════════════════════════╝
        """)
        
        return results
    
    def get_stats(self) -> Dict[str, Any]:
        """Lấy thống kê request"""
        return {
            "total_requests": self._request_count,
            "errors": self._error_count,
            "success_rate": (self._request_count - self._error_count) / max(self._request_count, 1),
            "avg_latency_ms": round(self._total_latency / max(self._request_count, 1) * 1000, 2)
        }


Ví dụ sử dụng
async def main():
    from dotenv import load_dotenv
    import os
    
    load_dotenv()
    api_key = os.getenv("HOLYSHEEP_API_KEY", "YOUR_HOLYSHEEP_API_KEY")
    
    config = HolySheepConfig(
        api_key=api_key,
        max_concurrency=200,  # 200 concurrent requests
        timeout=60
    )
    
    # Sample prompts cho sentiment analysis
    sample_prompts = [
        "Phân tích sentiment: 'Sản phẩm này tuyệt vời, giao hàng nhanh'"
        for _ in range(1000)
    ]
    
    async with HolySheepMiniMaxClient(config) as client:
        results = await client.batch_process(sample_prompts)
        
        # In kết quả mẫu
        print("\nKết quả mẫu (5第一条):")
        for i, result in enumerate(results[:5]):
            print(f"  [{i+1}] {'✓' if result['success'] else '✗'} - {result.get('content', result.get('error'))[:80]}")


if __name__ == "__main__":
    asyncio.run(main())

Script xử lý file CSV với checkpoint

import csv
import asyncio
from pathlib import Path
from typing import List, Tuple


class BatchProcessor:
    """Xử lý file CSV lớn với checkpoint để tránh mất dữ liệu khi crash"""
    
    def __init__(self, client: HolySheepMiniMaxClient, checkpoint_interval: int = 500):
        self.client = client
        self.checkpoint_interval = checkpoint_interval
        self.checkpoint_file = Path("checkpoint.json")
    
    def load_checkpoint(self) -> Tuple[int, List[dict]]:
        """Load checkpoint nếu có"""
        if self.checkpoint_file.exists():
            import json
            with open(self.checkpoint_file, 'r') as f:
                data = json.load(f)
                return data['processed_count'], data['results']
        return 0, []
    
    def save_checkpoint(self, processed: int, results: List[dict]):
        """Lưu checkpoint"""
        import json
        with open(self.checkpoint_file, 'w') as f:
            json.dump({
                'processed_count': processed,
                'results': results[-1000:]  # Chỉ giữ 1000 kết quả gần nhất
            }, f)
    
    async def process_csv(
        self, 
        input_file: str, 
        output_file: str,
        prompt_column: str,
        batch_size: int = 500
    ):
        """Xử lý file CSV với checkpoint tự động"""
        input_path = Path(input_file)
        start_idx, existing_results = self.load_checkpoint()
        
        prompts = []
        with open(input_path, 'r', encoding='utf-8') as f:
            reader = csv.DictReader(f)
            rows = list(reader)
        
        total = len(rows)
        prompts = [row[prompt_column] for row in rows[start_idx:]]
        
        print(f"Tiếp tục từ index {start_idx}/{total}")
        print(f"Cần xử lý {len(prompts)} prompts trong {ceil(len(prompts)/batch_size)} batches")
        
        all_results = existing_results
        
        for batch_start in range(0, len(prompts), batch_size):
            batch = prompts[batch_start:batch_start + batch_size]
            current_idx = start_idx + batch_start
            
            # Xử lý batch
            batch_results = await self.client.batch_process(batch)
            
            # Thêm vào kết quả
            for i, result in enumerate(batch_results):
                all_results.append({
                    'index': current_idx + i,
                    **result
                })
            
            # Lưu checkpoint
            if (batch_start + batch_size) % self.checkpoint_interval == 0:
                self.save_checkpoint(current_idx + batch_size, all_results)
                print(f"✓ Đã lưu checkpoint tại {current_idx + batch_size}/{total}")
        
        # Lưu kết quả cuối cùng
        with open(output_file, 'w', encoding='utf-8', newline='') as f:
            writer = csv.DictWriter(f, fieldnames=['index', 'success', 'content', 'latency_ms'])
            writer.writeheader()
            writer.writerows(all_results)
        
        # Xóa checkpoint sau khi hoàn thành
        self.checkpoint_file.unlink(missing_ok=True)
        
        print(f"✓ Hoàn thành! Kết quả lưu tại {output_file}")


def ceil(x: float) -> int:
    return int(-(-x // 1))


if __name__ == "__main__":
    from dotenv import load_dotenv
    import os
    
    load_dotenv()
    api_key = os.getenv("HOLYSHEEP_API_KEY", "YOUR_HOLYSHEEP_API_KEY")
    
    config = HolySheepConfig(api_key=api_key, max_concurrency=200)
    
    async def run():
        async with HolySheepMiniMaxClient(config) as client:
            processor = BatchProcessor(client, checkpoint_interval=500)
            await processor.process_csv(
                input_file="reviews.csv",
                output_file="results.csv",
                prompt_column="review_text",
                batch_size=500
            )
    
    asyncio.run(run())

Chi phí và ROI — Phân tích thực tế

Bảng tính chi phí chi tiết

Hạng mục	Trước (Relay cũ)	Sau (HolySheep)	Tiết kiệm
Chi phí API/ngày	$127	$18.50	$108.50 (85%)
Chi phí API/tháng	$3,810	$555	$3,255
Thời gian xử lý	11 giờ	23 phút	10h 37ph
Độ trễ P50	980ms	48ms	932ms (95%)
Rate limit	100 RPM	2000 RPM	20x

Tính ROI

# Giả định: 50,000 requests/ngày, mỗi request ~500 tokens input + 200 tokens output
requests_per_day = 50000
input_tokens = 500
output_tokens = 200
total_tokens_per_request = input_tokens + output_tokens  # 700 tokens

Chi phí MiniMax M2.7 qua HolySheep (~$0.42/MTok)
price_per_mtok = 0.42  # USD
tokens_per_day = requests_per_day * total_tokens_per_request
mtok_per_day = tokens_per_day / 1_000_000

daily_cost = mtok_per_day * price_per_mtok
monthly_cost = daily_cost * 30
yearly_cost = monthly_cost * 12

ROI calculation
old_monthly_cost = 3810  # Relay cũ
monthly_savings = old_monthly_cost - monthly_cost
yearly_savings = monthly_savings * 12

print(f"""
╔══════════════════════════════════════════════════════╗
║              PHÂN TÍCH CHI PHÍ & ROI                  ║
╠══════════════════════════════════════════════════════╣
║  Chi phí/ngày:           ${daily_cost:>8.2f}                   ║
║  Chi phí/tháng:          ${monthly_cost:>8.2f}                  ║
║  Chi phí/năm:            ${yearly_cost:>8.2f}                 ║
╠══════════════════════════════════════════════════════╣
║  Tiết kiệm/tháng:        ${monthly_savings:>8.2f}                  ║
║  Tiết kiệm/năm:          ${yearly_savings:>8.2f}                 ║
║  ROI (so với relay cũ):  {yearly_savings/old_monthly_cost*100:>8.1f}%                   ║
╚══════════════════════════════════════════════════════╝
""")

Kế hoạch di chuyển và Rollback

Phase 1: Preparation (Ngày 1-2)

• Đăng ký tài khoản HolySheep: Đăng ký tại đây và nhận tín dụng miễn phí
• Tạo API key mới và lưu vào environment variable
• Setup monitoring cho API response time và error rate
• Chuẩn bị script rollback với config cũ

Phase 2: Shadow Testing (Ngày 3-5)

# Script shadow testing - chạy song song cả 2 endpoint
async def shadow_test():
    """Chạy 10% traffic qua HolySheep, so sánh kết quả"""
    
    async with HolySheepMiniMaxClient(config) as holy_client, \
               OldRelayClient(old_config) as old_client:
        
        test_prompts = load_test_set(100)
        holy_results = []
        old_results = []
        
        for prompt in test_prompts:
            holy_task = holy_client._make_request(prompt)
            old_task = old_client._make_request(prompt)
            
            holy_result, old_result = await asyncio.gather(holy_task, old_task)
            holy_results.append(holy_result)
            old_results.append(old_result)
        
        # So sánh kết quả
        match_rate = calculate_match_rate(holy_results, old_results)
        print(f"Tỷ lệ khớp kết quả: {match_rate}%")
        
        # Đánh giá latency improvement
        avg_old_latency = sum(r['latency_ms'] for r in old_results) / len(old_results)
        avg_holy_latency = sum(r['latency_ms'] for r in holy_results) / len(holy_results)
        print(f"Độ trễ cải thiện: {avg_old_latency - avg_holy_latency}ms ({(1-avg_holy_latency/avg_old_latency)*100:.1f}%)")

Phase 3: Production Migration (Ngày 6-7)

• Blue-green deployment: 20% → 50% → 100% traffic
• Monitor closely trong 24 giờ đầu
• Giữ relay cũ active để rollback nhanh nếu cần

Rollback Plan

# Docker-compose cho rollback nhanh
docker-compose.rollback.yml
version: '3.8'
services:
  api-gateway:
    image: our-api:${VERSION}
    environment:
      - API_PROVIDER=old_relay  # Hoặc holy_sheep
      - HOLYSHEEP_API_KEY=${HOLYSHEEP_KEY}
      - OLD_RELAY_API_KEY=${OLD_RELAY_KEY}
    deploy:
      replicas: 3
    
  health-check:
    image: prom/health-check:latest
    environment:
      - ENDPOINT=http://api-gateway:8080/health
      - THRESHOLD_ERROR_RATE=0.05
      - THRESHOLD_LATENCY_P99=2000

Lệnh rollback nhanh
kubectl apply -f docker-compose.rollback.yml --set ACTIVE_PROVIDER=old_relay

Lỗi thường gặp và cách khắc phục

1. Lỗi "Connection pool exhausted" - Quá nhiều concurrent connections

# Vấn đề: aiohttp hiển thị "Cannot connect to host" hoặc connection timeout
Nguyên nhân: Tạo quá nhiều connections vượt quá giới hạn OS

Cách khắc phục - Tăng connection limit và giảm concurrency
import aiohttp

SAI - Gây ra connection pool exhaustion
async def bad_example():
    async with aiohttp.ClientSession() as session:
        tasks = [session.get(url) for url in urls]  # 10,000 tasks cùng lúc!
        await asyncio.gather(*tasks)

ĐÚNG - Giới hạn concurrency với semaphore
async def good_example():
    connector = aiohttp.TCPConnector(limit=100, limit_per_host=20)
    timeout = aiohttp.ClientTimeout(total=30)
    
    async with aiohttp.ClientSession(connector=connector, timeout=timeout) as session:
        semaphore = Semaphore(50)  # Chỉ 50 concurrent requests
        
        async def bounded_request(url):
            async with semaphore:
                return await session.get(url)
        
        tasks = [bounded_request(url) for url in urls]
        await asyncio.gather(*tasks)

2. Lỗi "Rate limit exceeded" - Vượt quá giới hạn request

# Vấn đề: Nhận HTTP 429 responses liên tục
Nguyên nhân: Gửi quá nhiều requests vượt rate limit của HolySheep

Cách khắc phục - Implement exponential backoff và rate limiter
import asyncio
from aiolimiter import AsyncLimiter

class RateLimitedClient:
    def __init__(self, requests_per_second: int = 100):
        # HolySheep cho phép 2000 RPM, giữ safety margin 80%
        self.limiter = AsyncLimiter(max_rate=requests_per_second, time_period=1)
    
    async def request(self, url: str, payload: dict):
        async with self.limiter:
            async with self.session.post(url, json=payload) as resp:
                if resp.status == 429:
                    # Exponential backoff
                    retry_after = int(resp.headers.get('Retry-After', 1))
                    await asyncio.sleep(retry_after * 2)
                    return await self.request(url, payload)  # Retry
                return await resp.json()

Sử dụng với retry logic đầy đủ
class ResilientRateLimitedClient(RateLimitedClient):
    def __init__(self, *args, max_retries: int = 5, **kwargs):
        super().__init__(*args, **kwargs)
        self.max_retries = max_retries
    
    async def request_with_retry(self, url: str, payload: dict):
        for attempt in range(self.max_retries):
            try:
                result = await self.request(url, payload)
                if 'error' not in result:
                    return result
                    
                # Xử lý rate limit với exponential backoff
                if result.get('error', {}).get('code') == 'rate_limit_exceeded':
                    wait_time = 2 ** attempt + random.uniform(0, 1)
                    print(f"Attempt {attempt + 1}: Rate limited, waiting {wait_time:.1f}s")
                    await asyncio.sleep(wait_time)
                    continue
                    
            except Exception as e:
                if attempt == self.max_retries - 1:
                    raise
                await asyncio.sleep(2 ** attempt)
        
        return {"error": "Max retries exceeded"}

3. Lỗi "Token usage mismatch" - Tính tokens không chính xác

# Vấn đề: Số tokens trong response không khớp với độ dài text
Nguyên nhân: Encoding khác nhau hoặc không parse đúng usage field

Cách khắc phục - Validate và sử dụng tokenizer chuẩn
from tiktoken import Encoding, get_encoding

class TokenValidator:
    def __init__(self):
        # Sử dụng cl100k_base cho model tương thích GPT-4
        self.encoder: Encoding = get_encoding("cl100k_base")
    
    def count_tokens(self, text: str) -> int:
        """Đếm tokens theo encoding chuẩn"""
        return len(self.encoder.encode(text))
    
    def validate_response(self, response: dict, prompt: str) -> dict:
        """Validate token usage từ API response"""
        content = response.get("choices", [{}])[0].get("message", {}).get("content", "")
        
        # Tokens từ API
        api_usage = response.get("usage", {})
        api_total_tokens = api_usage.get("total_tokens", 0)
        
        # Tokens đếm thủ công
        expected_tokens = self.count_tokens(prompt) + self.count_tokens(content)
        
        # Chênh lệch > 5% thì cảnh báo
        diff_pct = abs(api_total_tokens - expected_tokens) / max(expected_tokens, 1)
        
        if diff_pct > 0.05:
            print(f"⚠️ Token mismatch: API={api_total_tokens}, Expected={expected_tokens}, Diff={diff_pct:.1%}")
        
        return {
            "api_tokens": api_total_tokens,
            "expected_tokens": expected_tokens,
            "valid": diff_pct <= 0.05,
            "diff_percentage": diff_pct
        }
    
    def batch_validate(self, responses: List[dict], prompts: List[str]) -> dict:
        """Validate batch responses"""
        results = [
            self.validate_response(resp, prompt) 
            for resp, prompt in zip(responses, prompts)
        ]
        
        valid_count = sum(1 for r in results if r["valid"])
        
        return {
            "total": len(results),
            "valid": valid_count,
            "invalid": len(results) - valid_count,
            "validation_rate": valid_count / len(results),
            "avg_diff_pct": sum(r["diff_percentage"] for r in results) / len(results)
        }

4. Lỗi "Context window exceeded" - Prompt quá dài

# Vấn đề: Request bị reject vì prompt vượt context limit
Nguyên nhân: Không truncate/paginate prompt trước khi gửi

Cách khắc phục - Smart truncation với context management
class ContextManager:
    # MiniMax M2.7 context window: 245,760 tokens
    CONTEXT_LIMIT = 245760
    SAFETY_MARGIN = 0.9  # Chỉ dùng 90% context
    OUTPUT_TOKENS = 2048  # Dự trù cho output
    
    def __init__(self, max_context_tokens: int = None):
        self.max_context = int(
            (max_context_tokens or self.CONTEXT_LIMIT) * self.SAFETY_MARGIN - self.OUTPUT_TOKENS
        )
    
    def truncate_prompt(self, prompt: str, encoder) -> str:
        """Truncate prompt an toàn"""
        tokens = encoder.encode(prompt)
        
        if len(tokens) <= self.max_context:
            return prompt
        
        # Giữ system prompt + phần đầu + phần cuối của user prompt
        truncated_tokens = tokens[:self.max_context]
        return encoder.decode(truncated_tokens)
    
    def chunk_long_content(self, content: str, encoder, chunk_size: int = None) -> List[str]:
        """Chia content d
Tài nguyên liên quan
📚 Hướng dẫn AI API
💰 Xem giá
📖 Tài liệu nhà phát triển
🚀 Đăng ký miễn phí
Bài viết liên quan
DeerFlow工作流引擎配置Claude中转完整教程