Gemini Models Guide

# Read entire book or long document
with open('long_book.txt', 'r', encoding='utf-8') as f:
    book_content = f.read()

response = client.chat.completions.create(
    model="gemini-2.5-pro",  # 2M context
    messages=[
        {
            "role": "user",
            "content": f"""
            Please analyze this book and provide:
            1. Main theme summary
            2. Character relationship diagram
            3. Plot structure analysis
            4. Insights and evaluation

            Book content:
            {book_content}
            """
        }
    ],
    max_tokens=4000
)

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

import os

def read_code_files(directory):
    """Read all code files"""
    code_content = []
    for root, dirs, files in os.walk(directory):
        for file in files:
            if file.endswith(('.py', '.js', '.java', '.cpp')):
                file_path = os.path.join(root, file)
                with open(file_path, 'r', encoding='utf-8') as f:
                    code_content.append(f"=== {file_path} ===\n{f.read()}\n")
    return '\n'.join(code_content)

# Read entire project
project_code = read_code_files('./my_project')

response = client.chat.completions.create(
    model="gemini-2.5-pro",
    messages=[
        {
            "role": "user",
            "content": f"""
            Please analyze this code repository and provide:
            1. Project architecture overview
            2. Key module functions
            3. Code quality assessment
            4. Improvement suggestions

            Code content:
            {project_code}
            """
        }
    ],
    max_tokens=3000
)

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

response = client.chat.completions.create(
    model="gemini-2.5-flash",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Compare these product images and analyze their design styles and features"},
                {
                    "type": "image_url",
                    "image_url": {"url": "https://example.com/product1.jpg"}
                },
                {
                    "type": "image_url",
                    "image_url": {"url": "https://example.com/product2.jpg"}
                },
                {
                    "type": "image_url",
                    "image_url": {"url": "https://example.com/product3.jpg"}
                }
            ]
        }
    ]
)

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

response = client.chat.completions.create(
    model="gemini-pro-vision",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": """
                    Extract all information from this invoice:
                    1. Invoice number
                    2. Date
                    3. Vendor information
                    4. Item details
                    5. Total amount

                    Output in JSON format
                    """
                },
                {
                    "type": "image_url",
                    "image_url": {"url": "https://example.com/invoice.jpg"}
                }
            ]
        }
    ]
)

import json
invoice_data = json.loads(response.choices[0].message.content)
print(invoice_data)

data_prompt = """
Please analyze the following data and provide:
1. Data trends analysis
2. Anomaly detection
3. Correlation analysis
4. Forecasting suggestions

Sales data (last 12 months):
Jan: 12000, Feb: 11500, Mar: 13200, Apr: 14100, May: 13800,
Jun: 15200, Jul: 14900, Aug: 13600, Sep: 14300, Oct: 15800,
Nov: 17200, Dec: 19500
"""

response = client.chat.completions.create(
    model="gemini-2.5-flash",
    messages=[{"role": "user", "content": data_prompt}],
    temperature=0.3  # Lower temperature for more objective analysis
)

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

response = client.chat.completions.create(
    model="gemini-2.5-flash",
    messages=[
        {
            "role": "user",
            "content": """
            Write a Python class with these requirements:
            1. Class name: DataProcessor
            2. Functions: read data, process data, save results
            3. Support CSV and JSON formats
            4. Include error handling
            5. Provide usage examples
            """
        }
    ],
    temperature=0.5
)

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

# Multi-modal analysis (video + text)
response = client.chat.completions.create(
    model="gemini-2.5-pro",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Analyze the content and techniques of this video"},
                {"type": "video_url", "video_url": {"url": "https://example.com/video.mp4"}}
            ]
        }
    ]
)

# ✅ Good prompt example
good_prompt = """
Task: Analyze user feedback data

Requirements:
1. Sentiment classification (positive/negative/neutral)
2. Extract key issues
3. Count issue frequency
4. Provide improvement suggestions

Output format:
{
  "sentiment_analysis": {...},
  "key_issues": [...],
  "suggestions": [...]
}

Feedback data:
[User feedback data]
"""

# ❌ Poor prompt example
bad_prompt = "Analyze this feedback data"

# ❌ Wasteful
def chat_wasteful(user_input, full_history):
    messages = full_history  # May exceed 128K threshold
    messages.append({"role": "user", "content": user_input})
    return client.chat.completions.create(
        model="gemini-2.5-flash",
        messages=messages
    )

# ✅ Economical
def chat_economical(user_input, recent_history):
    # Keep context under 128K for lower pricing
    messages = recent_history[-10:]  # Only recent messages
    messages.append({"role": "user", "content": user_input})
    return client.chat.completions.create(
        model="gemini-2.5-flash",
        messages=messages
    )

import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.laozhang.ai/v1"
)

async def batch_process(tasks):
    """Parallel batch processing"""
    async_tasks = [
        client.chat.completions.create(
            model="gemini-2.5-flash",
            messages=[{"role": "user", "content": task}]
        )
        for task in tasks
    ]

    results = await asyncio.gather(*async_tasks)
    return [r.choices[0].message.content for r in results]

# Usage
tasks = [
    "Translate this to English: 你好世界",
    "Summarize: [Long text]",
    "Analyze sentiment: [Review text]"
]

results = asyncio.run(batch_process(tasks))

import time
from openai import APIError, RateLimitError

def chat_with_retry(messages, max_retries=3):
    """Robust retry mechanism"""
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="gemini-2.5-flash",
                messages=messages
            )
            return response

        except RateLimitError as e:
            if attempt < max_retries - 1:
                wait_time = (2 ** attempt) * 2  # Exponential backoff
                print(f"Rate limited, retrying in {wait_time} seconds...")
                time.sleep(wait_time)
            else:
                raise

        except APIError as e:
            if attempt < max_retries - 1:
                print(f"API error, retrying...")
                time.sleep(2)
            else:
                raise

# Usage
response = chat_with_retry([
    {"role": "user", "content": "Hello"}
])

def process_long_document(document_path):
    """Best practices for processing long documents"""

    # Read document
    with open(document_path, 'r', encoding='utf-8') as f:
        content = f.read()

    # Check length
    token_count = len(content) // 4  # Rough estimate

    # Choose appropriate model
    if token_count < 100000:  # < 100K
        model = "gemini-2.5-flash"  # Lower price tier
    else:  # > 100K
        model = "gemini-2.5-pro"  # More powerful

    response = client.chat.completions.create(
        model=model,
        messages=[
            {
                "role": "user",
                "content": f"Analyze this document:\n\n{content}"
            }
        ],
        max_tokens=2000
    )

    return response.choices[0].message.content

class ConversationManager:
    def __init__(self, model="gemini-2.5-flash", max_history=10):
        self.model = model
        self.max_history = max_history
        self.messages = []

    def chat(self, user_input):
        # Add user message
        self.messages.append({
            "role": "user",
            "content": user_input
        })

        # Keep only recent N messages
        messages_to_send = self.messages[-self.max_history:]

        # Get response
        response = client.chat.completions.create(
            model=self.model,
            messages=messages_to_send
        )

        # Add assistant response
        assistant_message = response.choices[0].message.content
        self.messages.append({
            "role": "assistant",
            "content": assistant_message
        })

        return assistant_message

# Usage
conversation = ConversationManager()
print(conversation.chat("What is AI?"))
print(conversation.chat("What are its application scenarios?"))

def get_structured_output(prompt):
    """Get structured JSON output"""
    response = client.chat.completions.create(
        model="gemini-2.5-flash",
        messages=[
            {
                "role": "system",
                "content": "Always return results in JSON format"
            },
            {
                "role": "user",
                "content": f"{prompt}\n\nOutput in JSON format"
            }
        ],
        temperature=0.3  # Lower temperature for more structured output
    )

    import json
    return json.loads(response.choices[0].message.content)

# Usage
result = get_structured_output(
    "Extract personal information: Zhang San, 28 years old, software engineer"
)
print(result)