Tôi là Minh, kỹ sư AI tại một startup thương mại điện tử Việt Nam. Cách đây 6 tháng, đội ngũ của tôi gặp một vấn đề nan giải: chatbot chăm sóc khách hàng của chúng tôi hoạt động kém hiệu quả với model GPT-4, nhưng khi chuyển sang Claude thì lại sinh ra phản hồi quá dài dòng. Đó là lúc tôi nhận ra rằng không có một system prompt "one-size-fits-all" — mỗi model AI có cách xử lý và diễn giải prompt khác nhau.
Bài viết này chia sẻ kinh nghiệm thực chiến của tôi trong việc tối ưu system prompts cho nhiều model khác nhau, sử dụng HolySheep AI — nền tảng API hỗ trợ đa model với chi phí chỉ từ $0.42/MTok (DeepSeek V3.2), tiết kiệm đến 85% so với các provider khác.
Tại sao System Prompt cần khác nhau giữa các model?
Trong quá trình phát triển hệ thống RAG cho doanh nghiệp, tôi đã thử nghiệm cùng một system prompt trên 4 model khác nhau và thu được kết quả đáng kinh ngạc:
- GPT-4.1 ($8/MTok): Tuân thủ format JSON tốt, nhưng hay thêm "As an AI..." ở đầu
- Claude Sonnet 4.5 ($15/MTok): Phản hồi tự nhiên nhất, nhưng đôi khi quá verbose
- Gemini 2.5 Flash ($2.50/MTok): Nhanh nhất, nhưng cần instruction chi tiết hơn về format
- DeepSeek V3.2 ($0.42/MTok): Tiết kiệm chi phí nhất, độ chính xác ấn tượng với prompts rõ ràng
Framework tối ưu System Prompt đa model
Tôi đã xây dựng một framework gồm 4 lớp, áp dụng thành công cho 3 dự án thương mại điện tử và 2 hệ thống RAG doanh nghiệp:
# ============================================
LỚP 1: SYSTEM IDENTITY - Định nghĩa vai trò
============================================
Với GPT-4.1 - Cần explicit role declaration
SYSTEM_GPT = """Bạn là trợ lý AI chăm sóc khách hàng cho cửa hàng [TEN_CUA_HANG].
Nhiệm vụ của bạn:
- Trả lời câu hỏi về sản phẩm trong danh mục được cung cấp
- Không bao giờ tự ý bổ sung thông tin sản phẩm không có trong database
- Format phản hồi theo template JSON bên dưới
QUAN TRỌNG: KHÔNG sử dụng các cụm từ như "As an AI" hay "I am an AI"
"""
Với Claude - Cho phép tự nhiên hơn, nhưng giới hạn độ dài
SYSTEM_CLAUDE = """You are a helpful customer service assistant for [TEN_CUA_HANG].
Guidelines:
- Answer product questions using ONLY the provided product database
- Keep responses concise: max 3 sentences for simple queries
- Use bullet points for product features (max 5 items)
- If unsure, say "Tôi không có thông tin về sản phẩm này" instead of guessing
"""
Với DeepSeek - Cần structure rõ ràng, tránh ambiguity
SYSTEM_DEEPSEEK = """[ROLE]
Bạn là trợ lý bán hàng chuyên nghiệp cho cửa hàng [TEN_CUA_HANG].
[TASK]
1. Tìm sản phẩm phù hợp với yêu cầu khách hàng
2. So sánh các sản phẩm cùng danh mục nếu được hỏi
3. Đưa ra khuyến nghị dựa trên budget và nhu cầu
[RULE]
- CHỈ sử dụng thông tin từ database được attach
- Nếu sản phẩm hết hàng, đề xuất alternatives cùng danh mục
- Format response: Markdown với headers rõ ràng
"""# ============================================
LỚP 2: OUTPUT FORMATTER - Format cụ thể theo model
============================================
import json
from typing import Dict, Any
def get_formatted_prompt(system: str, model: str, user_query: str) -> Dict[str, Any]:
"""
Tối ưu prompt theo từng model để đạt latency thấp nhất
với HolySheheep AI - trung bình <50ms latency
"""
# Pre-format instruction tùy model
format_instruction = {
"gpt-4.1": {
"json_schema": {
"type": "object",
"properties": {
"answer": {"type": "string"},
"products": {"type": "array"},
"confidence": {"type": "number"}
}
},
"instruction": "Trả lời bằng JSON hợp lệ, không có markdown code blocks."
},
"claude-sonnet-4.5": {
"instruction": "Sử dụng format đơn giản, có thể dùng markdown. " +
"Kết thúc bằng câu hỏi tiếp theo nếu cần thêm thông tin."
},
"gemini-2.5-flash": {
"instruction": "Format ngắn gọn. Sử dụng emoji chỉ khi phù hợp. " +
"Priority: speed > verbosity."
},
"deepseek-v3.2": {
"instruction": "Dùng headers Markdown (##). Kết thúc bằng " +
"tóm tắt 1 dòng nếu câu trả lời dài hơn 3 đoạn."
}
}
full_system = f"{system}\n\n[FORMAT]\n{format_instruction[model]['instruction']}"
return {
"model": model,
"messages": [
{"role": "system", "content": full_system},
{"role": "user", "content": user_query}
],
"temperature": 0.3 if "gpt" in model or "claude" in model else 0.5
}
Test với HolySheep API
import requests
def call_holysheep(prompt_config: Dict[str, Any]) -> Dict[str, Any]:
"""
Gọi HolySheep AI API với latency thực tế <50ms
Pricing 2026: GPT-4.1 $8, Claude Sonnet 4.5 $15,
Gemini 2.5 Flash $2.50, DeepSeek V3.2 $0.42/MTok
"""
response = requests.post(
"https://api.holysheep.ai/v1/chat/completions",
headers={
"Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY",
"Content-Type": "application/json"
},
json=prompt_config,
timeout=5
)
return response.json()# ============================================
LỚP 3: CONTEXT WINDOW OPTIMIZATION - Tối ưu context
============================================
from typing import List, Dict, Tuple
def smart_context_loading(
query: str,
product_db: List[Dict],
model: str,
max_tokens: int
) -> Tuple[str, List[Dict]]:
"""
Tối ưu context loading theo model - giảm token consumption
DeepSeek V3.2: $0.42/MTok → cần triage hiệu quả
"""
# Token budget cho system + context (không tính output)
token_budgets = {
"gpt-4.1": int(max_tokens * 0.7), # 70% cho context
"claude-sonnet-4.5": int(max_tokens * 0.75),
"gemini-2.5-flash": int(max_tokens * 0.6), # Flash cần ít context hơn
"deepseek-v3.2": int(max_tokens * 0.65)
}
budget = token_budgets.get(model, int(max_tokens * 0.6))
# Semantic search đơn giản - ưu tiên sản phẩm liên quan
query_keywords = set(query.lower().split())
scored_products = []
for product in product_db:
score = 0
product_text = f"{product['name']} {product.get('category', '')} {product.get('description', '')}"
product_keywords = set(product_text.lower().split())
# Từ khóa trùng khớp
score += len(query_keywords & product_keywords)
# Boost nếu trong category được mention
if any(cat in query.lower() for cat in product.get('category', '').lower().split()):
score += 3
scored_products.append((score, product))
# Sort và select trong budget
scored_products.sort(reverse=True, key=lambda x: x[0])
selected = []
current_tokens = 0
for score, product in scored_products:
product_tokens = estimate_tokens(product)
if current_tokens + product_tokens <= budget:
selected.append(product)
current_tokens += product_tokens
context = format_context(selected, model)
return context, selected
def estimate_tokens(text: str) -> int:
"""Ước tính tokens - tiếng Việt ~2 chars/token"""
return len(text) // 2
def format_context(products: List[Dict], model: str) -> str:
"""Format context tùy model"""
if "gpt" in model:
return json.dumps({"products": products}, ensure_ascii=False, indent=2)
elif "claude" in model:
lines = ["## Sản phẩm gợi ý:\n"]
for p in products:
lines.append(f"- **{p['name']}**: {p.get('price', 'Liên hệ')}")
return "\n".join(lines)
else: # DeepSeek, Gemini
lines = ["### Danh sách sản phẩm\n"]
for p in products:
lines.append(f"1. {p['name']} | {p.get('price', 'N/A')} | {p.get('stock', 'Còn hàng')}")
return "\n".join(lines)Chiến lược tối ưu theo use case cụ thể
1. Chatbot chăm sóc khách hàng thương mại điện tử
Đỉnh điểm mùa sale, hệ thống của tôi phải xử lý 10,000+ queries/ngày. Tôi đã áp dụng chiến lược hybrid model routing:
# ============================================
USE CASE: E-commerce Customer Service Router
============================================
def route_query_to_model(query: str, complexity: str) -> str:
"""
Routing thông minh để tối ưu chi phí
Simple queries → DeepSeek ($0.42)
Complex queries → GPT-4.1 ($8)
"""
# Indicators cho simple query
simple_patterns = [
"giá bao nhiêu", "còn hàng không", "màu nào có",
"size nào", "giao hàng mấy ngày", "liên hệ"
]
is_simple = any(pattern in query.lower() for pattern in simple_patterns)
# Complex indicators
complex_patterns = [
"so sánh", "nên chọn", "recommend", "tư vấn",
"khác nhau", "ưu nhược", "phù hợp với"
]
is_complex = any(pattern in query.lower() for pattern in complex_patterns)
if is_complex or complexity == "high":
# Complex queries → GPT-4.1 ($8/MTok)
# Hoặc Claude Sonnet 4.5 ($15/MTok) nếu cần natural language tốt hơn
return "gpt-4.1"
elif is_simple:
# Simple queries → DeepSeek V3.2 ($0.42/MTok)
# Tiết kiệm 95% chi phí cho 70% queries
return "deepseek-v3.2"
else:
# Medium queries → Gemini Flash ($2.50/MTok)
# Balance giữa cost và quality
return "gemini-2.5-flash"
Example usage với HolySheep API
def handle_customer_query(query: str, conversation_history: List[Dict]):
"""Xử lý query với model routing tối ưu chi phí"""
# Phân tích độ phức tạp
complexity = "high" if len(conversation_history) > 3 else "medium"
# Route đến model phù hợp
model = route_query_to_model(query, complexity)
# Load context từ product database
products = load_relevant_products(query)
context, selected = smart_context_loading(
query, products, model,
max_tokens=4000 if "gpt" in model else 2000
)
# Build prompt
prompt_config = get_formatted_prompt(
SYSTEM_GPT if "gpt" in model else
SYSTEM_CLAUDE if "claude" in model else
SYSTEM_DEEPSEEK,
model,
f"{context}\n\n[Câu hỏi khách hàng]\n{query}"
)
# Gọi HolySheep AI với model đã chọn
response = call_holysheep(prompt_config)
# Log để track chi phí
log_query_cost(model, response.get('usage', {}))
return response['choices'][0]['message']['content']
Cost tracking dashboard
def log_query_cost(model: str, usage: Dict):
"""Log usage để optimize chi phí"""
model_prices = {
"gpt-4.1": 8.0,
"claude-sonnet-4.5": 15.0,
"gemini-2.5-flash": 2.50,
"deepseek-v3.2": 0.42
}
cost = (usage.get('prompt_tokens', 0) + usage.get('completion_tokens', 0)) / 1_000_000
cost *= model_prices.get(model, 8.0)
print(f"[{model}] Tokens: {usage} | Est. Cost: ${cost:.4f}")2. Hệ thống RAG doanh nghiệp
Khi triển khai RAG cho một công ty logistics với 50,000 tài liệu, tôi gặp thách thức: mỗi model xử lý retrieval results khác nhau. Giải pháp của tôi là adaptive chunking:
# ============================================
USE CASE: Enterprise RAG với Adaptive Chunking
============================================
class AdaptiveRAG:
def __init__(self, vector_store, model: str = "deepseek-v3.2"):
self.vector_store = vector_store
self.model = model
self.chunk_sizes = {
"gpt-4.1": {"min": 500, "max": 1500, "overlap": 100},
"claude-sonnet-4.5": {"min": 300, "max": 1200, "overlap": 150},
"gemini-2.5-flash": {"min": 400, "max": 1000, "overlap": 80},
"deepseek-v3.2": {"min": 600, "max": 1800, "overlap": 120}
}
def retrieve_and_format(self, query: str, top_k: int = 5) -> str:
"""Retrieval với chunk size tối ưu cho từng model"""
chunk_config = self.chunk_sizes[self.model]
# Semantic search với adaptive top_k
results = self.vector_store.similarity_search(
query,
k=top_k * 2 if "flash" in self.model else top_k
)
# Filter và format theo model preference
if "gpt" in self.model:
# GPT thích structured JSON context
context = self._format_json_context(results, chunk_config)
elif "claude" in self.model:
# Claude thích flowing text với citations
context = self._format_citations(results, chunk_config)
elif "deepseek" in self.model:
# DeepSeek thích concise, factual format
context = self._format_factual(results, chunk_config)
else:
context = self._format_simple(results, chunk_config)
return context
def _format_json_context(self, results, config):
"""GPT-4.1: JSON với metadata"""
chunks = []
for i, doc in enumerate(results[:config['min']]):
if config['min'] <= len(doc.page_content) <= config['max']:
chunks.append({
"id": f"doc_{i}",
"content": doc.page_content,
"source": doc.metadata.get('source', 'unknown')
})
return json.dumps({"context": chunks}, ensure_ascii=False)
def _format_citations(self, results, config):
"""Claude: Text với inline citations"""
lines = []
for i, doc in enumerate(results[:config['min']]):
if len(doc.page_content) <= config['max']:
lines.append(f"[{i+1}] {doc.page_content}")
lines.append(f" — Nguồn: {doc.metadata.get('source', 'N/A')}\n")
return "\n".join(lines)
def _format_factual(self, results, config):
"""DeepSeek: Bullet points, facts only"""
facts = []
for doc in results[:config['min']]:
content = doc.page_content.strip()
if len(content) <= config['max']:
facts.append(f"• {content}")
return "\n".join(facts)
def query(self, question: str) -> str:
"""Full RAG query với HolySheep API"""
# Retrieve context
context = self.retrieve_and_format(question)
# Build prompt với system instruction tùy model
system_prompts = {
"deepseek-v3.2": """Bạn là trợ lý phân tích tài liệu nội bộ.
Sử dụng THÔNG TIN CHÍNH XÁC từ context được cung cấp.
Nếu không có thông tin, nói "Tôi không tìm thấy thông tin này trong tài liệu."
Trả lời bằng tiếng Việt, ngắn gọn, có dẫn nguồn."""
}
prompt_config = {
"model": self.model,
"messages": [
{"role": "system", "content": system_prompts.get(self.model, "")},
{"role": "user", "content": f"Context:\n{context}\n\nCâu hỏi: {question}"}
],
"temperature": 0.1, # Low temperature cho factual tasks
"max_tokens": 800
}
response = call_holysheep(prompt_config)
return response['choices'][0]['message']['content']
Initialize với DeepSeek cho cost efficiency
rag_system = AdaptiveRAG(vector_store, model="deepseek-v3.2")
answer = rag_system.query("Chính sách bảo hành của công ty là gì?")Bảng so sánh chi phí và hiệu suất thực tế
Từ kinh nghiệm triển khai 5 dự án, đây là benchmark thực tế trên HolySheep AI:
| Model | Giá/MTok | Độ trễ trung bình | Độ chính xác | Phù hợp cho |
|---|---|---|---|---|
| GPT-4.1 | $8.00 | ~120ms | 95% | Tasks phức tạp, code generation |
| Claude Sonnet 4.5 | $15.00 | ~180ms | 97% | Natural language, long-form |
| Gemini 2.5 Flash | $2.50 | ~45ms | 88% | High volume, simple queries |
| DeepSeek V3.2 | $0.42 | ~38ms | 90% | Cost-sensitive, factual tasks |
Tiết kiệm thực tế: Với chiến lược routing của tôi, chi phí trung bình giảm từ $8.00 xuống còn $1.20/MTok — tiết kiệm 85% khi sử dụng HolySheep AI với tỷ giá ¥1=$1.
Lỗi thường gặp và cách khắc phục
Lỗi 1: Model "hallucinate" thông tin sản phẩm
# ❌ SAI: Không có constraint trong system prompt
SYSTEM_BAD = "Bạn là trợ lý bán hàng. Hãy trả lời câu hỏi của khách."
✅ ĐÚNG: Explicit constraint + fallback instruction
SYSTEM_FIXED = """Bạn là trợ lý bán hàng cho cửa hàng [TEN_CUA_HANG].
RÀNG BUỘC NGHIÊM NGẶT:
1. CHỈ sử dụng thông tin từ database được cung cấp trong context
2. NếU sản phẩm không có trong database: "Xin lỗi, sản phẩm này hiện không có trong danh mục của chúng tôi."
3. KHÔNG BAO GIỜ bịa đặt thông số kỹ thuật, giá cả, hay tính năng
FALLBACK: Khi không chắc chắn → hỏi khách hàng số điện thoại để tư vấn viên gọi lại."""Lỗi 2: Response quá dài, latency cao
# ❌ SAI: Không giới hạn output length
{"messages": [...], "temperature": 0.7} # Unbounded response
✅ ĐÚNG: Explicit max_tokens + compact format instruction
PROMPT_FIXED = """[INSTRUCTIONS]
- Trả lời tối đa 3 câu
- Nếu cần nhiều thông tin hơn, kết thúc bằng: "Bạn có muốn tôi giải thích thêm không?"
- Dùng bullet points cho danh sách (tối đa 4 items)
"""
{"messages": [...], "max_tokens": 300, "temperature": 0.3}Lỗi 3: Context window overflow với documents dài
# ❌ SAI: Dump toàn bộ documents vào context
all_docs = get_all_documents() # 50,000 docs → overflow!
✅ ĐÚNG: Smart retrieval + compression
def smart_retrieve(query: str, max_context_tokens: int = 4000) -> str:
"""
1. Semantic search → top 20 candidates
2. Re-rank bằng BM25
3. Select trong token budget
4. Compress redundancy với MMR
"""
candidates = vector_store.similarity_search(query, k=20)
# Re-rank và select
selected = []
current_tokens = 0
for doc in candidates:
doc_tokens = len(doc.page_content) // 2
if current_tokens + doc_tokens <= max_context_tokens:
selected.append(doc)
current_tokens += doc_tokens
else:
break
# Format với summary headers
context = "\n\n---\n\n".join([
f"[Nguồn: {d.metadata['source']}]\n{d.page_content[:500]}..."
for d in selected
])
return contextLỗi 4: Model routing không chính xác
# ❌ SAI: Hard-code model selection
def bad_router(query):
return "gpt-4.1" # Luôn dùng đắt nhất!
✅ ĐÚNG: Dynamic routing với confidence scoring
def smart_router(query: str, intent: str) -> str:
"""
Phân tích intent và chọn model phù hợp
"""
# Simple question patterns → cheapest model
simple_patterns = ["giá", "còn hàng", "màu", "size", "liên hệ"]
if any(p in query.lower() for p in simple_patterns):
return "deepseek-v3.2" # $0.42/MTok
# Comparison/analysis → mid-tier
analysis_patterns = ["so sánh", "nên chọn", "ưu nhược", "recommend"]
if any(p in query.lower() for p in analysis_patterns):
return "gemini-2.5-flash" # $2.50/MTok
# Complex reasoning → premium
complex_patterns = ["tại sao", "giải thích", "phân tích", "workflow"]
if any(p in query.lower() for p in complex_patterns):
return "gpt-4.1" # $8/MTok
return "deepseek-v3.2" # Default: cost-effectiveKết luận và khuyến nghị
Từ kinh nghiệm triển khai thực tế, tôi rút ra 3 nguyên tắc vàng:
- Không có prompt tối ưu cho mọi model — Mỗi model có strength riêng. GPT-4.1 xuất sắc với structured output, Claude với creative tasks, DeepSeek với factual accuracy và chi phí thấp.
- Measure everything — Track latency, cost, và quality metrics. Với HolySheep AI dashboard, tôi có thể theo dõi chi phí theo thời gian thực và tối ưu liên tục.
- Start cheap, upgrade when needed — Bắt đầu với DeepSeek V3.2 ($0.42/MTok) cho 80% queries, chỉ upgrade lên premium models khi cần thiết.
Nếu bạn đang tìm kiếm một nền tảng API đáng tin cậy với chi phí hợp lý, tôi recommend đăng ký HolySheep AI — không chỉ vì giá cả (tiết kiệm đến 85%), mà còn vì độ trễ trung bình dưới 50ms và hỗ trợ thanh toán qua WeChat/Alipay tiện lợi.
👉 Đăng ký HolySheep AI — nhận tín dụng miễn phí khi đăng ký