Gemini Practical Techniques [Part 1]

Setup and context — About This Article Series

This series extracts insights from Gemini Lab premium content and presents them in practical form for both free and premium users.

Part 1 Purpose: Master fundamental skills for integrating Gemini API into real projects Part 2 Purpose: Build production-grade systems, voice AI, monetization pipelines

This guide assumes Python 3.10+, but REST API concepts apply across languages.

Gemini API Design Patterns

Basic Text Generation Structure

Let's start with minimal implementation:

import google.generativeai as genai
import os
 
# Configure API key
api_key = os.getenv("GEMINI_API_KEY")
genai.configure(api_key=api_key)
 
# Initialize model
model = genai.GenerativeModel("gemini-2.5-pro")
 
# Simple text generation
response = model.generate_content("Explain Japan's economic growth rate in 3 sentences")
print(response.text)

Key Points:

GenerativeModel specifies the model ("gemini-2.5-pro", "gemini-2.5-flash", etc.)
generate_content() accepts the prompt
Response available as response.text

More Detailed Configuration

Real projects require parameter control:

from google.generativeai.types import GenerationConfig, SafetySetting, HarmCategory, HarmBlockThreshold
 
response = model.generate_content(
    contents="What are best practices for designing Python Web APIs?",
    generation_config=GenerationConfig(
        temperature=0.7,           # Creativity (0.0-2.0)
        top_p=0.95,               # Diversity control
        top_k=40,                 # Narrow candidate pool
        max_output_tokens=1024,   # Max response tokens
        stop_sequences=["---"],   # Output terminator
    ),
    safety_settings=[
        SafetySetting(
            category=HarmCategory.HARM_CATEGORY_UNSPECIFIED,
            threshold=HarmBlockThreshold.BLOCK_NONE,
        )
    ]
)
 
print(response.text)

Parameter Explanation:

temperature: Lower = deterministic, higher = random. Usually 0.5-0.9
top_p: Nucleus sampling. Narrows to high-probability choices. Usually 0.8-0.95
max_output_tokens: Set within API limits. 1024-100000

Streaming Responses

For long responses, return partial results to improve user experience:

model = genai.GenerativeModel("gemini-2.5-pro")
 
# Enable streaming
response = model.generate_content(
    contents="Explain AI history in 1000 words",
    stream=True
)
 
# Output text progressively
for chunk in response:
    if chunk.text:
        print(chunk.text, end="", flush=True)
 
print()  # Newline

Use Case: Stream responses to clients via Server-Sent Events (SSE). Users see AI "thinking" in real-time.

Multi-turn Conversation Management

Manage multiple questions and answers as one conversation:

model = genai.GenerativeModel("gemini-2.5-pro")
 
# Initialize chat history
chat = model.start_chat(history=[])
 
# Turn 1
user_input_1 = "Teach me about async programming in Python"
response_1 = chat.send_message(user_input_1)
print(f"User: {user_input_1}")
print(f"AI: {response_1.text}\n")
 
# Turn 2 (can reference previous response)
user_input_2 = "Give 3 examples of asyncio.gather()"
response_2 = chat.send_message(user_input_2)
print(f"User: {user_input_2}")
print(f"AI: {response_2.text}\n")
 
# Turn 3
user_input_3 = "Which is most practical?"
response_3 = chat.send_message(user_input_3)
print(f"User: {user_input_3}")
print(f"AI: {response_3.text}\n")

Important: Conversation context is auto-managed by model.start_chat(). No manual history tracking needed.

Function Calling Basics

Function Calling allows AI to invoke external tools (APIs, databases, functions) as needed.

Tool Definition and Calling Pattern

import json
 
# Define tools (functions)
tools = [
    {
        "name": "get_product_info",
        "description": "Get product info (price, stock) from product ID",
        "input_schema": {
            "type": "object",
            "properties": {
                "product_id": {
                    "type": "string",
                    "description": "Product ID (e.g. PROD-12345)"
                },
                "include_reviews": {
                    "type": "boolean",
                    "description": "Include review info (default: false)"
                }
            },
            "required": ["product_id"]
        }
    },
    {
        "name": "update_inventory",
        "description": "Update inventory count",
        "input_schema": {
            "type": "object",
            "properties": {
                "product_id": {"type": "string"},
                "quantity_change": {"type": "integer", "description": "Change amount"}
            },
            "required": ["product_id", "quantity_change"]
        }
    }
]
 
# Actual tool implementation
def get_product_info(product_id: str, include_reviews: bool = False) -> dict:
    """Real business logic"""
    products_db = {
        "PROD-001": {"name": "Laptop", "price": 150000, "stock": 5},
        "PROD-002": {"name": "Mouse", "price": 3000, "stock": 50},
    }
    if product_id not in products_db:
        return {"error": "Product not found"}
 
    info = products_db[product_id]
    if include_reviews:
        info["reviews"] = "4.5 stars (100 reviews)"
    return info
 
def update_inventory(product_id: str, quantity_change: int) -> dict:
    """Inventory update (real: database operation)"""
    return {"status": "success", "product_id": product_id, "change": quantity_change}
 
# API call
model = genai.GenerativeModel(
    "gemini-2.5-pro",
    tools=tools
)
 
# User request
user_message = "Reduce PROD-001 inventory by 3 and show latest info"
response = model.generate_content(user_message)
 
# Handle Function Calling results
for content_part in response.content:
    if hasattr(content_part, 'function_call'):
        # Get the function AI wants to call
        func_call = content_part.function_call
        func_name = func_call.name
        func_args = {k: v for k, v in func_call.args.items()}
 
        print(f"AI called '{func_name}': {func_args}")
 
        # Execute actual function
        if func_name == "get_product_info":
            result = get_product_info(**func_args)
        elif func_name == "update_inventory":
            result = update_inventory(**func_args)
        else:
            result = {"error": "Unknown function"}
 
        print(f"Result: {result}")
 
        # Return result to AI
        second_response = model.generate_content([
            user_message,
            response,
            {"role": "user", "parts": [{"text": f"Function result: {json.dumps(result)}"}]}
        ])
        print(f"AI Final Answer: {second_response.text}")

Flow:

User
  ↓
AI (decides function call needed)
  ↓
Specify function and arguments
  ↓
App (execute actual function)
  ↓
Return result to AI
  ↓
AI (incorporate result into response)
  ↓
User

Structured Output (responseSchema) Usage

To always get JSON-formatted responses:

from google.generativeai.types import ResponseSchema, GenerateContentResponse
 
# Define output schema
schema = [
    ResponseSchema(
        name="analysis_result",
        description="Analysis result",
        type="object",
        properties=[
            ResponseSchema(name="title", description="Title", type="string"),
            ResponseSchema(name="summary", description="Summary (max 200 chars)", type="string"),
            ResponseSchema(
                name="key_points",
                description="Important points",
                type="array",
                items=ResponseSchema(name="point", type="string")
            ),
            ResponseSchema(name="confidence", description="Confidence (0-100)", type="integer")
        ]
    )
]
 
model = genai.GenerativeModel(
    "gemini-2.5-pro",
    generation_config=GenerationConfig(
        response_mime_type="application/json",
        response_schema=schema,
    )
)
 
prompt = """
Analyze this text:
"AI improves diagnosis accuracy in healthcare,
  automates anomaly detection in manufacturing,
  and strengthens fraud detection in finance"
"""
 
response = model.generate_content(prompt)
 
# Directly parse as JSON
import json
result = json.loads(response.text)
print(json.dumps(result, indent=2, ensure_ascii=False))

Example Output:

{
  "analysis_result": {
    "title": "AI's Real-World Application Scope",
    "summary": "AI is deployed across healthcare, manufacturing, and finance with measurable impact in diagnosis, anomaly detection, and fraud prevention.",
    "key_points": [
      "Healthcare: Improved diagnostic accuracy",
      "Manufacturing: Automated anomaly detection",
      "Finance: Enhanced fraud detection"
    ],
    "confidence": 95
  }
}

Multimodal Input Fundamentals

Basic Image Analysis

from pathlib import Path
 
# Load local image
image_path = Path("screenshot.png")
image_data = image_path.read_bytes()
 
# Detect MIME type
import mimetypes
mime_type, _ = mimetypes.guess_type(str(image_path))
 
# Send to Gemini
model = genai.GenerativeModel("gemini-2.5-pro")
response = model.generate_content([
    "Describe what's in this image. If there's text, translate it to English.",
    {
        "mime_type": mime_type,
        "data": image_data
    }
])
 
print(response.text)

Supported Formats:

Images: PNG, JPEG, GIF, WebP
Video: MP4, MPEG, MOV, AVI, FLV, MKV, WMV, WEBM (up to 25MB)
Audio: WAV, MP3, AIFF, AAC, OGG, FLAC

PDF Document Processing

import mimetypes
 
# Upload PDF
pdf_path = "technical_report.pdf"
with open(pdf_path, "rb") as pdf_file:
    pdf_data = pdf_file.read()
 
model = genai.GenerativeModel("gemini-2.5-pro")
 
response = model.generate_content([
    {
        "mime_type": "application/pdf",
        "data": pdf_data
    },
    "Extract from this document:\n1. Main theme\n2. Author\n3. Key conclusions\n4. Reference count"
])
 
print(response.text)

Key Points:

PDFs up to 1M tokens (all pages) processed at once
Tables and charts recognized
OCR-capable for scanned PDFs

Using 1M Token Context

Analyze multiple large files:

import os
from pathlib import Path
 
# Load multiple PDFs
pdf_files = list(Path("documents/").glob("*.pdf"))
 
contents = []
 
# Add prompt first
contents.append({
    "text": """Perform integrated analysis of these 3 technical reports:
1. Identify common themes
2. List methodology differences
3. Identify conclusion conflicts
4. State overall recommendations"""
})
 
# Add all PDFs
for pdf_path in pdf_files[:3]:  # First 3 files
    with open(pdf_path, "rb") as f:
        contents.append({
            "mime_type": "application/pdf",
            "data": f.read()
        })
 
model = genai.GenerativeModel("gemini-2.5-pro")
response = model.generate_content(contents)
 
print(response.text)

Real-World Uses:

Compare 5-10 academic papers
Integrate insights from multiple academic sources
Analyze multi-year monthly/annual reports
Check reference consistency in legal documents

Google Workspace Integration Tips

Docs Auto-Document Creation Pattern

from google.auth.transport.requests import Request
from google.oauth2.service_account import Credentials
from googleapiclient.discovery import build
 
# Create document via Google Docs API
docs_service = build('docs', 'v1', credentials=credentials)
drive_service = build('drive', 'v3', credentials=credentials)
 
# Create new document
doc = docs_service.documents().create(body={'title': 'AI Report 2026'}).execute()
doc_id = doc['documentId']
 
# Generate content with Gemini
model = genai.GenerativeModel("gemini-2.5-pro")
response = model.generate_content(
    "Write a 3000-word report on Japan's AI industry state and prospects. Output in markdown."
)
 
# Insert Gemini output into Docs
requests = [
    {
        'insertText': {
            'text': response.text,
            'location': {'index': 1}
        }
    }
]
 
docs_service.documents().batchUpdate(
    documentId=doc_id,
    body={'requests': requests}
).execute()
 
print(f"Document created: https://docs.google.com/document/d/{doc_id}")

Sheets Data Analysis

# Load data from Google Sheets
sheets_service = build('sheets', 'v4', credentials=credentials)
 
result = sheets_service.spreadsheets().values().get(
    spreadsheetId='SHEET_ID',
    range='Sheet1!A1:Z100'
).execute()
 
data = result.get('values', [])
 
# Analyze with Gemini
model = genai.GenerativeModel("gemini-2.5-pro")
analysis = model.generate_content(f"""
Analyze this sales data:
{data}
 
Analysis:
1. Top 3 products by revenue
2. Revenue share by region
3. Month-over-month change rate
4. Improvement recommendations
""")
 
# Record analysis results in Sheets
sheets_service.spreadsheets().values().update(
    spreadsheetId='SHEET_ID',
    range='Analysis!A1',
    valueInputOption='USER_ENTERED',
    body={'values': [[analysis.text]]}
).execute()

Next Steps — Part 2 (Premium) Topics

Part 1 covered API basics and introductory techniques. Part 2 dives deeper into:

Parallel Tool Calling: Execute multiple functions simultaneously for performance
Live API Voice Processing: Real-time voice conversation interface
Production Agent Systems: Autonomous agents with Gemini 2.5 Pro
Vertex AI Fine-tuning: Build domain-specific models
Context Caching: Cost reduction for large inputs
Veo 3 Video API: Auto-generate video from text
SaaS Monetization: Business models using Gemini API

Premium articles include production project code examples, performance optimization best practices, and troubleshooting guides.

Discuss your next steps in the Gemini Lab community.

Gemini Practical Techniques [Part 1] — API Basics, Prompt Design & Multimodal Fundamentals