Bạn đã bao giờ tự hỏi làm sao để AI có thể thực hiện các tác vụ thực tế như tra cứu thời tiết, đặt lịch hẹn hay truy xuất dữ liệu từ cơ sở dữ liệu chưa? Câu trả lời nằm ở Tools/Function Calling — một tính năng cho phép AI gọi các hàm bên ngoài khi cần thiết. Trong bài viết này, mình sẽ hướng dẫn bạn từng bước từ con số 0, so sánh chi tiết khả năng tools calling của Gemini với các nền tảng khác, và giới thiệu giải pháp tối ưu về chi phí.

Tools/Gọi Hàm Là Gì? Giải Thích Đơn Giản Cho Người Mới

Khi bạn hỏi ChatGPT một câu hỏi đơn giản như "Thời tiết hôm nay thế nào?", AI chỉ có thể trả lời dựa trên dữ liệu đã được huấn luyện. Nhưng nếu bạn muốn AI thực sự lấy được thông tin thời tiết hiện tại tại TP.HCM? Lúc này, Tools/Function Calling phát huy tác dụng.

Cơ Chế Hoạt Động (Dễ Hiểu Như Đặt Đồ Ăn)

Hãy tưởng tượng bạn gọi đồ ăn qua app:

Điểm khác biệt quan trọng: thay vì AI tự đoán câu trả lời (có thể sai), AI sẽ yêu cầu bạn thực thi một hàm cụ thể và trả kết quả thực về cho nó.

Tại Sao Tools Calling Lại Quan Trọng?

Theo kinh nghiệm thực chiến của mình trong 3 năm làm việc với các API AI, tools calling giải quyết được 3 vấn đề lớn:

So Sánh Chi Tiết: Gemini vs Các Nền Tảng Khác

Bảng So Sánh Toàn Diện

Tiêu Chí Gemini 2.0 Flash GPT-4 (OpenAI) Claude (Anthropic)
Số lượng Tools tối đa 128 functions 128 functions 1000+ tools
Parallel Calling ✅ Hỗ trợ đầy đủ ✅ Hỗ trợ đầy đủ ✅ Hỗ trợ đầy đủ
Tool Choice Mode auto/any/required none/auto/required any/auto
Streaming Response ✅ ✅ ✅
Structured Output JSON Schema JSON Schema JSON Schema
Độ trễ trung bình <800ms <1200ms <1500ms
Giá (per 1M tokens) $2.50 (Input) / $10 (Output) $15 (Input) / $60 (Output) $15 (Input) / $75 (Output)
Định dạng Tool Definition Google A2A compatible OpenAI format Claude format

Phân Tích Chi Tiết Từng Nền Tảng

Gemini API — Lựa Chọn Tối Ưu Về Chi Phí

Gemini 2.5 Flash đang là "vua giá rẻ" trong làng AI với chi phí chỉ $2.50/1M tokens input — rẻ hơn GPT-4 tới 6 lần và Claude tới 6 lần. Đặc biệt, Gemini hỗ trợ định dạng Google A2A (Agent2Agent), chuẩn hóa việc giao tiếp giữa các agent một cách dễ dàng.

# Ví dụ: Gọi Gemini API với Tools sử dụng HolySheep

HolySheep hỗ trợ Gemini với độ trễ <50ms và giá tiết kiệm 85%+


import requests
import json


Cấu hình API - Sử dụng HolySheep thay vì API gốc của Google

BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"  # Lấy key từ https://www.holysheep.ai/register


Định nghĩa tools cho phép AI sử dụng

tools = [
    {
        "name": "get_weather",
        "description": "Lấy thông tin thời tiết theo thành phố",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "Tên thành phố cần tra cứu thời tiết"
                }
            },
            "required": ["city"]
        }
    },
    {
        "name": "calculate_loan",
        "description": "Tính toán số tiền trả góp hàng tháng",
        "parameters": {
            "type": "object",
            "properties": {
                "principal": {"type": "number", "description": "Số tiền vay (VND)"},
                "annual_rate": {"type": "number", "description": "Lãi suất năm (%)"},
                "months": {"type": "number", "description": "Số tháng vay"}
            },
            "required": ["principal", "annual_rate", "months"]
        }
    }
]


Câu trả lời mẫu từ Gemini khi nó muốn gọi tool

sample_response = {
    "candidates": [{
        "content": {
            "parts": [{
                "functionCall": {
                    "name": "get_weather",
                    "args": {"city": "TP.HCM"}
                }
            }]
        }
    }]
}

print("Gemini muốn gọi function:", sample_response["candidates"][0]["content"]["parts"][0]["functionCall"])

# Triển khai function handlers để xử lý yêu cầu từ AI

def get_weather(city: str) -> dict:
    """Xử lý yêu cầu lấy thời tiết - thay bằng API thực tế"""
    # Trong thực tế, gọi OpenWeatherMap, WeatherAPI, etc.
    weather_data = {
        "TP.HCM": {"temp": 32, "humidity": 75, "condition": "Nắng"},
        "Hà Nội": {"temp": 28, "humidity": 80, "condition": "Mưa rào"},
        "Đà Nẵng": {"temp": 30, "humidity": 70, "condition": "Ít mây"}
    }
    return weather_data.get(city, {"temp": 0, "humidity": 0, "condition": "Không rõ"})

def calculate_loan(principal: float, annual_rate: float, months: int) -> dict:
    """Tính số tiền trả góp hàng tháng theo công thức dư nợ giảm dần"""
    monthly_rate = annual_rate / 100 / 12
    if monthly_rate == 0:
        return {"monthly_payment": principal / months, "total_interest": 0}
    
    # Công thức dư nợ giảm dần
    payment = principal * monthly_rate * (1 + monthly_rate)**months / ((1 + monthly_rate)**months - 1)
    total_payment = payment * months
    
    return {
        "monthly_payment": round(payment, 2),
        "total_payment": round(total_payment, 2),
        "total_interest": round(total_payment - principal, 2)
    }


Hàm xử lý chính - xử lý function calls từ AI response

def handle_function_calls(function_calls: list) -> list:
    """Xử lý danh sách function calls và trả về kết quả"""
    results = []
    
    for call in function_calls:
        func_name = call.get("name")
        func_args = call.get("args", {})
        
        if func_name == "get_weather":
            result = get_weather(**func_args)
        elif func_name == "calculate_loan":
            result = calculate_loan(**func_args)
        else:
            result = {"error": f"Unknown function: {func_name}"}
        
        results.append({
            "name": func_name,
            "result": result
        })
    
    return results


Demo xử lý

sample_calls = [
    {"name": "get_weather", "args": {"city": "TP.HCM"}},
    {"name": "calculate_loan", "args": {"principal": 100000000, "annual_rate": 8.5, "months": 24}}
]

results = handle_function_calls(sample_calls)
for r in results:
    print(f"Function: {r['name']} => Kết quả: {r['result']}")

OpenAI GPT-4 — Tiêu Chuẩn Công Nghiệp

GPT-4 được coi là tiêu chuẩn vàng cho function calling với độ chính xác cao nhất trong việc phân tích intent và chọn đúng function. Tuy nhiên, với giá $15/1M input tokens, chi phí có thể trở thành gánh nặng cho các ứng dụng quy mô lớn.

# Ví dụ: Integration với HolySheep (tương thích OpenAI format)

HolySheep cung cấp endpoint tương thích OpenAI, chuyển đổi dễ dàng


import openai
from openai import OpenAI


Cấu hình HolySheep như một proxy OpenAI

client = OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"  # Không dùng api.openai.com!
)


Định nghĩa tools theo chuẩn OpenAI

tools = [
    {
        "type": "function",
        "function": {
            "name": "search_products",
            "description": "Tìm kiếm sản phẩm trong cơ sở dữ liệu",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Từ khóa tìm kiếm"},
                    "category": {"type": "string", "description": "Danh mục sản phẩm"},
                    "max_price": {"type": "number", "description": "Giá tối đa (VND)"}
                }
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "create_order",
            "description": "Tạo đơn hàng mới",
            "parameters": {
                "type": "object",
                "properties": {
                    "product_id": {"type": "string"},
                    "quantity": {"type": "integer", "minimum": 1},
                    "customer_id": {"type": "string"}
                },
                "required": ["product_id", "quantity", "customer_id"]
            }
        }
    }
]


Gửi request với function calling

messages = [
    {"role": "user", "content": "Tìm iPhone 15 Pro giá dưới 30 triệu và tạo đơn cho khách KH001"}
]

response = client.chat.completions.create(
    model="gpt-4-turbo",  # Hoặc "gpt-4.1" tùy provider
    messages=messages,
    tools=tools,
    tool_choice="auto"  # Để AI tự quyết định gọi function nào
)


Xử lý kết quả

for choice in response.choices:
    if choice.finish_reason == "tool_calls":
        for tool_call in choice.message.tool_calls:
            print(f"AI muốn gọi: {tool_call.function.name}")
            print(f"Arguments: {tool_call.function.arguments}")

Cách Triển Khai Tools Calling Cho Người Mới Bắt Đầu

Bước 1: Đăng Ký và Lấy API Key

Đầu tiên, bạn cần có API key để bắt đầu. Mình khuyên bạn đăng ký tại đây để nhận tín dụng miễn phí khi bắt đầu. HolySheep hỗ trợ thanh toán qua WeChat/Alipay và tỷ giá quy đổi ¥1 = $1 — tiết kiệm tới 85% so với các nền tảng khác.

Bước 2: Cài Đặt Thư Viện

# Cài đặt thư viện cần thiết
pip install requests openai google-generativeai


Kiểm tra cài đặt thành công

python -c "import requests, openai; print('Cài đặt thành công!')"

Bước 3: Xây Dựng Hệ Thống Chatbot Với Tools

# Hệ thống chatbot hoàn chỉnh với Tools Calling

Demo đầy đủ: chatbot hỗ trợ tra cứu thông tin và tính toán


import requests
import json
import re

class AIToolsChatbot:
    """Chatbot đơn giản với khả năng gọi tools"""
    
    def __init__(self, api_key: str, base_url: str = "https://api.holysheep.ai/v1"):
        self.api_key = api_key
        self.base_url = base_url
        self.tools = self._define_tools()
        self.conversation_history = []
    
    def _define_tools(self):
        """Định nghĩa các tools có sẵn"""
        return [
            {
                "name": "calculator",
                "description": "Máy tính - thực hiện các phép tính cơ bản",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "expression": {"type": "string", "description": "Biểu thức toán, ví dụ: 15 * 8 + 100"}
                    }
                }
            },
            {
                "name": "currency_converter",
                "description": "Chuyển đổi tiền tệ",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "amount": {"type": "number", "description": "Số tiền cần chuyển"},
                        "from_currency": {"type": "string", "description": "Tiền tệ nguồn (VND, USD, CNY)"},
                        "to_currency": {"type": "string", "description": "Tiền tệ đích"}
                    }
                }
            },
            {
                "name": "get_date_info",
                "description": "Lấy thông tin về ngày",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "date": {"type": "string", "description": "Ngày cần tra cứu (YYYY-MM-DD)"}
                    }
                }
            }
        ]
    
    def execute_tool(self, tool_name: str, arguments: dict) -> str:
        """Thực thi tool và trả kết quả"""
        if tool_name == "calculator":
            try:
                result = eval(arguments["expression"])
                return f"Kết quả: {result}"
            except Exception as e:
                return f"Lỗi tính toán: {str(e)}"
        
        elif tool_name == "currency_converter":
            # Tỷ giá mẫu - trong thực tế gọi API thực
            rates = {"VND": 1, "USD": 25400, "CNY": 3500}
            amount = arguments["amount"]
            from_c = arguments["from_currency"]
            to_c = arguments["to_currency"]
            result = (amount / rates[from_c]) * rates[to_c]
            return f"{amount} {from_c} = {result:.2f} {to_c}"
        
        elif tool_name == "get_date_info":
            from datetime import datetime
            date = arguments["date"]
            dt = datetime.strptime(date, "%Y-%m-%d")
            weekdays = ["Thứ Hai", "Thứ Ba", "Thứ Tư", "Thứ Năm", "Thứ Sáu", "Thứ Bảy", "Chủ Nhật"]
            return f"Ngày {date} là {weekdays[dt.weekday()]}"
        
        return f"Không tìm thấy tool: {tool_name}"
    
    def chat(self, user_message: str, model: str = "gemini-2.0-flash") -> str:
        """Gửi tin nhắn và nhận phản hồi từ AI"""
        # Thêm tin nhắn vào lịch sử
        self.conversation_history.append({"role": "user", "content": user_message})
        
        # Gọi API - sử dụng HolySheep endpoint
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": model,
            "messages": self.conversation_history,
            "tools": self.tools,
            "tool_choice": "auto"
        }
        
        try:
            response = requests.post(
                f"{self.base_url}/chat/completions",
                headers=headers,
                json=payload,
                timeout=30
            )
            response.raise_for_status()
            result = response.json()
            
            # Xử lý response
            message = result["choices"][0]["message"]
            
            if message.get("tool_calls"):
                # AI muốn gọi tool - xử lý và gửi lại
                tool_results = []
                for call in message["tool_calls"]:
                    tool_name = call["function"]["name"]
                    args = json.loads(call["function"]["arguments"])
                    result_text = self.execute_tool(tool_name, args)
                    tool_results.append({
                        "role": "tool",
                        "tool_call_id": call["id"],
                        "content": result_text
                    })
                
                # Thêm kết quả tool vào conversation
                self.conversation_history.append(message)
                self.conversation_history.extend(tool_results)
                
                # Gọi lại để AI tổng hợp kết quả
                payload["messages"] = self.conversation_history
                payload.pop("tools", None)  # Không cần tools nữa
                payload.pop("tool_choice", None)
                
                response2 = requests.post(
                    f"{self.base_url}/chat/completions",
                    headers=headers,
                    json=payload,
                    timeout=30
                )
                final_message = response2.json()["choices"][0]["message"]["content"]
            else:
                final_message = message["content"]
            
            self.conversation_history.append({"role": "assistant", "content": final_message})
            return final_message
            
        except requests.exceptions.RequestException as e:
            return f"Lỗi kết nối: {str(e)}. Vui lòng kiểm tra API key và kết nối mạng."



============== DEMO SỬ DỤNG ==============

if __name__ == "__main__":
    # Khởi tạo chatbot (thay YOUR_KEY bằng key thực tế)
    bot = AIToolsChatbot(api_key="YOUR_HOLYSHEEP_API_KEY")
    
    # Test 1: Tính toán đơn giản
    print("=== Demo 1: Tính toán ===")
    response = bot.chat("Tính 15 nhân 8 rồi cộng thêm 100")
    print(f"User: Tính 15 nhân 8 rồi cộng thêm 100")
    print(f"Bot: {response}\n")
    
    # Test 2: Chuyển đổi tiền tệ
    print("=== Demo 2: Chuyển đổi tiền tệ ===")
    response = bot.chat("Đổi 1000 USD sang VND")
    print(f"User: Đổi 1000 USD sang VND")
    print(f"Bot: {response}\n")
    
    # Test 3: Hỏi thông tin ngày
    print("=== Demo 3: Thông tin ngày ===")
    response = bot.chat("Hôm nay là thứ mấy?")
    print(f"User: Hôm nay là thứ mấy?")
    print(f"Bot: {response}")

Best Practices Khi Sử Dụng Tools Calling

1. Thiết Kế Tool Definitions Rõ Ràng

Một tool definition tốt cần có:

2. Xử Lý Lỗi Tool Execution

def safe_execute_tool(tool_name: str, arguments: dict) -> dict:
    """Thực thi tool với error handling đầy đủ"""
    
    try:
        # Validate arguments trước khi execute
        if tool_name == "transfer_money":
            if arguments.get("amount", 0) <= 0:
                return {"success": False, "error": "Số tiền phải lớn hơn 0"}
            if arguments.get("amount", 0) > 100000000:
                return {"success": False, "error": "Số tiền vượt quá giới hạn"}
        
        # Execute the actual tool
        result = execute_tool(tool_name, arguments)
        return {"success": True, "data": result}
    
    except ValidationError as e:
        return {"success": False, "error": f"Dữ liệu không hợp lệ: {str(e)}"}
    except ConnectionError as e:
        return {"success": False, "error": "Không thể kết nối dịch vụ"}
    except Exception as e:
        return {"success": False, "error": f"Lỗi không xác định: {str(e)}"}

3. Tối Ưu Chi Phí

Theo kinh nghiệm thực chiến, có 3 cách giảm chi phí đáng kể:

Lỗi Thường Gặp Và Cách Khắc Phục

Lỗi 1: "Invalid API Key" - 401 Unauthorized

# ❌ SAI: Sai base_url hoặc sai định dạng API key
client = OpenAI(
    api_key="sk-xxx...",
    base_url="https://api.openai.com/v1"  # Sai!
)


✅ ĐÚNG: Sử dụng HolySheep endpoint chính xác

client = OpenAI(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    base_url="https://api.holysheep.ai/v1"  # Đúng!
)


Kiểm tra key hợp lệ

import requests
response = requests.get(
    "https://api.holysheep.ai/v1/models",
    headers={"Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY"}
)
if response.status_code == 401:
    print("API Key không hợp lệ. Vui lòng lấy key mới từ https://www.holysheep.ai/register")

Lỗi 2: "Tool Call Format Error" - JSON Parse Failed

# ❌ SAI: Arguments không phải JSON string
tool_call = {
    "name": "get_weather",
    "args": {"city": "TP.HCM"}  # Nên là JSON string
}


✅ ĐÚNG: Đảm bảo arguments là JSON string khi gửi cho model

tool_call = {
    "name": "get_weather",
    "args": json.dumps({"city": "TP.HCM"})  # Convert sang string
}


Hoặc parse lại khi nhận từ model

try:
    args = json.loads(tool_call["function_call"]["arguments"])
except json.JSONDecodeError as e:
    print(f"Lỗi parse JSON: {e}")
    # Fallback: yêu cầu user cung cấp lại thông tin

Lỗi 3: "Timeout Error" - Request Quá 30 Giây

# ❌ SAI: Timeout mặc định quá ngắn hoặc không set
response = requests.post(url, json=payload)  # Timeout mặc định None


✅ ĐÚNG: Set timeout hợp lý và xử lý retry

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=2, max=10))
def call_with_retry(url: str, headers: dict, payload: dict) -> dict:
    try:
        response = requests.post(
            url,
            headers=headers,
            json=payload,
            timeout=60  # 60 giây cho các tác vụ phức tạp
        )
        response.raise_for_status()
        return response.json()
    except requests.exceptions.Timeout:
        print("Request timeout, đang thử lại...")
        raise
    except requests.exceptions.RequestException as e:
        print(f"Lỗi request: {e}")
        raise


Sử dụng với HolySheep - độ trễ <50ms thường không cần timeout dài

result = call_with_retry(
    f"https://api.holysheep.ai/v1/chat/completions",
    headers={"Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY"},
    payload=payload
)

Lỗi 4: "Rate Limit Exceeded" - Vượt Giới Hạn Request

# ❌ SAI: Gửi request liên tục không kiểm soát
for i in range(1000):
    call_api()  # Sẽ bị rate limit ngay


✅ ĐÚNG: Sử dụng rate limiter và exponential backoff

import time
from collections import defaultdict

class RateLimiter:
    def __init__(self, max_requests: int = 60, window_seconds: int = 60):
        self.max_requests = max_requests
        self.window = window_seconds
        self.requests = defaultdict(list)
    
    def wait_if_needed(self):
        now = time.time()
        # Xóa các request cũ khỏi window
        self.requests["default"] = [t for t in self.requests["default"] if now - t < self.window]
        
        if len(self.requests["default"]) >= self.max

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