Trong bài viết này, tôi sẽ chia sẻ chiến lược API ecosystem mà tôi đã triển khai cho một nền tảng thương mại điện tử tại TP.HCM — từ việc chịu đựng hóa đơn $4,200/tháng với độ trễ 420ms cho đến khi tối ưu xuống $680/tháng với độ trễ chỉ 180ms. Đây là hành trình thực tế mà bất kỳ team kỹ thuật nào cũng có thể học hỏi.
Bối Cảnh: Khi API Bill Trở Thành Áp Lực Lớn Nhất
Năm 2025, một nền tảng TMĐT quy mô vừa tại TP.HCM đang xử lý khoảng 50,000 yêu cầu AI mỗi ngày cho tính năng chatbot hỗ trợ khách hàng, gợi ý sản phẩm, và tóm tắt đánh giá. Nhà phát triển ban đầu sử dụng một nhà cung cấp API phổ biến với cấu hình mặc định.
Điểm đau của nhà cung cấp cũ
- Chi phí cắt cổ: Hóa đơn hàng tháng dao động từ $3,800 đến $4,500 do tính phí theo token đầu vào và đầu ra riêng biệt
- Độ trễ không ổn định: Trung bình 420ms, đỉnh điểm lên tới 800ms vào giờ cao điểm
- Không hỗ trợ thanh toán nội địa: Chỉ chấp nhận thẻ quốc tế, gây khó khăn cho kế toán
- Retry logic yếu: Không có built-in circuit breaker, dẫn đến cascade failure khi API lag
Giải pháp: HolySheep AI
Sau khi đánh giá nhiều alternatives, team đã chọn HolySheep AI vì ba lý do chính:
- Tỷ giá ¥1=$1 giúp tiết kiệm 85%+ so với các nhà cung cấp phương Tây
- Hỗ trợ WeChat Pay và Alipay cho thanh toán thuận tiện
- Latency trung bình dưới 50ms với cơ sở hạ tầng edge ở châu Á
- Nhận tín dụng miễn phí khi đăng ký để test trước khi cam kết
Chiến Lược Di Chuyển: Zero-Downtime Migration
Tôi đã thiết kế chiến lược di chuyển theo 3 giai đoạn để đảm bảo zero-downtime. Dưới đây là các bước cụ thể mà team đã thực hiện.
Giai Đoạn 1: Wrapper Class Chung
Thay vì hard-code provider trong toàn bộ codebase, chúng tôi tạo một abstraction layer để dễ dàng switch giữa các providers.
# ai_client.py
import os
import time
import httpx
from typing import Optional, Dict, Any
from tenacity import retry, stop_after_attempt, wait_exponential
class AIAPIClient:
"""
Unified wrapper cho multiple AI providers.
Hiện tại chỉ hỗ trợ HolySheep API với các mô hình:
- GPT-4.1: $8/MTok
- Claude Sonnet 4.5: $15/MTok
- Gemini 2.5 Flash: $2.50/MTok
- DeepSeek V3.2: $0.42/MTok (best value!)
"""
def __init__(self, api_key: Optional[str] = None):
# LUÔN LUÔN sử dụng HolySheep - KHÔNG dùng api.openai.com
self.base_url = "https://api.holysheep.ai/v1"
self.api_key = api_key or os.environ.get("HOLYSHEEP_API_KEY")
if not self.api_key:
raise ValueError("HOLYSHEEP_API_KEY is required. Đăng ký tại: https://www.holysheep.ai/register")
self.client = httpx.Client(
timeout=30.0,
limits=httpx.Limits(max_keepalive_connections=20, max_connections=100)
)
# Metrics tracking
self.stats = {"requests": 0, "errors": 0, "total_latency": 0}
@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=1, max=10))
def chat_completion(
self,
messages: list,
model: str = "deepseek-v3.2",
temperature: float = 0.7,
max_tokens: int = 1000
) -> Dict[str, Any]:
"""
Gọi chat completion API với retry logic tự động.
Args:
messages: List of message dicts với role và content
model: Model name (default: deepseek-v3.2 cho cost efficiency)
temperature: Creativity level (0.0-2.0)
max_tokens: Maximum tokens trong response
Returns:
Response dict từ API
"""
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": model,
"messages": messages,
"temperature": temperature,
"max_tokens": max_tokens
}
start_time = time.time()
try:
response = self.client.post(
f"{self.base_url}/chat/completions",
headers=headers,
json=payload
)
response.raise_for_status()
# Track metrics
latency = (time.time() - start_time) * 1000 # Convert to ms
self.stats["requests"] += 1
self.stats["total_latency"] += latency
return response.json()
except httpx.HTTPStatusError as e:
self.stats["errors"] += 1
if e.response.status_code == 429:
raise Exception("Rate limit exceeded - implement backoff")
elif e.response.status_code == 401:
raise Exception("Invalid API key - check your HOLYSHEEP_API_KEY")
raise
except Exception as e:
self.stats["errors"] += 1
raise
def get_stats(self) -> Dict[str, Any]:
"""Lấy metrics summary"""
avg_latency = (
self.stats["total_latency"] / self.stats["requests"]
if self.stats["requests"] > 0 else 0
)
error_rate = (
self.stats["errors"] / self.stats["requests"]
if self.stats["requests"] > 0 else 0
)
return {
"total_requests": self.stats["requests"],
"error_count": self.stats["errors"],
"error_rate": f"{error_rate:.2%}",
"avg_latency_ms": round(avg_latency, 2)
}
Singleton instance
_client: Optional[AIAPIClient] = None
def get_ai_client() -> AIAPIClient:
global _client
if _client is None:
_client = AIAPIClient()
return _clientGiai Đoạn 2: Canary Deployment Strategy
Để giảm thiểu rủi ro, chúng tôi triển khai theo mô hình canary: 5% → 20% → 50% → 100% traffic trong 2 tuần.
# canary_controller.py
import os
import time
import random
from typing import Callable, Any, Dict
from dataclasses import dataclass
from enum import Enum
class TrafficSplit(Enum):
PHASE_1_5_PERCENT = 0.05
PHASE_2_20_PERCENT = 0.20
PHASE_3_50_PERCENT = 0.50
PHASE_4_100_PERCENT = 1.00
@dataclass
class CanaryConfig:
phase: TrafficSplit
start_time: float
duration_hours: int
health_check_url: str = "https://api.holysheep.ai/v1/models"
canary_config = CanaryConfig(
phase=TrafficSplit.PHASE_1_5_PERCENT,
start_time=time.time(),
duration_hours=168 # 1 week per phase
)
def should_use_new_provider() -> bool:
"""
Quyết định có dùng HolySheep hay provider cũ dựa trên canary percentage.
"""
current_phase = _get_current_phase()
canary_config.phase = current_phase
# Always use HolySheep - we've migrated completely
# This function kept for A/B testing scenarios
return True
def _get_current_phase() -> TrafficSplit:
"""
Tự động promote phase dựa trên thời gian và health check.
"""
elapsed_hours = (time.time() - canary_config.start_time) / 3600
# Auto-promote based on time
if elapsed_hours >= 504: # 3 weeks total
return TrafficSplit.PHASE_4_100_PERCENT
elif elapsed_hours >= 336: # 2 weeks
return TrafficSplit.PHASE_3_50_PERCENT
elif elapsed_hours >= 168: # 1 week
return TrafficSplit.PHASE_2_20_PERCENT
else:
return TrafficSplit.PHASE_1_5_PERCENT
class CircuitBreaker:
"""
Circuit breaker pattern để handle API failures.
States: CLOSED (normal) → OPEN (failing) → HALF_OPEN (testing)
"""
def __init__(self, failure_threshold: int = 5, timeout_seconds: int = 60):
self.failure_threshold = failure_threshold
self.timeout_seconds = timeout_seconds
self.failures = 0
self.last_failure_time = None
self.state = "CLOSED" # CLOSED, OPEN, HALF_OPEN
def call(self, func: Callable, *args, **kwargs) -> Any:
if self.state == "OPEN":
if time.time() - self.last_failure_time > self.timeout_seconds:
self.state = "HALF_OPEN"
else:
raise Exception("Circuit breaker OPEN - rejecting request")
try:
result = func(*args, **kwargs)
if self.state == "HALF_OPEN":
self.state = "CLOSED"
self.failures = 0
return result
except Exception as e:
self.failures += 1
self.last_failure_time = time.time()
if self.failures >= self.failure_threshold:
self.state = "OPEN"
raise
Global circuit breaker instance
ai_circuit_breaker = CircuitBreaker(failure_threshold=5, timeout_seconds=60)Giai Đoạn 3: Batch Processing Và Caching
Một trong những key optimizations là batch multiple requests và implement caching thông minh để giảm token consumption.
# batch_and_cache.py
import hashlib
import json
import time
from typing import List, Dict, Any, Optional
from collections import OrderedDict
import asyncio
class LRUCache:
"""
LRU Cache với TTL cho API responses.
Giảm chi phí đáng kể bằng cách cache repeated queries.
"""
def __init__(self, max_size: int = 1000, ttl_seconds: int = 3600):
self.cache = OrderedDict()
self.timestamps = {}
self.max_size = max_size
self.ttl_seconds = ttl_seconds
self.hits = 0
self.misses = 0
def _make_key(self, messages: List[Dict], model: str) -> str:
"""Tạo cache key từ request parameters."""
content = json.dumps({"messages": messages, "model": model}, sort_keys=True)
return hashlib.sha256(content.encode()).hexdigest()
def get(self, messages: List[Dict], model: str) -> Optional[Dict]:
key = self._make_key(messages, model)
if key in self.cache:
# Check TTL
if time.time() - self.timestamps[key] < self.ttl_seconds:
self.cache.move_to_end(key)
self.hits += 1
return self.cache[key]
else:
# Expired
del self.cache[key]
del self.timestamps[key]
self.misses += 1
return None
def set(self, messages: List[Dict], model: str, value: Dict):
key = self._make_key(messages, model)
if key in self.cache:
self.cache.move_to_end(key)
self.cache[key] = value
self.timestamps[key] = time.time()
# Evict oldest if over max_size
if len(self.cache) > self.max_size:
oldest_key = next(iter(self.cache))
del self.cache[oldest_key]
del self.timestamps[oldest_key]
def get_stats(self) -> Dict[str, Any]:
total = self.hits + self.misses
hit_rate = (self.hits / total * 100) if total > 0 else 0
return {
"hits": self.hits,
"misses": self.misses,
"hit_rate": f"{hit_rate:.2f}%",
"size": len(self.cache)
}
class BatchProcessor:
"""
Batch multiple small requests thành một single API call.
Tối ưu cho scenarios với nhiều short queries.
"""
def __init__(self, client, batch_size: int = 10, max_wait_ms: int = 100):
self.client = client
self.batch_size = batch_size
self.max_wait_ms = max_wait_ms
self.pending_requests: List[Dict] = []
self.last_batch_time = time.time()
async def add_request(self, messages: List[Dict], model: str) -> Dict:
"""
Add request vào batch queue.
"""
request_id = len(self.pending_requests)
request = {
"id": request_id,
"messages": messages,
"model": model,
"timestamp": time.time()
}
self.pending_requests.append(request)
# Flush if batch is full
if len(self.pending_requests) >= self.batch_size:
return await self._flush_batch()
# Flush if wait time exceeded
if (time.time() - self.last_batch_time) * 1000 >= self.max_wait_ms:
return await self._flush_batch()
return {"status": "queued", "request_id": request_id}
async def _flush_batch(self) -> Dict:
"""
Gửi batch request đến API.
Sử dụng DeepSeek V3.2 ($0.42/MTok) cho cost efficiency.
"""
if not self.pending_requests:
return {"status": "empty"}
# Construct batch prompt
batch_prompt = self._construct_batch_prompt(self.pending_requests)
response = self.client.chat_completion(
messages=[{"role": "user", "content": batch_prompt}],
model="deepseek-v3.2" # Best cost-performance ratio
)
results = self._parse_batch_response(response, self.pending_requests)
self.pending_requests = []
self.last_batch_time = time.time()
return {"status": "processed", "results": results}
def _construct_batch_prompt(self, requests: List[Dict]) -> str:
"""Tạo prompt cho batch processing."""
prompt_parts = ["Process the following requests as a batch:\n"]
for req in requests:
prompt_parts.append(f"Request {req['id']}: {req['messages'][-1]['content']}\n")
prompt_parts.append("Respond in JSON format with results array.")
return "".join(prompt_parts)
def _parse_batch_response(self, response: Dict, requests: List[Dict]) -> List[Dict]:
"""Parse batch response thành individual results."""
# Simplified - in production, implement proper parsing
content = response.get("choices", [{}])[0].get("message", {}).get("content", "")
return [{"id": r["id"], "response": content} for r in requests]
Global instances
response_cache = LRUCache(max_size=5000, ttl_seconds=7200) # 2 hour cache
batch_processor: Optional[BatchProcessor] = NoneBảng So Sánh Chi Phí: Trước Và Sau
| Model | Nhà cung cấp cũ ($/MTok) | HolySheep ($/MTok) | Tiết kiệm |
|---|---|---|---|
| GPT-4.1 | $30.00 | $8.00 | 73% |
| Claude Sonnet 4.5 | $45.00 | $15.00 | 67% |
| Gemini 2.5 Flash | $7.50 | $2.50 | 67% |
| DeepSeek V3.2 | Không hỗ trợ | $0.42 | Best Value! |
Kết Quả Sau 30 Ngày Go-Live
Dưới đây là metrics thực tế được đo sau 30 ngày triển khai HolySheep:
- Độ trễ trung bình: 420ms → 180ms (giảm 57%)
- Chi phí hàng tháng: $4,200 → $680 (giảm 84%)
- Error rate: 2.3% → 0.1%
- Cache hit rate: 35% (bonus từ LRU cache)
- Thời gian phục hồi lỗi: 45 phút → 5 phút
Từ kinh nghiệm thực chiến của tôi: Phần lớn savings đến từ việc switch sang DeepSeek V3.2 cho các task không đòi hỏi model lớn nhất, kết hợp với caching strategy. Chỉ cần 3 simple changes trong code là bạn có thể đạt được những con số tương tự.
Lỗi Thường Gặp Và Cách Khắc Phục
Qua quá trình di chuyển, tôi đã gặp và xử lý nhiều edge cases. Dưới đây là 5 lỗi phổ biến nhất cùng với giải pháp đã test.
1. Lỗi "Invalid API Key" Sau Khi Rotate Key
# Vấn đề: Sau khi rotate API key, request vẫn dùng key cũ
Giải pháp: Implement key rotation với graceful fallback
class KeyRotationManager:
def __init__(self, primary_key: str, secondary_key: str = None):
self.primary_key = primary_key
self.secondary_key = secondary_key
self.active_key = primary_key
self.key_version = 1
def rotate_key(self, new_key: str):
"""Rotate sang new key với health check trước."""
old_key = self.active_key
# Test new key trước khi activate
test_client = AIAPIClient(api_key=new_key)
try:
test_result = test_client.chat_completion(
messages=[{"role": "user", "content": "ping"}],
model="deepseek-v3.2"
)
# New key healthy - rotate
if self.primary_key == self.active_key:
self.secondary_key = old_key
self.primary_key = new_key
else:
self.secondary_key = old_key
self.active_key = new_key
self.key_version += 1
print(f"Key rotated successfully. Version: {self.key_version}")
except Exception as e:
print(f"New key validation failed: {e}")
raise ValueError("Key rotation aborted - new key is invalid")
def get_active_key(self) -> str:
"""Get current active key với automatic recovery."""
if self._is_key_valid(self.active_key):
return self.active_key
# Try fallback key
if self.secondary_key and self._is_key_valid(self.secondary_key):
print("Falling back to secondary key")
self.active_key = self.secondary_key
return self.active_key
raise Exception("No valid API key available")
def _is_key_valid(self, key: str) -> bool:
"""Quick health check cho API key."""
try:
test_client = AIAPIClient(api_key=key)
test_client.client.get(
f"https://api.holysheep.ai/v1/models",
headers={"Authorization": f"Bearer {key}"}
)
return True
except:
return False
Usage
key_manager = KeyRotationManager(
primary_key="YOUR_HOLYSHEEP_API_KEY"
)
key_manager.rotate_key("NEW_HOLYSHEEP_API_KEY")2. Lỗi Rate Limit Xử Lý Không Đúng
# Vấn đề: Khi gặp 429 error, retry logic không exponential backoff
Giải pháp: Implement proper exponential backoff với jitter
import random
import asyncio
class RateLimitHandler:
"""
Proper rate limit handling với exponential backoff và jitter.
Tránh thundering herd problem.
"""
def __init__(self, base_delay: float = 1.0, max_delay: float = 60.0):
self.base_delay = base_delay
self.max_delay = max_delay
self.current_rate_limit = None
def calculate_backoff(self, attempt: int, retry_after: int = None) -> float:
"""
Calculate backoff delay với exponential và jitter.
Args:
attempt: Số lần retry hiện tại (bắt đầu từ 1)
retry_after: Retry-After header value từ server (seconds)
Returns:
Delay trong seconds
"""
# Respect server's retry-after if provided
if retry_after:
# Add jitter: ±20%
jitter = random.uniform(0.8, 1.2)
return retry_after * jitter
# Exponential backoff: base_delay * 2^attempt
exponential_delay = self.base_delay * (2 ** (attempt - 1))
# Cap at max_delay
delay = min(exponential_delay, self.max_delay)
# Add random jitter: ±25%
jitter = random.uniform(0.75, 1.25)
delay *= jitter
return delay
async def execute_with_retry(
self,
func,
*args,
max_attempts: int = 5,
**kwargs
):
"""
Execute function với automatic retry on rate limit.
Args:
func: Function cần execute
max_attempts: Maximum retry attempts
*args, **kwargs: Arguments cho func
"""
last_exception = None
for attempt in range(1, max_attempts + 1):
try:
result = await func(*args, **kwargs)
return result
except httpx.HTTPStatusError as e:
last_exception = e
if e.response.status_code == 429:
retry_after = None
# Try to parse Retry-After header
retry_after_header = e.response.headers.get("retry-after")
if retry_after_header:
try:
retry_after = int(retry_after_header)
except ValueError:
pass
delay = self.calculate_backoff(attempt, retry_after)
print(f"Rate limited. Attempt {attempt}/{max_attempts}. "
f"Waiting {delay:.2f}s...")
await asyncio.sleep(delay)
elif e.response.status_code >= 500:
# Server error - retry with backoff
delay = self.calculate_backoff(attempt)
print(f"Server error {e.response.status_code}. "
f"Retrying in {delay:.2f}s...")
await asyncio.sleep(delay)
else:
# Client error (4xx except 429) - don't retry
raise
except Exception as e:
last_exception = e
# Network error - retry with backoff
delay = self.calculate_backoff(attempt)
print(f"Network error: {e}. Retrying in {delay:.2f}s...")
await asyncio.sleep(delay)
# All attempts failed
raise Exception(
f"All {max_attempts} attempts failed. Last error: {last_exception}"
)
Usage với async function
handler = RateLimitHandler(base_delay=1.0, max_delay=30.0)
async def call_ai_api():
client = get_ai_client()
return await handler.execute_with_retry(
client.chat_completion,
messages=[{"role": "user", "content": "Hello"}],
model="deepseek-v3.2"
)
Run
result = asyncio.run(call_ai_api())
3. Lỗi Memory Leak Khi Sử Dụng Singleton Client
# Vấn đề: httpx Client giữ connection pool không release đúng cách
Giải pháp: Proper lifecycle management cho client instances
import atexit
import weakref
class AIAPIClientManager:
"""
Manager để handle AI API client lifecycle.
Tránh memory leak từ connection pool.
"""
_instances: weakref.WeakSet = weakref.WeakSet()
def __init__(self, max_connections: int = 100):
self.max_connections = max_connections
self.client = None
self._setup_client()
# Track this instance
AIAPIClientManager._instances.add(self)
# Register cleanup
atexit.register(self.cleanup)
def _setup_client(self):
"""Setup httpx client với proper limits."""
self.client = httpx.Client(
timeout=httpx.Timeout(30.0, connect=5.0),
limits=httpx.Limits(
max_keepalive_connections=20,
max_connections=self.max_connections
),
http2=True # Enable HTTP/2 for better multiplexing
)
def cleanup(self):
"""Cleanup resources khi manager bị destroy."""
if self.client:
try:
self.client.close()
print("AI API Client cleaned up successfully")
except Exception as e:
print(f"Error during cleanup: {e}")
@classmethod
def cleanup_all(cls):
"""Cleanup all tracked instances."""
for instance in list(cls._instances):
instance.cleanup()
print(f"Cleaned up {len(list(cls._instances))} instances")
class RequestContext:
"""
Context manager cho individual requests.
Đảm bảo resources được release sau mỗi request.
"""
def __init__(self, client_manager: AIAPIClientManager):
self.client_manager = client_manager
self.request_start = None
def __enter__(self):
self.request_start = time.time()
return self.client_manager.client
def __exit__(self, exc_type, exc_val, exc_tb):
duration = time.time() - self.request_start
if exc_type:
print(f"Request failed after {duration:.2f}s: {exc_val}")
else:
print(f"Request completed in {duration:.2f}s")
# Force release connection back to pool
# httpx handles this automatically, but we can be explicit
return False # Don't suppress exceptions
Usage
manager = AIAPIClientManager(max_connections=50)
Proper request pattern
with RequestContext(manager) as client:
response = client.post(
"https://api.holysheep.ai/v1/chat/completions",
headers={"Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY"},
json={"model": "deepseek-v3.2", "messages": [{"role": "user", "content": "Hi"}]}
)
Cleanup when shutting down
AIAPIClientManager.cleanup_all()4. Lỗi Context Window Overflow Với Long Conversations
# Vấn đề: Chat history quá dài vượt context window limit
Giải pháp: Intelligent context window management
class ConversationManager:
"""
Manage long conversations với automatic summarization
để fit trong context window.
"""
CONTEXT_LIMITS = {
"gpt-4.1": 128000,
"claude-sonnet-4.5": 200000,
"gemini-2.5-flash": 1000000, # 1M tokens!
"deepseek-v3.2": 64000
}
def __init__(self, model: str = "deepseek-v3.2"):
self.model = model
self.max_tokens = self.CONTEXT_LIMITS.get(model, 64000)
# Reserve tokens cho response
self.max_input_tokens = int(self.max_tokens * 0.8)
self.messages: list = []
def estimate_tokens(self, messages: list) -> int:
"""Estimate token count (rough approximation: 1 token ≈ 4 chars)."""
total_chars = sum(len(str(m.get("content", ""))) for m in messages)
return total_chars // 4
def add_message(self, role: str, content: str):
"""Add message với automatic trimming nếu cần."""
new_message = {"role": role, "content": content}
self.messages.append(new_message)
# Check if we need to trim
while self.estimate_tokens(self.messages) > self.max_input_tokens:
if len(self.messages) <= 2:
# Can't trim further - raise error
raise ValueError(
f"Message too long for {self.model} context window"
)
# Remove oldest non-system message
for i, msg in enumerate(self.messages):
if msg["role"] != "system":
self.messages.pop(i)
break
return self
def get_context_window(self) -> list:
"""Get messages fit trong context window."""
return self.messages.copy()
async def summarize_old_messages(self, client: AIAPIClient) -> list:
"""
Summarize old messages để compress context.
Giữ lại system prompt và recent messages.
"""
if len(self.messages) <= 4:
return self.messages
# Keep system prompt
system_messages = [m for m in self.messages if m["role"] == "system"]
recent_messages = self.messages[-3:] # Keep last 3 messages
# Summarize middle messages
middle_messages = self.messages[len(system_messages):-3]
if not middle_messages:
return self.messages
# Create summarization prompt
summary_prompt = f"""Summarize this conversation concisely,
preserving key information and decisions made:
{middle_messages}
Provide a brief summary (max 200 words):"""
try:
response = await client.chat_completion(
messages=[{"role": "user", "content": summary_prompt}],
model="deepseek-v3.2" # Cheap model for summarization
)
summary_content = response["choices"][0]["message"]["content"]
# Replace middle messages với summary
summarized_messages = system_messages + [
{"role": "system", "content": f"[Previous conversation summary: {summary_content}]"}
] + recent_messages
self.messages = summarized_messages
return summarized_messages
except Exception as e:
print(f"Summarization failed: {e}")
# Fallback: just trim old messages
return system_messages + recent_messages
Usage
conv = ConversationManager(model="deepseek-v3.2")
conv.add_message("system", "You are a helpful assistant.")
conv.add_message("user", "I need help with my order #12345")
conv.add_message("assistant", "Order #12345 is being processed...")
conv.add_message("user", "What's the status?")
Auto-trimmed context ready for API call
context = conv