Python LLM API Calls

From Web Interface to API

At its core, an Application Programming Interface (API) is a contract that allows different software systems to communicate. When you use a web app like ChatGPT, you're interacting with the LLM through a graphical user interface. The API allows you to bypass that interface and communicate with the model directly from your code.

This unlocks a new level of control and automation. You can build applications that dynamically generate prompts, process LLM outputs, and integrate them into a larger workflow—all essential components of a RAG system.

This diagram illustrates how your applications connect to LLM providers via an API. Our focus today is on the "Connecting Elements"—specifically, making that initial API call.

Interacting with an LLM via its API offers several advantages over the web UI, such as the ability to customize the model's behavior, process inputs and outputs programmatically, and integrate the model into automated workflows.

To understand these benefits more clearly, please watch a short segment from the video "The OpenAI (Python) API | Introduction & Example Code" by Shaw Talebi.

Two Paths to an API Call

As a software engineer, you know there are often multiple ways to achieve the same result. Interacting with LLM APIs in Python is no different. The two primary methods are:

1. Direct HTTP Requests: Using a general-purpose library like requests to manually construct and send HTTP requests. This gives you full control and helps you understand the underlying protocol.
2. Provider-Specific SDKs: Using a Software Development Kit (SDK) provided by the LLM company (e.g., OpenAI, Anthropic, Google). SDKs are libraries that wrap the API in convenient, language-specific functions, abstracting away the low-level HTTP details.

For most application development, the SDK is the preferred path due to its convenience and robustness. However, understanding what the SDK does under the hood is valuable. The following reading from APXML's course provides an excellent overview of both approaches.

Setting Up Your Environment

Now, let's get your hands dirty. To make our first API call, we need to set up your development environment. We'll use OpenAI's API as our example, as it's widely used and well-documented.

The setup involves three main steps:

1. Obtaining an API key.
2. Installing the required Python libraries.
3. Storing your API key securely.

The video below provides a clear, step-by-step walkthrough of creating an OpenAI account, navigating the billing settings, and generating your first secret API key.

With your API key in hand, the next step is to set up your Python project.

Your First Programmatic API Call

You are now ready to write the code. We will use the OpenAI Python SDK, which you just installed. It provides a clean and Pythonic way to interact with the API.

The process involves:

1. Importing the OpenAI client and os / dotenv for key management.
2. Loading the environment variables from your .env file.
3. Initializing the OpenAI client, which automatically finds the key from the environment.
4. Calling the client.chat.completions.create() method with your prompt.
5. Printing the response from the model.

Let's look at the code.

Here is a complete, runnable script you can use. Create a file named main.py in the same directory as your .env file, and paste this code into it.

import os
from openai import OpenAI
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

# The OpenAI client automatically looks for the OPENAI_API_KEY
# in the environment variables.
try:
    client = OpenAI()
    print("OpenAI client initialized successfully.")

    # Make the API call
    print("Sending request to the API...")
    chat_completion = client.chat.completions.create(
        model="gpt-4o-mini",  # A fast and cost-effective model
        messages=[
            {
                "role": "user",
                "content": "Explain what an API is to a software engineer in one sentence.",
            }
        ],
    )

    # Extract and print the response
    response_content = chat_completion.choices[0].message.content
    print("\nLLM Response:")
    print(response_content)

    # You can also inspect the full response object
    # print("\nFull response object:")
    # print(chat_completion)

except Exception as e:
    print(f"An error occurred: {e}")
    print("Please check if your OPENAI_API_KEY is set correctly in the .env file.")

Run this script from your terminal: python main.py.

If everything is configured correctly, you will see a response from the LLM printed to your console. Congratulations, you have successfully made your first programmatic API call to a large language model!

Conclusion

In this lesson, you've made the pivotal transition from a GUI user to an API-empowered developer. You now understand the "why" and "how" of programmatic LLM interaction.

Here are the key takeaways:

• LLM APIs provide the control and automation necessary to build sophisticated AI applications.
• Setup involves getting an API key, installing the provider's SDK (openai), and securely managing the key using environment variables (.env file).
• The OpenAI Python SDK simplifies interaction, allowing you to make a chat completion request with the client.chat.completions.create() method.
• A basic request requires specifying a model and a messages list containing the prompt.

You've built the fundamental block. In our next lesson, we will build upon this foundation. You'll learn how to structure your prompts more effectively using system and user roles to better control the LLM's personality and behavior. This will give you more fine-grained command over the conversations you orchestrate in your code.