Google is about to remove free access to Gemini Flash and Pro

Learn how to work with Google's Gemini API to interact with different AI models, preparing for the upcoming restrictions on free access to Gemini Flash and Pro models.

Introduction

In this tutorial, you'll learn how to work with the Google Gemini API to build a simple chat application that demonstrates the differences between the free and paid models. As Google prepares to restrict access to the standard Gemini Flash model for free users, we'll explore how to programmatically interact with different Gemini models and handle API authentication. This tutorial will teach you how to set up your development environment, authenticate with Google AI, and make requests to different Gemini models using Python.

Prerequisites

Basic Python programming knowledge
Google Cloud account with billing enabled
Google AI Studio access and API key
Python 3.7 or higher installed
pip package manager

Step-by-step instructions

1. Setting Up Your Development Environment

1.1 Install Required Packages

First, create a virtual environment and install the necessary packages for working with the Gemini API:

python -m venv gemini_env
source gemini_env/bin/activate  # On Windows: gemini_env\Scripts\activate
pip install google-generativeai

Why: Creating a virtual environment isolates your project dependencies and prevents conflicts with other Python packages on your system.

1.2 Get Your Google AI API Key

Visit Google AI Studio and create a new project. Navigate to the API section to generate your API key. Store this key securely and never commit it to version control.

2. Initialize the Gemini Client

2.1 Create Your Main Python Script

Create a file called gemini_chat.py and start by importing the required libraries:

import google.generativeai as genai
import os
from getpass import getpass

# Configure the API key
api_key = os.getenv('GEMINI_API_KEY') or getpass('Enter your Gemini API key: ')
genai.configure(api_key=api_key)

# Define available models
MODELS = {
    'flash_lite': 'gemini-1.5-flash-001',
    'flash': 'gemini-1.5-flash',
    'pro': 'gemini-1.5-pro'
}

print("Gemini API initialized successfully!")

Why: This setup allows you to programmatically switch between different models and handles API key management securely.

3. Creating Different Chat Functions

3.1 Implement a Basic Chat Function

Now create a function that can chat with different models:

def chat_with_model(model_name, user_message):
    try:
        model = genai.GenerativeModel(model_name)
        response = model.generate_content(user_message)
        return response.text
    except Exception as e:
        return f"Error: {str(e)}"

# Test with different models
print("Testing Flash Lite model:")
result = chat_with_model('flash_lite', "What is the capital of France?")
print(result)

print("\nTesting Flash model:")
result = chat_with_model('flash', "Explain quantum computing in simple terms")
print(result)

Why: This function demonstrates how to switch between different models programmatically, showing how the free tier will be limited to Flash Lite.

3.2 Add Model Selection Logic

Enhance your script to handle model selection based on user preferences:

def select_and_chat(model_type, message):
    if model_type in MODELS:
        model_name = MODELS[model_type]
        print(f"Using {model_name} model")
        return chat_with_model(model_name, message)
    else:
        return "Invalid model type. Choose from: flash_lite, flash, pro"

# Example usage
print(select_and_chat('flash_lite', 'Write a poem about technology'))
print(select_and_chat('flash', 'What are the benefits of AI in healthcare?'))

4. Handling Rate Limits and Errors

4.1 Implement Error Handling

Update your chat function to handle common API errors:

import time
from google.api_core import exceptions

def robust_chat(model_name, message, max_retries=3):
    for attempt in range(max_retries):
        try:
            model = genai.GenerativeModel(model_name)
            response = model.generate_content(message)
            return response.text
        except exceptions.ResourceExhausted as e:
            print(f"Rate limit exceeded. Waiting before retry {attempt + 1}...")
            time.sleep(2 ** attempt)  # Exponential backoff
        except exceptions.Unauthorized as e:
            return "Authentication failed. Please check your API key."
        except Exception as e:
            return f"Unexpected error: {str(e)}"
    return "Failed after maximum retries"

# Test the robust function
result = robust_chat('flash', 'Explain machine learning in 100 words')
print(result)

Why: Proper error handling ensures your application gracefully manages API limitations and authentication issues, which will become more critical as Google restricts access to premium models.

5. Creating a Simple User Interface

5.1 Build a Command-Line Chat Interface

Create a simple interactive chat interface:

def interactive_chat():
    print("\n=== Gemini Chat Interface ===")
    print("Available models: flash_lite, flash, pro")
    print("Type 'quit' to exit\n")
    
    while True:
        model_choice = input("Select model (flash_lite/flash/pro): ").strip()
        if model_choice.lower() == 'quit':
            break
        
        user_input = input("You: ").strip()
        if user_input.lower() == 'quit':
            break
        
        response = select_and_chat(model_choice, user_input)
        print(f"Gemini: {response}\n")

# Uncomment to run interactive chat
# interactive_chat()

Why: This interface demonstrates how users will interact with different models, helping you understand the practical implications of Google's model access changes.

6. Testing Your Implementation

6.1 Run Your Complete Script

Execute your complete script to test all functionality:

if __name__ == "__main__":
    # Test all models
    test_message = "Explain the difference between machine learning and deep learning"
    
    for model_name in ['flash_lite', 'flash', 'pro']:
        print(f"\n--- Testing {model_name} ---")
        result = chat_with_model(MODELS[model_name], test_message)
        print(result[:200] + "...")  # Show first 200 characters

Why: Testing all models helps you understand their capabilities and how the free tier limitations will affect your applications.

Summary

This tutorial demonstrated how to work with the Google Gemini API to interact with different models, including the upcoming restrictions for free users. You learned how to set up authentication, create chat functions, handle errors, and build a simple user interface. As Google prepares to limit free access to the standard Flash model, this implementation shows how developers can prepare for these changes by programmatically managing model access and planning for paid subscriptions when needed.

Remember that while Flash Lite will remain free, access to Flash and Pro models will require a Google AI Plus subscription. This tutorial helps you understand how to structure your applications to work within these new limitations while still providing value to users.