	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > OpenAI API > OpenAI API - Chat Completions and Function Calling

OpenAI API - Chat Completions and Function Calling

Author: Venkata Sudhakar

The OpenAI API is the most widely used interface for integrating Large Language Models into applications. At its core, the Chat Completions endpoint accepts a list of messages (a conversation history) and returns the model's next response. Each message has a role (system, user, or assistant) and content. The system message sets the behaviour and persona of the model. The user messages are the human's turns. The assistant messages are the model's previous turns, which you include to maintain conversation context.

Function calling (also called tool calling in newer API versions) is one of the most powerful features of the OpenAI API. It lets you define a set of functions as JSON schemas, and the model decides when to call one based on the user's message. Instead of generating a text answer, the model returns a structured JSON object with the function name and arguments. Your code then executes the function with those arguments and feeds the result back to the model, which uses it to generate the final answer. This is the foundation of how AI agents interact with external systems.

The below example shows the three core patterns: a basic chat completion, a streaming response, and function calling to retrieve live data.

from openai import OpenAI

client = OpenAI(api_key="your-api-key-here")

# Example 1: Basic chat completion with system + user messages
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system", "content": "You are a concise data migration expert. Answer in 2 sentences max."},
        {"role": "user", "content": "What is the main advantage of CDC over batch ETL?"}
    ],
    temperature=0.3,
    max_tokens=150
)
print("Answer:", response.choices[0].message.content)
print("Tokens used:", response.usage.total_tokens)

# Example 2: Multi-turn conversation (include history in messages)
conversation = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "What is Debezium?"},
    {"role": "assistant", "content": "Debezium is an open-source CDC tool that reads database logs and publishes change events to Kafka."},
    {"role": "user", "content": "Which databases does it support?"}
]
response2 = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=conversation,
    temperature=0
)
print("\nFollow-up answer:", response2.choices[0].message.content)

It gives the following output,

Answer: CDC captures database changes in real time from the transaction log, eliminating
the latency of batch windows and capturing deletes that timestamp-based ETL misses.
Tokens used: 87

Follow-up answer: Debezium supports MySQL, PostgreSQL, MongoDB, Oracle, SQL Server,
DB2, and several others through a plugin architecture on top of Apache Kafka Connect.

It gives the following streamed output (tokens print as they arrive),

Streaming response: 1. Blue-Green Deployment - run two identical environments, switch
traffic from old to new via load balancer after validation.
2. Strangler Fig Pattern - incrementally replace legacy features by routing individual
endpoints to a new service while keeping others on the legacy system.
3. Expand-Contract - add the new schema element, migrate data, then remove the old
element across separate deployments to maintain backward compatibility.

import json
from openai import OpenAI

client = OpenAI(api_key="your-api-key-here")

# Example 4: Function calling - the model decides when to call your function
# Define the function schema (what the model can call)
tools = [{
    "type": "function",
    "function": {
        "name": "get_migration_status",
        "description": "Get the current status of a database migration job by its ID",
        "parameters": {
            "type": "object",
            "properties": {
                "job_id": {
                    "type": "string",
                    "description": "The migration job ID, e.g. MIG-1042"
                }
            },
            "required": ["job_id"]
        }
    }
}]

# Simulated function that your code would call
def get_migration_status(job_id):
    # In reality: query your migration platform API
    statuses = {
        "MIG-1042": {"status": "IN_PROGRESS", "rows_migrated": 2450000, "total_rows": 5000000, "eta_minutes": 45},
        "MIG-1040": {"status": "COMPLETED", "rows_migrated": 1200000, "total_rows": 1200000, "eta_minutes": 0}
    }
    return json.dumps(statuses.get(job_id, {"status": "NOT_FOUND"}))

# Step 1: Send user message with tools available
messages = [{"role": "user", "content": "What is the status of migration job MIG-1042?"}]
response = client.chat.completions.create(
    model="gpt-4o-mini", messages=messages, tools=tools, tool_choice="auto"
)
assistant_msg = response.choices[0].message

# Step 2: Check if the model wants to call a function
if assistant_msg.tool_calls:
    tool_call = assistant_msg.tool_calls[0]
    fn_name = tool_call.function.name
    fn_args = json.loads(tool_call.function.arguments)
    print(f"Model called: {fn_name}({fn_args})")

# Step 3: Execute the function and add result to conversation
    fn_result = get_migration_status(**fn_args)
    messages.append(assistant_msg)
    messages.append({"role": "tool", "tool_call_id": tool_call.id,
                     "name": fn_name, "content": fn_result})

# Step 4: Send result back to model for final human-readable answer
    final_response = client.chat.completions.create(
        model="gpt-4o-mini", messages=messages
    )
    print("Final Answer:", final_response.choices[0].message.content)

It gives the following output,

Model called: get_migration_status({"job_id": "MIG-1042"})
Final Answer: Migration job MIG-1042 is currently IN PROGRESS. So far 2,450,000 out
of 5,000,000 rows have been migrated (49% complete), with an estimated 45 minutes
remaining until completion.

Key OpenAI API parameters to know:

temperature - Controls randomness. 0 is deterministic (same input always gives same output), useful for data extraction and structured tasks. 1.0 is more creative and varied, good for brainstorming and writing. max_tokens - Caps the response length. Set this to prevent runaway long responses and control costs. top_p - Alternative to temperature for controlling diversity; usually leave at default 1.0 when using temperature. tool_choice - Set to "auto" to let the model decide whether to call a tool, "required" to force a tool call, or specify a specific function name to always call that function.

Send your comments, suggestions or queries regarding this site to [email protected].