AI Workflows

Implementing LLM Function Calling with OpenAI Tool Integration

Step-by-step guide to use OpenAI's function calling for structured responses in Python.

5 min read

Step-by-Step Guide to Implementing LLM Function Calling with OpenAI Tool Integration

This guide demonstrates how to use OpenAI's function calling to interact seamlessly between a language model and external tools in a Python environment. By following this guide, you will learn to enable structured outputs and create an example product assistant for managing structured data queries. Let's get started!

Prerequisites for Implementing LLM Function Calling

Before implementing LLM function calling, ensure you meet the following prerequisites:

prerequisites

  • Knowledge of Python fundamentals, including loops, functions, and dictionaries.
  • Access to OpenAI's Chat Completions API and an active API key.
  • Installed required libraries: openai and Python's built-in json.
  • Familiarity with JSON schemas, particularly for tool definitions.

Steps to Define and Use Tools for LLM Calling in Python

This section outlines the steps to set up your Python environment, define tool functions, and implement OpenAI's function-calling capabilities.

steps

  1. Set up your Python project.

    • Ensure the openai library is installed.
    • Prepare your Python files, including products.py to simulate a product database.
    bash
    pip install openai
  2. Define a dictionary of product data.
    This will serve as the datasource for your product queries. Save this as products.py.

    python
    products = {
        "Ethiopian_Yirgacheffe": {
            "name": "Ethiopian Yirgacheffe",
            "origin": "Ethiopia",
            "flavor_profile": "Bright and citrusy with floral aroma",
            "price": 18.99,
            "certifications": ["Fair Trade", "Organic"]
        }
    }
  3. Create a function to fetch product information.

    Define a Python function using typing annotations that extracts requested product details.

    python
    from typing import Dict
    
    def get_product_info(product_id: str) -> Dict:
        """
        Fetch details for the specified product.
        """
        if product_id not in products:
            raise ValueError("Product not found.")
        return products[product_id]
  4. Describe the function using a JSON schema for the LLM.

    The schema serves as a "contract" that explains the function and its parameters to the language model.

    python
    import json
    
    tools = [
        {
            "type": "function",
            "name": "get_product_info",
            "description": "Fetch detailed information about Global Java Roasters products.",
            "parameters": {
                "type": "object",
                "properties": {
                    "product_id": {
                        "type": "string",
                        "description": "The ID of the product to retrieve information for."
                    }
                },
                "required": ["product_id"]
            }
        }
    ]
  5. Connect to the OpenAI API and set up the LLM message flow.

    Create the flow that routes user messages, handles tool invocation, and returns structured results.

    python
    import openai
    import os
    
    openai.api_key = os.getenv("OPENAI_API_KEY")
    
    messages = [
        {"role": "system", "content": "You are a product assistant for Global Java Roasters."},
        {"role": "user", "content": "Can you tell me about Ethiopian Yirgacheffe?"}
    ]
    
    response = openai.ChatCompletion.create(
        model="gpt-4-0613",  # The name of the OpenAI model.
        messages=messages,
        functions=tools,
        function_call="auto",  # Let the model decide whether to call a function.
    )
    
    tool_request = response["choices"][0]["message"]["function_call"]
    if tool_request:
        function_name = tool_request["name"]
        arguments = json.loads(tool_request["arguments"])
    
        # Call the function
        if function_name == "get_product_info":
            result = get_product_info(**arguments)
    
        # Append the tool response to messages
        messages.append({"role": "tool", "name": function_name, "content": json.dumps(result)})
    
        # Continue the conversation
        final_response = openai.ChatCompletion.create(
            model="gpt-4-0613",
            messages=messages,
        )
    
        print(final_response["choices"][0]["message"]["content"])

Terminal Output from Function Calling Implementation

Here's an example of what to expect when the function is executed correctly.

Expected Output after Function Call

Model requested `get_product_info` with arguments:
# {'product_id': 'Ethiopian_Yirgacheffe'}

Assistant response:
# "Our Ethiopian Yirgacheffe is a bright and citrusy coffee with a floral aroma and a light body. It is sourced from Ethiopia and costs $18.99."

Common Mistakes and Debugging Tips in LLM Tool Integration

Here are tips to solve issues you may encounter:


Takeaways from Structured Function Calls in AI APIs

LLM function calling enables AI models to perform responsible, structured operations by delegating them to pre-defined tools. By integrating OpenAI's functionality into Python workflows, developers can build robust applications that minimize errors, enable parallel processing of tool calls, and prevent hallucinations commonly associated with less-structured LLM outputs. Add robust error handling and extensibility for best results.


FAQ

What is LLM function calling?

LLM function calling allows language models like OpenAI's GPT to request external tools when handling structured inputs and outputs, ensuring precise, non-hallucinatory results.

Can I call multiple tools in parallel?

Yes, OpenAI allows handling multiple tool calls in the same interaction. Use a loop to process and return the outputs from multiple tool calls sequentially.

Do I need JSON schema for each function?

Yes, each tool you want the LLM to use must be accompanied by a JSON schema describing the function, its parameters, and when the model should use it. Structure and clarity in the schema are crucial.

How does tool calling improve AI workflows?

Tool calling offloads operations that require precision (e.g., math, data lookups) to backend systems while ensuring the AI's outputs are structured and factually accurate.


Official reference: OpenAI API documentation.