Năm 2026, kỷ nguyên AI Agent đã chín muồi. Việc xây dựng một hệ thống tự động hóa có thể gọi nhiều công cụ, xử lý ngữ cảnh phức tạp và ra quyết định theo chuỗi không còn là đặc quyền của những tập đoàn lớn. Bài viết này sẽ hướng dẫn bạn xây dựng một AI Agent workflow hoàn chỉnh sử dụng MCP (Model Context Protocol) kết hợp LangGraph để điều phối nhiều tool một cách thông minh.

So sánh chi phí: HolySheep AI vs các giải pháp khác

Trước khi bắt đầu, hãy cùng xem lý do tại sao HolySheep AI là lựa chọn tối ưu cho việc xây dựng AI Agent production:

Tiêu chí HolySheep AI API chính thức Dịch vụ Relay khác
Tỷ giá ¥1 = $1 (85%+ tiết kiệm) $30-50/1M tokens $15-25/1M tokens
Thanh toán WeChat, Alipay, USDT Chỉ thẻ quốc tế Hạn chế
Độ trễ trung bình <50ms 200-500ms 100-300ms
Tín dụng miễn phí Có khi đăng ký Không Ít khi
GPT-4.1 $8/1M tokens $60/1M tokens $15-20/1M tokens
Claude Sonnet 4.5 $15/1M tokens $75/1M tokens $25-35/1M tokens
Gemini 2.5 Flash $2.50/1M tokens $10/1M tokens $5-7/1M tokens
DeepSeek V3.2 $0.42/1M tokens Không hỗ trợ $1-2/1M tokens

Như bạn thấy, với mức giá chỉ từ $0.42/1M tokens cho DeepSeek V3.2 và <50ms độ trễ, HolySheep là lựa chọn lý tưởng cho production AI Agent. Bây giờ, hãy bắt đầu xây dựng hệ thống!

MCP Protocol là gì và tại sao cần nó?

MCP (Model Context Protocol) là một giao thức chuẩn hóa cho phép AI models giao tiếp với các external tools và data sources. Thay vì hard-code từng tool riêng lẻ, MCP tạo ra một abstraction layer giúp:

Kiến trúc tổng quan Agent Workflow


┌─────────────────────────────────────────────────────────────┐
│                    USER REQUEST                             │
│              "Tìm kiếm thông tin về AAPL,                   │
│               phân tích và lưu vào database"                │
└─────────────────────┬───────────────────────────────────────┘
                      │
                      ▼
┌─────────────────────────────────────────────────────────────┐
│                    LANGGRAPH GRAPH                          │
│  ┌──────────┐    ┌──────────┐    ┌──────────┐              │
│  │  ROUTER  │───▶│ TOOL_1   │───▶│ TOOL_2   │───▶ ...      │
│  │  (LLM)   │    │ (Search) │    │ (Store)  │              │
│  └──────────┘    └──────────┘    └──────────┘              │
│       │               │               │                     │
│       ▼               ▼               ▼                     │
│  ┌──────────────────────────────────────────┐              │
│  │         STATE MANAGEMENT                  │              │
│  │   (Conversation context + Tool results)  │              │
│  └──────────────────────────────────────────┘              │
└─────────────────────┬───────────────────────────────────────┘
                      │
                      ▼
┌─────────────────────────────────────────────────────────────┐
│                    HOLYSHEEP AI                             │
│           base_url: api.holysheep.ai/v1                    │
│           Model: gpt-4.1 / claude-sonnet-4.5               │
└─────────────────────────────────────────────────────────────┘

Cài đặt môi trường và dependencies

# requirements.txt
langgraph>=0.0.20
langchain>=0.1.0
langchain-openai>=0.0.5
mcp>=1.0.0
pydantic>=2.0.0
asyncio>=3.4.3
httpx>=0.25.0
python-dotenv>=1.0.0


Cài đặt

pip install -r requirements.txt

Triển khai MCP Server cho custom tools

Đầu tiên, chúng ta cần tạo MCP server để expose các tools của mình. Dưới đây là ví dụ triển khai một search tool và database tool:

# mcp_server.py
from mcp.server import Server
from mcp.types import Tool, TextContent
from pydantic import AnyUrl
import asyncio
import httpx


Khởi tạo MCP Server

server = Server("ai-agent-tools")

@server.list_tools()
async def list_tools() -> list[Tool]:
    """Định nghĩa tất cả tools có sẵn"""
    return [
        Tool(
            name="web_search",
            description="Tìm kiếm thông tin trên web",
            inputSchema={
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Từ khóa tìm kiếm"},
                    "max_results": {"type": "integer", "default": 5}
                },
                "required": ["query"]
            }
        ),
        Tool(
            name="save_to_db",
            description="Lưu dữ liệu vào database",
            inputSchema={
                "type": "object",
                "properties": {
                    "table": {"type": "string"},
                    "data": {"type": "object"}
                },
                "required": ["table", "data"]
            }
        ),
        Tool(
            name="calculate",
            description="Thực hiện phép tính toán",
            inputSchema={
                "type": "object",
                "properties": {
                    "expression": {"type": "string"}
                },
                "required": ["expression"]
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    """Xử lý tool calls"""
    
    if name == "web_search":
        # Simulated search - thay bằng API thực tế
        query = arguments["query"]
        max_results = arguments.get("max_results", 5)
        
        results = await perform_search(query, max_results)
        return [TextContent(type="text", text=str(results))]
    
    elif name == "save_to_db":
        table = arguments["table"]
        data = arguments["data"]
        
        # Simulated DB save
        saved_id = await save_data(table, data)
        return [TextContent(type="text", text=f"Đã lưu thành công với ID: {saved_id}")]
    
    elif name == "calculate":
        expression = arguments["expression"]
        result = eval(expression)  # Cẩn thận: production nên dùng safe eval
        return [TextContent(type="text", text=f"Kết quả: {result}")]
    
    return [TextContent(type="text", text="Tool không được hỗ trợ")]

async def perform_search(query: str, max_results: int) -> dict:
    """Mock search function - thay bằng search API thực tế"""
    await asyncio.sleep(0.1)  # Simulate network delay
    return {
        "query": query,
        "results": [
            {"title": f"Kết quả {i+1} cho {query}", "url": f"https://example.com/{i}"}
            for i in range(max_results)
        ]
    }

async def save_data(table: str, data: dict) -> str:
    """Mock save function - thay bằng database thực tế"""
    await asyncio.sleep(0.05)
    return f"{table}_{hash(str(data)) % 100000}"

if __name__ == "__main__":
    import mcp.server.stdio
    
    async def main():
        async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
            await server.run(
                read_stream,
                write_stream,
                server.create_initialization_options()
            )
    
    asyncio.run(main())

Xây dựng LangGraph Agent với MCP Integration

Đây là phần cốt lõi - kết hợp LangGraph state machine với MCP tools:

# agent_workflow.py
import os
from typing import TypedDict, Annotated, Sequence
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
from langgraph.graph import StateGraph, END
from langgraph.prebuilt import ToolNode
import json


Cấu hình HolySheep API - TUYỆT ĐỐI KHÔNG dùng api.openai.com

os.environ["OPENAI_API_BASE"] = "https://api.holysheep.ai/v1"
os.environ["OPENAI_API_KEY"] = "YOUR_HOLYSHEEP_API_KEY"  # Thay bằng API key thực tế


Định nghĩa State cho LangGraph

class AgentState(TypedDict):
    messages: Annotated[Sequence[HumanMessage | AIMessage], "conversation"]
    tool_results: dict
    current_step: str
    context: dict


Khởi tạo LLM với HolySheep

llm = ChatOpenAI(
    model="gpt-4.1",  # Hoặc "claude-sonnet-4.5", "gemini-2.5-flash"
    temperature=0.7,
    api_key=os.environ["OPENAI_API_KEY"],
    base_url=os.environ["OPENAI_API_BASE"]
)


Định nghĩa tools cho LangGraph

def get_tools():
    """Trả về danh sách tools - kết nối với MCP server"""
    return [
        {
            "name": "web_search",
            "description": "Tìm kiếm thông tin trên web",
            "function": web_search_tool
        },
        {
            "name": "save_to_db", 
            "description": "Lưu dữ liệu vào database",
            "function": save_to_db_tool
        },
        {
            "name": "calculate",
            "description": "Thực hiện phép tính toán",
            "function": calculate_tool
        }
    ]

def web_search_tool(query: str, max_results: int = 5) -> str:
    """Tool tìm kiếm web"""
    # Trong production, gọi đến MCP server hoặc search API
    results = f"Tìm thấy {max_results} kết quả cho: {query}"
    return results

def save_to_db_tool(table: str, data: dict) -> str:
    """Tool lưu database"""
    return f"Đã lưu vào bảng {table}: {json.dumps(data)}"

def calculate_tool(expression: str) -> str:
    """Tool tính toán"""
    try:
        result = eval(expression)
        return f"Kết quả: {result}"
    except:
        return "Lỗi: Biểu thức không hợp lệ"


Bind tools vào LLM

tools = get_tools()
llm_with_tools = llm.bind_tools(tools)

def should_continue(state: AgentState) -> str:
    """Quyết định có tiếp tục gọi tool hay kết thúc"""
    last_message = state["messages"][-1]
    
    # Nếu có tool_calls → tiếp tục gọi tool
    if hasattr(last_message, "tool_calls") and last_message.tool_calls:
        return "action"
    
    # Nếu không có tool_calls hoặc đã gọi xong → kết thúc
    return "end"

def call_model(state: AgentState) -> AgentState:
    """Gọi LLM để quyết định hành động"""
    system_prompt = SystemMessage(content="""Bạn là một AI Agent thông minh.
    Nhiệm vụ của bạn:
    1. Phân tích yêu cầu của user
    2. Quyết định cần gọi tool nào (nếu cần)
    3. Trả lời user sau khi có kết quả
    
    Các tools có sẵn:
    - web_search: Tìm kiếm thông tin
    - save_to_db: Lưu dữ liệu
    - calculate: Tính toán
    
    Luôn suy nghĩ step-by-step và gọi đúng tool cho đúng task.""")

    response = llm_with_tools.invoke([system_prompt] + state["messages"])
    
    return {
        "messages": state["messages"] + [response],
        "tool_results": state.get("tool_results", {}),
        "current_step": "model_called",
        "context": state.get("context", {})
    }

def execute_tool(state: AgentState) -> AgentState:
    """Thực thi tool và cập nhật state"""
    last_message = state["messages"][-1]
    tool_results = state.get("tool_results", {})
    
    if hasattr(last_message, "tool_calls"):
        for tool_call in last_message.tool_calls:
            tool_name = tool_call["name"]
            tool_args = tool_call["args"]
            
            # Tìm và gọi tool
            for tool in tools:
                if tool["name"] == tool_name:
                    result = tool["function"](**tool_args)
                    tool_results[tool_name] = result
    
    return {
        "messages": state["messages"],
        "tool_results": tool_results,
        "current_step": "tool_executed",
        "context": {**state.get("context", {}), "last_results": tool_results}
    }

def route_or_end(state: AgentState) -> str:
    """Quyết định tiếp tục hay kết thúc"""
    last_message = state["messages"][-1]
    
    # Nếu message cuối là từ model mà không có tool_calls → kết thúc
    if isinstance(last_message, AIMessage) and not hasattr(last_message, "tool_calls"):
        return "end"
    
    # Nếu có tool_calls → gọi tool
    if hasattr(last_message, "tool_calls") and last_message.tool_calls:
        return "continue"
    
    return "end"


Xây dựng Graph

workflow = StateGraph(AgentState)


Thêm nodes

workflow.add_node("agent", call_model)
workflow.add_node("action", execute_tool)


Thiết lập edges

workflow.set_entry_point("agent")
workflow.add_conditional_edges(
    "agent",
    route_or_end,
    {
        "continue": "action",
        "end": END
    }
)
workflow.add_edge("action", "agent")


Compile graph

agent_graph = workflow.compile()

def run_agent(query: str) -> str:
    """Chạy agent với query của user"""
    initial_state = {
        "messages": [HumanMessage(content=query)],
        "tool_results": {},
        "current_step": "start",
        "context": {}
    }
    
    # Chạy graph
    final_state = None
    for state in agent_graph.stream(initial_state):
        final_state = state
        print(f"Step: {list(state.keys())}")
    
    # Trả về response cuối cùng
    if final_state:
        last_node = list(final_state.values())[-1]
        messages = last_node.get("messages", [])
        if messages:
            return messages[-1].content
    
    return "Agent không trả lời được"


Test

if __name__ == "__main__":
    result = run_agent("Tìm kiếm thông tin về Bitcoin và tính toán 100 * 2 + 50")
    print(f"\nKết quả:\n{result}")

Triển khai Multi-Agent Orchestration

Để xử lý các task phức tạp, chúng ta nên chia thành nhiều specialized agents:

# multi_agent_orchestration.py
import os
from typing import Literal
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
from langgraph.graph import StateGraph, END, MessageGraph
from langgraph.checkpoint.memory import MemorySaver


Cấu hình HolySheep API

os.environ["OPENAI_API_BASE"] = "https://api.holysheep.ai/v1"
os.environ["OPENAI_API_KEY"] = "YOUR_HOLYSHEEP_API_KEY"


Base LLM Configuration

def get_llm(model: str = "gpt-4.1", temperature: float = 0.3):
    return ChatOpenAI(
        model=model,
        temperature=temperature,
        api_key=os.environ["OPENAI_API_KEY"],
        base_url=os.environ["OPENAI_API_BASE"]
    )


Specialized Agents

class ResearchAgent:
    """Agent chuyên nghiên cứu và tìm kiếm"""
    def __init__(self):
        self.llm = get_llm(model="gpt-4.1", temperature=0.5)
        self.system_prompt = SystemMessage(content="""Bạn là Research Agent.
        Nhiệm vụ: Tìm kiếm và tổng hợp thông tin từ nhiều nguồn.
        Output: Báo cáo ngắn gọn với các điểm chính.""")
    
    def run(self, query: str) -> str:
        response = self.llm.invoke([self.system_prompt, HumanMessage(content=query)])
        return response.content

class AnalysisAgent:
    """Agent chuyên phân tích dữ liệu"""
    def __init__(self):
        self.llm = get_llm(model="claude-sonnet-4.5", temperature=0.2)
        self.system_prompt = SystemMessage(content="""Bạn là Analysis Agent.
        Nhiệm vụ: Phân tích dữ liệu và đưa ra insights.
        Output: Phân tích chi tiết với các khuyến nghị.""")
    
    def run(self, data: str) -> str:
        response = self.llm.invoke([self.system_prompt, HumanMessage(content=data)])
        return response.content

class WriterAgent:
    """Agent chuyên viết content"""
    def __init__(self):
        self.llm = get_llm(model="gemini-2.5-flash", temperature=0.7)
        self.system_prompt = SystemMessage(content="""Bạn là Writer Agent.
        Nhiệm vụ: Viết content chất lượng cao từ dữ liệu phân tích.
        Output: Bài viết hoàn chỉnh, dễ đọc.""")
    
    def run(self, analysis: str) -> str:
        response = self.llm.invoke([self.system_prompt, HumanMessage(content=analysis)])
        return response.content

class OrchestratorAgent:
    """Agent điều phối chính"""
    def __init__(self):
        self.llm = get_llm(model="gpt-4.1", temperature=0.1)
        self.researcher = ResearchAgent()
        self.analyzer = AnalysisAgent()
        self.writer = WriterAgent()
        
        self.system_prompt = SystemMessage(content="""Bạn là Orchestrator Agent.
        Nhiệm vụ: Điều phối các specialized agents để hoàn thành task phức tạp.
        
        Pipeline:
        1. Research → 2. Analysis → 3. Writing
        
        Quyết định:
        - Khi nào cần research thêm
        - Khi nào cần analysis sâu hơn
        - Khi nào cần viết lại
        - Khi nào task hoàn thành""")
    
    def run(self, user_request: str) -> dict:
        """Chạy orchestration pipeline"""
        print("🔍 [1/3] Đang nghiên cứu...")
        research_result = self.researcher.run(user_request)
        
        print("📊 [2/3] Đang phân tích...")
        analysis_result = self.analyzer.run(f"Yêu cầu ban đầu: {user_request}\n\nDữ liệu research:\n{research_result}")
        
        print("✍️ [3/3] Đang viết...")
        final_output = self.writer.run(analysis_result)
        
        return {
            "research": research_result,
            "analysis": analysis_result,
            "final_output": final_output
        }


LangGraph Orchestrator với Memory

class AgentState:
    pass

orchestrator_graph = StateGraph(AgentState)

def supervisor_node(state: dict) -> dict:
    """Supervisor quyết định next agent"""
    llm = get_llm(temperature=0.1)
    
    messages = [
        SystemMessage(content="""Bạn là Supervisor.
        Quyết định agent nào xử lý tiếp:
        - research: Tìm kiếm thông tin
        - analysis: Phân tích dữ liệu
        - writer: Viết content
        - done: Hoàn thành
        
        Trả lời CHỈ một từ: research/analysis/writer/done"""),
        HumanMessage(content=state.get("current_task", ""))
    ]
    
    decision = llm.invoke(messages).content.lower()
    return {"next_agent": decision, "messages": state.get("messages", [])}


Compile với memory

checkpointer = MemorySaver()
orchestrator = orchestrator_graph.compile(checkpointer=checkpointer)


Demo

if __name__ == "__main__":
    orch = OrchestratorAgent()
    
    result = orch.run("Phân tích xu hướng AI Agent trong năm 2026")
    
    print("\n" + "="*50)
    print("KẾT QUẢ CUỐI CÙNG:")
    print("="*50)
    print(result["final_output"])

Tối ưu hóa chi phí với HolySheep

Một trong những lợi thế lớn khi sử dụng HolySheep AI là tiết kiệm đến 85%+ chi phí API. Dưới đây là cách tối ưu:

# cost_optimizer.py
import os
from typing import Optional
from langchain_openai import ChatOpenAI

os.environ["OPENAI_API_BASE"] = "https://api.holysheep.ai/v1"
os.environ["OPENAI_API_KEY"] = "YOUR_HOLYSHEEP_API_KEY"

class CostOptimizedAgent:
    """Agent với chiến lược tối ưu chi phí"""
    
    # Bảng giá HolySheep 2026 (USD/1M tokens)
    HOLYSHEEP_PRICING = {
        "gpt-4.1": 8.0,
        "claude-sonnet-4.5": 15.0,
        "gemini-2.5-flash": 2.50,
        "deepseek-v3.2": 0.42
    }
    
    def __init__(self):
        self.usage_stats = {"prompt_tokens": 0, "completion_tokens": 0}
    
    def get_optimal_model(self, task_type: str, complexity: str) -> str:
        """Chọn model tối ưu chi phí cho từng task"""
        
        if task_type == "quick_lookup":
            # Tra cứu nhanh → dùng DeepSeek rẻ nhất
            return "deepseek-v3.2"
        
        elif task_type == "analysis":
            # Phân tích trung bình → Gemini Flash
            return "gemini-2.5-flash"
        
        elif task_type == "complex_reasoning":
            # Logic phức tạp → GPT-4.1
            return "gpt-4.1"
        
        elif task_type == "creative":
            # Sáng tạo → Claude Sonnet
            return "claude-sonnet-4.5"
        
        return "deepseek-v3.2"  # Default: rẻ nhất
    
    def calculate_cost(self, model: str, tokens: int) -> float:
        """Tính chi phí theo tokens"""
        price_per_million = self.HOLYSHEEP_PRICING.get(model, 8.0)
        return (tokens / 1_000_000) * price_per_million
    
    def run_optimized(self, task: str, task_type: str = "quick_lookup") -> dict:
        """Chạy task với model tối ưu chi phí"""
        
        # Chọn model
        model = self.get_optimal_model(task_type, "auto")
        print(f"Model được chọn: {model}")
        print(f"Giá/1M tokens: ${self.HOLYSHEEP_PRICING[model]:.2f}")
        
        # Khởi tạo LLM
        llm = ChatOpenAI(
            model=model,
            api_key=os.environ["OPENAI_API_KEY"],
            base_url=os.environ["OPENAI_API_BASE"]
        )
        
        # Estimate tokens (thực tế nên dùng tiktoken)
        estimated_tokens = len(task.split()) * 1.3  # Rough estimate
        
        # Gọi API
        response = llm.invoke(task)
        
        # Tính chi phí ước tính
        response_tokens = len(response.content.split()) * 1.3
        total_tokens = estimated_tokens + response_tokens
        
        cost = self.calculate_cost(model, total_tokens)
        
        print(f"Tổng tokens ước tính: {total_tokens:.0f}")
        print(f"Chi phí ước tính: ${cost:.4f}")
        
        return {
            "response": response.content,
            "model_used": model,
            "estimated_cost": cost,
            "tokens_used": total_tokens
        }


So sánh chi phí

def compare_costs():
    """So sánh chi phí giữa các nhà cung cấp"""
    
    models = ["gpt-4.1", "claude-sonnet-4.5", "gemini-2.5-flash", "deepseek-v3.2"]
    tokens = 1_000_000  # 1M tokens
    
    print("="*60)
    print("SO SÁNH CHI PHÍ CHO 1 TRIỆU TOKENS")
    print("="*60)
    
    for model in models:
        holy_price = CostOptimizedAgent.HOLYSHEEP_PRICING[model]
        official_price = {
            "gpt-4.1": 60.0,
            "claude-sonnet-4.5": 75.0,
            "gemini-2.5-flash": 10.0,
            "deepseek-v3.2": 15.0
        }.get(model, 60.0)
        
        savings = ((official_price - holy_price) / official_price) * 100
        
        print(f"{model:25} | HolySheep: ${holy_price:6.2f} | Official: ${official_price:6.2f} | Tiết kiệm: {savings:.1f}%")

if __name__ == "__main__":
    # So sánh chi phí
    compare_costs()
    
    print("\n" + "="*60)
    print("DEMO AGENT TỐI ƯU CHI PHÍ")
    print("="*60)
    
    agent = CostOptimizedAgent()
    
    # Task nhẹ - dùng DeepSeek
    result1 = agent.run_optimized("1 + 1 bằng mấy?", task_type="quick_lookup")
    
    # Task phức tạp - dùng GPT-4.1
    result2 = agent.run_optimized("Phân tích pros/cons của microservices architecture", task_type="complex_reasoning")

Performance Benchmark: HolySheep vs Official API

Dưới đây là kết quả benchmark thực tế giữa HolySheep và API chính thức:

# benchmark.py
import time
import asyncio
import statistics
from langchain_openai import ChatOpenAI


Cấu hình

HOLYSHEEP_CONFIG = {
    "base_url": "https://api.holysheep.ai/v1",
    "api_key": "YOUR_HOLYSHEEP_API_KEY"
}

OFFICIAL_CONFIG = {
    "base_url": "https://api.openai.com/v1",
    "api_key": "YOUR_OPENAI_API_KEY"  # Cần API key chính thức để test
}

async def benchmark_provider(config: dict, model: str, num_requests: int = 10) -> dict:
    """Benchmark một provider"""
    
    llm = ChatOpenAI(
        model=model,
        api_key=config["api_key"],
        base_url=config["base_url"]
    )
    
    latencies = []
    errors = 0
    
    test_prompt = "Giải thích ngắn gọn về Machine Learning trong 3 câu."
    
    for i in range(num_requests):
        start = time.time()
        try:
            response = await llm.ainvoke(test_prompt)
            latency = (time.time() - start) * 1000  # Convert to ms
            latencies.append(latency)
        except Exception as e:
            errors += 1
            print(f"Lỗi request {i+1}: {e}")
        
        await asyncio.sleep(0.1)  # Rate limiting
    
    return {
        "provider": config["base_url"],
        "model": model,
        "requests": num_requests,
        "successful": len(latencies),
        "errors": errors,
        "avg_latency_ms": statistics.mean(latencies) if latencies else 0,
        "min_latency_ms": min(latencies) if latencies else 0,
        "max_latency_ms": max(latencies) if latencies else 0,
        "p95_latency_ms": statistics.quantiles(latencies, n=20)[18] if len(latencies) > 5 else 0
    }

def print_benchmark_result(result: dict):
    """In kết quả benchmark đẹp mắt"""
    print(f"\n{'='*60}")
    print(f"Provider: {result['provider']}")
    print(f"Model: {result['model']}")
    print(f"{'='*60}")
    print(f"Số request thành công: {result['successful']}/{result['requests']}")
    print(f"Số lỗi: {result['errors']}")
    print(f"Độ trễ trung bình: {result['avg_latency_ms']:.2f}ms")
    print(f"Độ trễ tối thiểu: {result['min_latency_ms']:.2f}ms")
    print(f"Độ trễ tối đa: {result['max_latency_ms']:.2

Tài nguyên liên quan
Bài viết liên quan