How Function Calling Helps LLMs Overcome Hallucinations

LLM Hallucination and Function Calling

Large language models (LLMs) can generate text that looks plausible but is factually incorrect, a problem known as hallucination . Function calling enables an LLM to invoke external functions or APIs, allowing it to retrieve up‑to‑date, accurate information and interact with real‑world services, thereby reducing hallucinations.

How Function Calling Works

Define functions : Developers describe each function’s name, purpose, parameters, and data types in a JSON schema.

LLM generates a call : When a user query requires external data, the model produces a function‑call JSON payload containing the function name and arguments.

Execute the function : The system receives the call, runs the corresponding function, and returns the result.

LLM generates the final response : Using the function’s output, the model crafts the answer presented to the user.

Why Function Calling Mitigates Hallucinations

Access to real‑time data : By calling weather, news, stock, or other APIs, the model avoids outdated knowledge.

Use of specialized tools : Calculators, translators, and domain‑specific utilities provide mathematically or linguistically accurate results.

Access to private or enterprise data : Internal APIs can supply proprietary information for precise answers.

Typical Application Scenarios

Intelligent assistants : Weather queries, flight bookings, reminders, etc.

Data analysis : Trigger analytics pipelines to generate reports automatically.

Code generation : Invoke code‑generation services based on user specifications.

Knowledge‑base Q&A : Combine external knowledge bases for accurate answers.

Example: Real‑Time Weather with OpenAI ChatGPT‑4o Function Calling

1. Define the Python function that simulates a weather‑API call.

import requests

def get_current_weather(location, unit="fahrenheit"):
    """Retrieve current weather for a given location."""
    # Simulated API response
    weather_data = {
        "location": location,
        "temperature": 25,  # assumed temperature
        "unit": unit,
        "description": "晴朗"
    }
    return weather_data

2. Create the JSON function description so the model knows the signature.

functions = [
    {
        "name": "get_current_weather",
        "description": "获取指定地点的当前天气信息。",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {
                    "type": "string",
                    "description": "需要查询的地点，例如：北京"
                },
                "unit": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "温度单位，摄氏度或华氏度"
                }
            },
            "required": ["location"]
        }
    }
]

3. Call the ChatGPT‑4o API with the function definitions.

import openai

openai.api_key = "YOUR_API_KEY"

def get_weather_from_chatgpt(user_input):
    """Use ChatGPT‑4o to obtain weather information."""
    messages = [{"role": "user", "content": user_input}]
    response = openai.ChatCompletion.create(
        model="gpt-4o",
        messages=messages,
        functions=functions,
        function_call="auto"  # let the model decide when to call
    )
    return response

user_input = "北京现在天气怎么样？"
response = get_weather_from_chatgpt(user_input)

4. Process the API response and invoke the local function if needed.

import json

response_message = response["choices"][0]["message"]

if response_message.get("function_call"):
    function_name = response_message["function_call"]["name"]
    function_args = json.loads(response_message["function_call"]["arguments"])
    if function_name == "get_current_weather":
        location = function_args.get("location")
        unit = function_args.get("unit")
        weather_data = get_current_weather(location, unit)
        # Append function result to the conversation
        messages.append(response_message)
        messages.append({
            "role": "function",
            "name": function_name,
            "content": json.dumps(weather_data)
        })
        second_response = openai.ChatCompletion.create(
            model="gpt-4o",
            messages=messages,
        )
        print(second_response["choices"][0]["message"]["content"])
else:
    print(response_message["content"])

Replace YOUR_API_KEY with a valid OpenAI key, run the script, and the final printed message will contain the real‑time weather data returned by the function call.

Conclusion

Function calling equips LLMs with the ability to retrieve up‑to‑date information and execute domain‑specific tools, which effectively mitigates hallucinations and expands practical AI applications.