# How to Switch Between Azure OpenAI, OpenAI API, and GitHub Copilot Models

> Easily switch between Azure OpenAI, OpenAI API, and GitHub Copilot models. Learn how to update imports, environment variables, and endpoints with this quick guide.

- Repository: [Microsoft/generative-ai-for-beginners](https://github.com/microsoft/generative-ai-for-beginners)
- Tags: how-to-guide
- Published: 2026-02-26

---

**You can switch between Azure OpenAI, OpenAI API, and GitHub Copilot Models by changing the client library import, updating environment variables, and adjusting the endpoint configuration while keeping the core chat completion logic identical.**

The `microsoft/generative-ai-for-beginners` repository provides isolated Python implementations in `06-text-generation-apps/python/` that demonstrate exactly how to migrate between these three providers. Each example follows the same pattern—load credentials with `python-dotenv`, instantiate a provider-specific client, and execute a chat completion request—making provider switching a matter of updating imports and configuration rather than rewriting application logic.

## OpenAI API Implementation

The standard OpenAI implementation in [`06-text-generation-apps/python/oai-app.py`](https://github.com/microsoft/generative-ai-for-beginners/blob/main/06-text-generation-apps/python/oai-app.py) uses the `openai` library with automatic API key detection.

```python
from openai import OpenAI
import os
from dotenv import load_dotenv

load_dotenv()
client = OpenAI()
deployment = "gpt-3.5-turbo"

messages = [{"role": "user", "content": "Complete the following: Once upon a time there was a"}]
completion = client.chat.completions.create(
    model=deployment, 
    messages=messages
)

print(completion.choices[0].message.content)

```

This implementation requires only the `OPENAI_API_KEY` environment variable, which the `OpenAI()` constructor reads automatically from the environment.

## Azure OpenAI Service Configuration

To switch to Azure OpenAI, use the code from [`06-text-generation-apps/python/aoai-app.py`](https://github.com/microsoft/generative-ai-for-beginners/blob/main/06-text-generation-apps/python/aoai-app.py), which requires explicit endpoint configuration using the `AzureOpenAI` class.

```python
from openai import AzureOpenAI
import os
from dotenv import load_dotenv

load_dotenv()
client = AzureOpenAI(
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_key=os.environ["AZURE_OPENAI_API_KEY"],
    api_version="2024-02-01"
)

deployment = os.environ["AZURE_OPENAI_DEPLOYMENT"]
messages = [{"role": "user", "content": "Complete the following: Once upon a time there was a"}]
completion = client.chat.completions.create(
    model=deployment, 
    messages=messages
)

print(completion.choices[0].message.content)

```

Switching from OpenAI to Azure OpenAI requires changing the client import from `OpenAI` to `AzureOpenAI`, adding the `azure_endpoint` and `api_version` parameters, and updating the environment variables to include `AZURE_OPENAI_ENDPOINT`, `AZURE_OPENAI_API_KEY`, and `AZURE_OPENAI_DEPLOYMENT`.

## GitHub Copilot Models Setup

For GitHub Copilot Models, the repository uses the Azure AI Inference SDK as implemented in [`06-text-generation-apps/python/githubmodels-app.py`](https://github.com/microsoft/generative-ai-for-beginners/blob/main/06-text-generation-apps/python/githubmodels-app.py).

```python
import os
from azure.ai.inference import ChatCompletionsClient
from azure.ai.inference.models import SystemMessage, UserMessage
from azure.core.credentials import AzureKeyCredential
from dotenv import load_dotenv

load_dotenv()
token = os.environ["GITHUB_TOKEN"]
endpoint = "https://models.inference.ai.azure.com"
model_name = "gpt-4o"

client = ChatCompletionsClient(
    endpoint=endpoint,
    credential=AzureKeyCredential(token),
)

response = client.complete(
    messages=[
        SystemMessage(content="You are a helpful assistant."),
        UserMessage(content="Show me 5 recipes for a dish with chicken, potatoes, and carrots."),
    ],
    model=model_name,
    temperature=1.0,
    max_tokens=1000,
)

print(response.choices[0].message.content)

```

Switching to GitHub Copilot Models requires installing the `azure-ai-inference` package, importing `ChatCompletionsClient` from `azure.ai.inference`, and using `AzureKeyCredential` for authentication with your `GITHUB_TOKEN`.

## Environment Variable Management

All three implementations in the `microsoft/generative-ai-for-beginners` repository rely on `python-dotenv` to load credentials from a `.env` file. The repository includes a `.env.copy` template that you duplicate and populate according to your active provider.

| Provider | Required Variables | Source File |
|----------|-------------------|-------------|
| **OpenAI** | `OPENAI_API_KEY` | [`06-text-generation-apps/python/oai-app.py`](https://github.com/microsoft/generative-ai-for-beginners/blob/main/06-text-generation-apps/python/oai-app.py) |
| **Azure OpenAI** | `AZURE_OPENAI_ENDPOINT`, `AZURE_OPENAI_API_KEY`, `AZURE_OPENAI_DEPLOYMENT` | [`06-text-generation-apps/python/aoai-app.py`](https://github.com/microsoft/generative-ai-for-beginners/blob/main/06-text-generation-apps/python/aoai-app.py) |
| **GitHub Copilot Models** | `GITHUB_TOKEN` | [`06-text-generation-apps/python/githubmodels-app.py`](https://github.com/microsoft/generative-ai-for-beginners/blob/main/06-text-generation-apps/python/githubmodels-app.py) |

The [`shared/python/env_utils.py`](https://github.com/microsoft/generative-ai-for-beginners/blob/main/shared/python/env_utils.py) module provides validation helpers to ensure required variables are present before client initialization, preventing runtime authentication errors.

## Step-by-Step Provider Migration

To switch between Azure OpenAI, OpenAI API, and GitHub Copilot Models in your application:

1. **Install the appropriate client library**:
   - OpenAI/Azure: `pip install openai`
   - GitHub Models: `pip install azure-ai-inference`

2. **Update the client import and instantiation** using the code blocks from the specific provider sections above.

3. **Configure the model identifier**:
   - OpenAI: Use model names like `"gpt-3.5-turbo"`
   - Azure: Use your deployment name from the Azure portal
   - GitHub: Use model names like `"gpt-4o"` or `"gpt-4o-mini"`

4. **Populate environment variables** in your `.env` file for the selected provider.

Because all three clients use similar `chat.completions.create()` or `complete()` patterns with message arrays, your core prompting logic remains identical across providers.

## Summary

- The `microsoft/generative-ai-for-beginners` repository provides isolated examples in `06-text-generation-apps/python/` demonstrating how to switch between Azure OpenAI, OpenAI API, and GitHub Copilot Models.
- **OpenAI** uses the `openai.OpenAI` client with `OPENAI_API_KEY` and standard model names.
- **Azure OpenAI** requires `openai.AzureOpenAI` with explicit `azure_endpoint`, `api_version`, and deployment-specific environment variables.
- **GitHub Copilot Models** utilize `azure.ai.inference.ChatCompletionsClient` with `GITHUB_TOKEN` and the Azure AI Inference endpoint.
- All implementations use `python-dotenv` for credential management, allowing you to switch providers by updating imports, client instantiation, and environment variables while maintaining consistent chat completion logic.

## Frequently Asked Questions

### Can I use the same prompt code for all three providers?

Yes. The chat completion interface accepts the same `messages` array format across OpenAI, Azure OpenAI, and GitHub Copilot Models. You only need to change the client initialization and model identifier; the prompting logic and message structure remain identical.

### What is the difference between the OpenAI and Azure OpenAI client libraries?

Both use the `openai` Python package, but Azure OpenAI requires the `AzureOpenAI` class with explicit `azure_endpoint` and `api_version` parameters, while the standard OpenAI client uses `OpenAI()` which only requires the API key. The Azure client routes requests to your private Azure endpoint rather than OpenAI's public API.

### Do I need separate environment files for each provider?

No. You can maintain a single `.env` file and populate the variables for your active provider. The scripts in `microsoft/generative-ai-for-beginners` use `python-dotenv` to load whichever variables are present. For cleaner separation, you can create `.env.openai`, `.env.azure`, and `.env.github` and symlink or copy them to `.env` as needed.

### Which models are available through GitHub Copilot Models?

GitHub Copilot Models provides access to models like `gpt-4o`, `gpt-4o-mini`, and others through the Azure AI Inference endpoint at `https://models.inference.ai.azure.com`. The available models may vary based on your GitHub account permissions and Copilot subscription tier.