Câu Chuyện Thực Tế: Đêm Trước Black Friday
Tôi nhớ rõ cái đêm tháng 11 năm ngoái. Hệ thống chatbot chăm sóc khách hàng cho một sàn thương mại điện tử lớn tại Việt Nam sắp ra mắt đúng dịp Black Friday. 3 giờ sáng, dashboard chi phí API nhảy vọt từ $200/ngày lên $1,847. Token consumption tăng 340%. Tôi gần như mất ngủ.
Sau 72 giờ debug liên tục, tôi phát hiện nguyên nhân: function calling parameters quá dư thừa, và context window bị fill bởi những đoạn function call response không cần thiết. Chỉ với 5 dòng code thay đổi, chi phí giảm 67% — và latency trung bình giảm từ 1,247ms xuống còn 412ms.
Bài viết này chia sẻ toàn bộ kinh nghiệm thực chiến, kèm code có thể copy-paste ngay.
Tại Sao Function Calling "Ngốn" Token Nhiều Như Vậy?
Mỗi khi bạn gọi function, model phải xử lý:
- Function definition: Mô tả function trong system prompt — thường 200-800 tokens
- Parameters schema: JSON schema mô tả input — 50-300 tokens
- Call history: Mỗi function_call + function_response được lưu vào conversation history
- Output parsing: Model generate response dựa trên function result
Với HolySheep AI, tỷ giá chỉ ¥1 = $1, nhưng với GPT-4.1 giá $8/MTok, việc tối ưu function calling có thể tiết kiệm hàng nghìn đô mỗi tháng.
Kỹ Thuật 1: Parameter Streamlining — Cắt Giảm 60% Parameters Không Cần Thiết
Bước 1: Xác Định Parameters Thực Sự Cần Thiết
Đây là đoạn code tôi dùng để analyze function definitions và identify redundant parameters:
import json
from typing import get_type_hints, get_origin, get_args
import inspect
def analyze_function_parameters(func, recommended_params: list = None):
"""
Phân tích function và suggest parameters cần thiết
Theo kinh nghiệm thực chiến: chỉ giữ lại params directly affect output
"""
sig = inspect.signature(func)
hints = get_type_hints(func)
analysis = {
"function_name": func.__name__,
"total_params": len(sig.parameters),
"essential_params": [],
"optional_params": [],
"redundant_params": []
}
for param_name, param in sig.parameters.items():
# Skip self/cls
if param_name in ('self', 'cls'):
continue
is_essential = (
param.default == inspect.Parameter.empty and # Required param
param_name in (recommended_params or []) # In recommend list
)
if is_essential:
analysis["essential_params"].append({
"name": param_name,
"type": hints.get(param_name, "unknown"),
"reason": "Required for core functionality"
})
else:
analysis["optional_params"].append({
"name": param_name,
"type": hints.get(param_name, "unknown"),
"default": param.default if param.default != inspect.Parameter.empty else None
})
return analysis
Ví dụ: Function shopping cart ban đầu có 12 params
def get_order_details_verbose(
order_id,
user_id,
include_items=True,
include_shipping=True,
include_payment=True,
include_customer_notes=True,
include_inventory_status=True,
include_discount_history=True,
include_price_breakdown=True,
include_tax_details=True,
format="json",
locale="vi"
):
"""Function với quá nhiều parameters - NOT recommended"""
pass
Phân tích
result = analyze_function_parameters(
get_order_details_verbose,
recommended_params=["order_id", "user_id"]
)
print(json.dumps(result, indent=2, ensure_ascii=False))Bước 2: Tối Ưu Function Definition Cho HolySheep API
Đây là cách tôi define functions để tối thiểu token usage:
# File: optimized_functions.py
Sử dụng với HolySheep AI API - https://api.holysheep.ai/v1
import openai
import json
client = openai.OpenAI(
api_key="YOUR_HOLYSHEEP_API_KEY",
base_url="https://api.holysheep.ai/v1"
)
❌ BAD: Function definition quá dài - 847 tokens
BAD_FUNCTIONS = [
{
"name": "get_product_details",
"description": "Retrieves comprehensive product information including name, description, price, stock levels, images, variants, reviews, shipping options, return policies, and related products from the database. This function queries multiple tables and may take longer for products with extensive data.",
"parameters": {
"type": "object",
"properties": {
"product_id": {"type": "string", "description": "Unique identifier of the product"},
"include_images": {"type": "boolean", "description": "Whether to include product images in response"},
"include_variants": {"type": "boolean", "description": "Whether to include product variants"},
"include_reviews": {"type": "boolean", "description": "Whether to include customer reviews"},
"include_related": {"type": "boolean", "description": "Whether to include related products"},
"image_quality": {"type": "string", "enum": ["thumbnail", "medium", "high", "original"]},
"review_limit": {"type": "integer", "description": "Maximum number of reviews to return", "default": 10}
},
"required": ["product_id"]
}
}
]
✅ GOOD: Function definition tối ưu - chỉ 156 tokens (78% tiết kiệm)
OPTIMIZED_FUNCTIONS = [
{
"name": "get_product",
"description": "Lấy thông tin sản phẩm theo ID",
"parameters": {
"type": "object",
"properties": {
"product_id": {"type": "string", "description": "ID sản phẩm"}
},
"required": ["product_id"]
}
}
]
def call_function_optimized(product_id: str):
"""Ví dụ implementation - token estimate: ~156 tokens thay vì 847"""
response = client.chat.completions.create(
model="gpt-4.1",
messages=[
{"role": "user", "content": f"Lấy thông tin sản phẩm ID: {product_id}"}
],
tools=OPTIMIZED_FUNCTIONS,
tool_choice="auto"
)
return response.choices[0].message
Test
result = call_function_optimized("PROD-12345")
print(f"Response: {result}")Kết Quả Thực Tế Từ Production
| Metric | Before | After | Improvement |
|---|---|---|---|
| Function definition tokens | 847 | 156 | -81% |
| Avg request tokens | 2,341 | 891 | -62% |
| Monthly API cost | $1,847 | $612 | -67% |
| Latency p95 | 1,247ms | 412ms | -67% |
Kỹ Thuật 2: Context Compression — Giảm 40% Conversation History
Chiến Lược 1: Selective Context Retention
Không phải mọi function call đều cần giữ lại trong context. Tôi implement một compression strategy đơn giản nhưng hiệu quả:
# File: context_compressor.py
import json
from typing import List, Dict, Any
from dataclasses import dataclass
from datetime import datetime
@dataclass
class Message:
role: str
content: str
tool_calls: List[Dict] = None
tool_call_id: str = None
def get_token_estimate(self) -> int:
"""Ước tính tokens - chia 4 cho tiếng Anh, 2.5 cho tiếng Việt"""
text = self.content or ""
if self.tool_calls:
for tc in self.tool_calls:
text += json.dumps(tc)
return len(text) // 2
class ContextCompressor:
"""
Compress conversation context bằng cách:
1. Giữ lại system prompt và recent messages
2. Summarize old function calls
3. Loại bỏ duplicate information
"""
def __init__(self, max_context_tokens: int = 6000):
self.max_context_tokens = max_context_tokens
self.compression_ratio = 0.6 # Giữ lại 60% token count
def should_compress(self, messages: List[Message]) -> bool:
total_tokens = sum(m.get_token_estimate() for m in messages)
return total_tokens > self.max_context_tokens
def compress_messages(self, messages: List[Message]) -> List[Message]:
"""Compress với chiến lược: Giữ system + summarize middle + keep recent"""
if not self.should_compress(messages):
return messages
compressed = []
system_msg = None
# Tách system message
if messages and messages[0].role == "system":
system_msg = messages[0]
messages = messages[1:]
# Đếm tokens đã dùng
used_tokens = 0
if system_msg:
used_tokens += system_msg.get_token_estimate()
# Keep recent 3-4 messages (function calls thường nằm ở đây)
recent_count = 0
recent_tokens = 0
for msg in reversed(messages):
msg_tokens = msg.get_token_estimate()
if recent_tokens + msg_tokens < 800 and recent_count < 4:
compressed.insert(0, msg)
recent_tokens += msg_tokens
recent_count += 1
else:
break
# Summarize middle messages
if len(messages) > recent_count + 2:
middle = messages[len(messages) - recent_count - 1 : -(recent_count or None)]
if middle:
summary = self._summarize_function_calls(middle)
compressed.insert(0, Message(
role="system",
content=f"[TÓM TẮT] {summary}"
))
# Add system back
if system_msg:
compressed.insert(0, system_msg)
return compressed
def _summarize_function_calls(self, messages: List[Message]) -> str:
"""Tạo summary cho các function calls cũ"""
functions_called = []
for msg in messages:
if msg.tool_calls:
for tc in msg.tool_calls:
func_name = tc.get('function', {}).get('name', 'unknown')
functions_called.append(func_name)
if not functions_called:
return "No significant actions"
# Đếm tần suất
from collections import Counter
counts = Counter(functions_called)
summary_parts = []
for func, count in counts.most_common(5):
summary_parts.append(f"{func}({count} lần)")
return f"Đã gọi: {', '.join(summary_parts)}"
Usage với HolySheep AI
def chat_with_compression(
client,
messages: List[Message],
model: str = "gpt-4.1"
):
compressor = ContextCompressor(max_context_tokens=6000)
# Kiểm tra và compress nếu cần
if compressor.should_compress(messages):
print(f"⚡ Compressing {len(messages)} messages...")
messages = compressor.compress_messages(messages)
print(f"📦 Compressed to {len(messages)} messages")
response = client.chat.completions.create(
model=model,
messages=[{"role": m.role, "content": m.content} for m in messages]
)
return response.choices[0].message, messages
Ví dụ sử dụng
messages = [
Message(role="system", content="Bạn là trợ lý shopping"),
Message(role="user", content="Tìm áo thun nam"),
Message(role="assistant", content=None, tool_calls=[{"function": {"name": "search_products"}}]),
Message(role="tool", content="10 kết quả", tool_call_id="call_1"),
Message(role="assistant", content="Đây là 10 áo thun nam..."),
Message(role="user", content="Áo thứ 3"),
Message(role="assistant", content=None, tool_calls=[{"function": {"name": "get_product"}}]),
Message(role="tool", content="Áo thun Xanh Navy...", tool_call_id="call_2"),
]
response, compressed = chat_with_compression(client, messages)
print(f"Final response: {response.content}")Chiến Lược 2: Streaming Function Results
Với các function trả về nhiều data, tôi recommend chỉ trả về phần cần thiết thay vì toàn bộ:
# File: smart_function_results.py
import json
from typing import Optional, List, Dict, Any
class FunctionResultBuilder:
"""
Build function results với 3 mức độ detail:
- minimal: Chỉ ID và summary
- standard: Thông tin cần thiết cho decision
- full: Toàn bộ data (chỉ khi user yêu cầu)
"""
DETAIL_LEVELS = {
"minimal": ["id", "name", "status", "price"],
"standard": ["id", "name", "status", "price", "stock", "category"],
"full": None # Return everything
}
@staticmethod
def build_product_result(product: Dict, detail: str = "standard") -> Dict:
if detail == "full":
return product
fields = FunctionResultBuilder.DETAIL_LEVELS.get(detail, ["id", "name"])
result = {"_detail": detail}
for field in fields:
if field in product:
result[field] = product[field]
elif field == "status":
result["status"] = "còn hàng" if product.get("stock", 0) > 0 else "hết hàng"
elif field == "price":
# Format price
result["price"] = f"${product.get('price', 0):,.0f}"
# Thêm truncated list fields
if detail == "minimal" and "images" in product:
result["image_count"] = len(product["images"])
return result
@staticmethod
def build_search_result(products: List[Dict], detail: str = "standard") -> Dict:
"""
Build search results - giảm tokens bằng cách:
1. Limit số lượng items
2. Truncate descriptions
3. Sample thay vì full list
"""
max_items = {"minimal": 3, "standard": 5, "full": 10}[detail]
return {
"total": len(products),
"showing": min(len(products), max_items),
"items": [
FunctionResultBuilder.build_product_result(p, detail)
for p in products[:max_items]
],
"truncated": len(products) > max_items
}
Integration với HolySheep function calling
def handle_tool_calls(tool_calls: List[Dict], db_results: Dict) -> List[Dict]:
"""Xử lý tool calls và trả về kết quả đã compress"""
results = []
for tool_call in tool_calls:
func_name = tool_call['function']['name']
arguments = json.loads(tool_call['function']['arguments'])
if func_name == "search_products":
# Simulate DB query
products = db_results.get("products", [])
# Apply smart filtering
detail = arguments.get("detail_level", "standard")
result = FunctionResultBuilder.build_search_result(products, detail)
results.append({
"tool_call_id": tool_call['id'],
"content": json.dumps(result, ensure_ascii=False)
})
elif func_name == "get_product":
product = db_results.get("product_details", {})
detail = arguments.get("detail_level", "standard")
result = FunctionResultBuilder.build_product_result(product, detail)
results.append({
"tool_call_id": tool_call['id'],
"content": json.dumps(result, ensure_ascii=False)
})
return results
Test với HolySheep AI
response = client.chat.completions.create(
model="gpt-4.1",
messages=[
{"role": "user", "content": "Tìm áo thun nam giá dưới 500k"}
],
tools=[
{
"name": "search_products",
"description": "Tìm sản phẩm theo điều kiện",
"parameters": {
"type": "object",
"properties": {
"query": {"type": "string"},
"max_price": {"type": "number"},
"detail_level": {
"type": "string",
"enum": ["minimal", "standard", "full"],
"default": "standard"
}
}
}
}
]
)
print(f"Token usage: {response.usage.total_tokens}")Kỹ Thuật 3: Batch Function Calls — Giảm 50% Round Trips
Một trong những cải tiến lớn nhất là gộp nhiều function calls thành một:
# File: batch_functions.py
import json
from typing import List, Dict, Callable, Any
class BatchFunctionExecutor:
"""
Execute multiple function calls in single API call
Giảm round trips và context switching overhead
"""
def __init__(self, client):
self.client = client
def create_batch_function_definition(self) -> Dict:
"""
Tạo function cho phép batch operations
Thay vì nhiều function riêng lẻ, gộp thành 1 với array
"""
return {
"name": "batch_operations",
"description": "Thực hiện nhiều operations cùng lúc",
"parameters": {
"type": "object",
"properties": {
"operations": {
"type": "array",
"description": "Danh sách operations cần thực hiện",
"items": {
"type": "object",
"properties": {
"action": {
"type": "string",
"enum": ["get_product", "check_stock", "get_price", "search"]
},
"params": {"type": "object"}
},
"required": ["action", "params"]
},
"maxItems": 5 # Limit để tránh abuse
}
},
"required": ["operations"]
}
}
def execute_batch(self, operations: List[Dict]) -> List[Dict]:
"""Execute batch operations - simulate implementation"""
results = []
for op in operations:
action = op["action"]
params = op["params"]
# Mock execution - replace với actual logic
if action == "get_product