OpenAI Function Calling Hoàn Chỉnh: Định Nghĩa Tool, Gọi Hàm và Xử Lý Kết Quả

Giới Thiệu: Cuộc Cách Mạng Chi Phí AI Năm 2026

Thị trường AI đang chứng kiến cuộc đua giá khốc liệt chưa từng có. Dữ liệu giá được xác minh năm 2026 cho thấy sự chênh lệch đáng kinh ngạc giữa các nhà cung cấp:

DeepSeek V3.2 rẻ hơn GPT-4.1 đến 19 lần! Với HolySheep AI, bạn được hưởng tỷ giá ¥1=$1 — tiết kiệm hơn 85% so với các nền tảng khác, hỗ trợ WeChat/Alipay, độ trễ dưới 50ms.

Function Calling Là Gì?

Function Calling (hay Tool Calling) cho phép AI "gọi" các hàm được định nghĩa sẵn trong code của bạn. Thay vì chỉ trả về text, AI có thể:

• Truy vấn database khi cần
• Gọi API bên thứ ba
• Thực hiện tính toán phức tạp
• Tương tác với hệ thống file
• Query cơ sở kiến thức nội bộ

Kiến Trúc Hoàn Chỉnh Function Calling

1. Định Nghĩa Tools Schema

# tools_schema.py

Định nghĩa tools theo chuẩn OpenAI
TOOLS_SCHEMA = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Lấy thời tiết hiện tại của một thành phố",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "Tên thành phố (VD: Hanoi, Ho Chi Minh City)"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "Đơn vị nhiệt độ",
                        "default": "celsius"
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_products",
            "description": "Tìm kiếm sản phẩm trong database",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Từ khóa tìm kiếm"
                    },
                    "category": {
                        "type": "string",
                        "enum": ["electronics", "clothing", "books", "home"],
                        "description": "Danh mục sản phẩm"
                    },
                    "max_price": {
                        "type": "number",
                        "description": "Giá tối đa (USD)"
                    }
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate_shipping",
            "description": "Tính phí vận chuyển dựa trên địa chỉ",
            "parameters": {
                "type": "object",
                "properties": {
                    "weight_kg": {
                        "type": "number",
                        "description": "Trọng lượng gói hàng (kg)"
                    },
                    "destination": {
                        "type": "string",
                        "description": "Địa chỉ giao hàng đầy đủ"
                    }
                },
                "required": ["weight_kg", "destination"]
            }
        }
    }
]

2. Triển Khai Function Handlers

# function_handlers.py
import json
from typing import Dict, Any

Database giả lập
PRODUCTS_DB = [
    {"id": 1, "name": "iPhone 15 Pro", "category": "electronics", "price": 999},
    {"id": 2, "name": "MacBook Air M3", "category": "electronics", "price": 1299},
    {"id": 3, "name": "Nike Air Max", "category": "clothing", "price": 150},
    {"id": 4, "name": "Clean Code", "category": "books", "price": 45},
]

def get_weather(city: str, unit: str = "celsius") -> Dict[str, Any]:
    """Lấy thông tin thời tiết"""
    weather_data = {
        "hanoi": {"temp": 28, "condition": "Mây rải rác", "humidity": 75},
        "ho chi minh": {"temp": 34, "condition": "Nắng nóng", "humidity": 65},
        "da nang": {"temp": 31, "condition": "Mưa rào", "humidity": 82}
    }
    
    city_lower = city.lower()
    if city_lower in weather_data:
        data = weather_data[city_lower]
        temp = data["temp"]
        if unit == "fahrenheit":
            temp = temp * 9/5 + 32
        return {
            "city": city,
            "temperature": temp,
            "unit": unit,
            "condition": data["condition"],
            "humidity": data["humidity"],
            "success": True
        }
    return {"error": f"Không tìm thấy thành phố {city}", "success": False}

def search_products(query: str, category: str = None, max_price: float = None) -> Dict[str, Any]:
    """Tìm kiếm sản phẩm"""
    results = [p for p in PRODUCTS_DB if query.lower() in p["name"].lower()]
    
    if category:
        results = [p for p in results if p["category"] == category]
    if max_price:
        results = [p for p in results if p["price"] <= max_price]
    
    return {
        "query": query,
        "count": len(results),
        "products": results,
        "success": True
    }

def calculate_shipping(weight_kg: float, destination: str) -> Dict[str, Any]:
    """Tính phí vận chuyển"""
    base_rate = 5.0  # $5 base
    weight_rate = 2.5  # $2.5 per kg
    
    # Tính toán phức tạp hơn cho một số khu vực
    if "hanoi" in destination.lower() or "ho chi minh" in destination.lower():
        multiplier = 1.0
    else:
        multiplier = 1.5
    
    cost = (base_rate + (weight_kg * weight_rate)) * multiplier
    
    return {
        "weight_kg": weight_kg,
        "destination": destination,
        "shipping_cost": round(cost, 2),
        "currency": "USD",
        "estimated_days": 3 if multiplier == 1.0 else 5,
        "success": True
    }

Map function name -> handler
FUNCTION_HANDLERS = {
    "get_weather": get_weather,
    "search_products": search_products,
    "calculate_shipping": calculate_shipping
}

def execute_function(function_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
    """Thực thi function được gọi"""
    if function_name not in FUNCTION_HANDLERS:
        return {"error": f"Unknown function: {function_name}", "success": False}
    
    try:
        handler = FUNCTION_HANDLERS[function_name]
        return handler(**arguments)
    except Exception as e:
        return {"error": str(e), "success": False}

3. Client Hoàn Chỉnh Với HolySheep AI

# function_calling_client.py
import requests
import json
from typing import List, Dict, Any, Optional
from tools_schema import TOOLS_SCHEMA
from function_handlers import execute_function

class FunctionCallingClient:
    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 = TOOLS_SCHEMA
    
    def chat(
        self,
        messages: List[Dict[str, str]],
        model: str = "gpt-4.1",
        temperature: float = 0.7,
        max_turns: int = 10
    ) -> Dict[str, Any]:
        """
        Chat với Function Calling support
        """
        conversation = messages.copy()
        turn = 0
        
        while turn < max_turns:
            turn += 1
            
            # Gọi API lần đầu
            response = self._make_request(
                model=model,
                messages=conversation,
                tools=self.tools,
                temperature=temperature
            )
            
            # Kiểm tra lỗi
            if "error" in response:
                return response
            
            # Lấy message cuối
            assistant_message = response["choices"][0]["message"]
            conversation.append(assistant_message)
            
            # Kiểm tra có function_call không
            if "tool_calls" not in assistant_message:
                # Không có function call -> trả kết quả
                return {
                    "message": assistant_message["content"],
                    "success": True
                }
            
            # Xử lý từng function call
            for tool_call in assistant_message["tool_calls"]:
                function_name = tool_call["function"]["name"]
                arguments = json.loads(tool_call["function"]["arguments"])
                
                print(f"🔧 Gọi function: {function_name}")
                print(f"   Arguments: {arguments}")
                
                # Thực thi function
                result = execute_function(function_name, arguments)
                print(f"   Kết quả: {result}")
                
                # Thêm tool result vào conversation
                conversation.append({
                    "role": "tool",
                    "tool_call_id": tool_call["id"],
                    "content": json.dumps(result, ensure_ascii=False)
                })
        
        return {"error": "Đạt số turns tối đa", "success": False}
    
    def _make_request(
        self,
        model: str,
        messages: List[Dict[str, str]],
        tools: List[Dict],
        temperature: float
    ) -> Dict[str, Any]:
        """Thực hiện request đến API"""
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": model,
            "messages": messages,
            "tools": tools,
            "temperature": temperature,
            "tool_choice": "auto"  # Cho phép AI tự quyết định
        }
        
        try:
            response = requests.post(
                f"{self.base_url}/chat/completions",
                headers=headers,
                json=payload,
                timeout=30
            )
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            return {"error": str(e), "success": False}

============== DEMO ==============
if __name__ == "__main__":
    # Khởi tạo client với HolySheep AI
    client = FunctionCallingClient(
        api_key="YOUR_HOLYSHEEP_API_KEY",  # Thay bằng API key của bạn
        base_url="https://api.holysheep.ai/v1"
    )
    
    # Demo 1: Hỏi về thời tiết
    print("=" * 50)
    print("DEMO 1: Hỏi thời tiết")
    print("=" * 50)
    
    result = client.chat(
        messages=[
            {"role": "user", "content": "Thời tiết ở Hanoi hôm nay thế nào?"}
        ],
        model="gpt-4.1"
    )
    print(f"Kết quả: {result}")
    
    # Demo 2: Tìm sản phẩm + tính ship
    print("\n" + "=" * 50)
    print("DEMO 2: Tìm sản phẩm + tính phí ship")
    print("=" * 50)
    
    result = client.chat(
        messages=[
            {"role": "user", "content": "Tìm điện thoại iPhone giá dưới 1000 USD và tính phí ship 2kg đến Ho Chi Minh City"}
        ],
        model="gpt-4.1"
    )
    print(f"Kết quả: {result}")

4. Async Version Cho Production

# async_function_calling.py
import asyncio
import aiohttp
import json
from typing import List, Dict, Any
from tools_schema import TOOLS_SCHEMA
from function_handlers import execute_function

class AsyncFunctionCallingClient:
    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 = TOOLS_SCHEMA
    
    async def chat(self, messages: List[Dict[str, str]], model: str = "gpt-4.1") -> Dict[str, Any]:
        """Async chat với function calling"""
        conversation = messages.copy()
        
        async with aiohttp.ClientSession() as session:
            for turn in range(10):
                # Gọi API
                response = await self._make_request(session, model, conversation)
                
                if "error" in response:
                    return response
                
                assistant_message = response["choices"][0]["message"]
                conversation.append(assistant_message)
                
                if "tool_calls" not in assistant_message:
                    return {"message": assistant_message["content"], "success": True}
                
                # Xử lý parallel các function calls
                tasks = []
                for tool_call in assistant_message["tool_calls"]:
                    task = self._process_tool_call(session, conversation, tool_call)
                    tasks.append(task)
                
                results = await asyncio.gather(*tasks)
                
        return {"error": "Max turns exceeded", "success": False}
    
    async def _make_request(
        self,
        session: aiohttp.ClientSession,
        model: str,
        messages: List[Dict]
    ) -> Dict[str, Any]:
        """Async request"""
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }
        
        payload = {
            "model": model,
            "messages": messages,
            "tools": self.tools,
            "temperature": 0.7
        }
        
        async with session.post(
            f"{self.base_url}/chat/completions",
            headers=headers,
            json=payload
        ) as response:
            return await response.json()
    
    async def _process_tool_call(
        self,
        session: aiohttp.ClientSession,
        conversation: List[
Tài nguyên liên quan
📚 Hướng dẫn AI API
💰 Xem giá
📖 Tài liệu nhà phát triển
🚀 Đăng ký miễn phí
Bài viết liên quan
vi gpt 4o api hello world shilicongzhucedaodiyicichen 2026 0
vi gpt 5 api zhengshifabuhoudejierubiangengzhinan 2026 04 04