全面掌握Gemini API：从零开始的快速入门指南-优快云博客

全面掌握Gemini API：从零开始的快速入门指南

【免费下载链接】cookbook A collection of guides and examples for the Gemini API. 项目地址: https://gitcode.com/GitHub_Trending/coo/cookbook

Gemini API是Google推出的新一代多模态人工智能API，代表了人工智能技术发展的最新成果。本指南将带您从零开始全面掌握Gemini API的核心功能和使用方法，包括API概述与核心功能、密钥获取与认证配置、基础文本生成与多模态输入实践，以及实时API与流式响应处理技巧。通过本指南，您将学会如何使用Gemini API构建智能和交互性强的应用程序，充分利用其强大的多模态理解和生成能力。

Gemini API概述与核心功能简介

Gemini API是Google推出的新一代多模态人工智能API，它代表了人工智能技术发展的最新成果。作为Google DeepMind团队开发的强大模型系列，Gemini API提供了前所未有的多模态理解和生成能力，让开发者能够构建更加智能和交互性强的应用程序。

核心架构与设计理念

Gemini API采用统一的客户端架构，通过google-genai SDK提供简洁而强大的接口。其核心设计理念包括：

统一客户端模式

from google import genai
from google.genai import types

# 初始化客户端
client = genai.Client(api_key=GEMINI_API_KEY)

# 选择模型
MODEL_ID = "gemini-2.5-flash"

这种设计使得开发者可以使用同一个客户端实例访问所有Gemini模型功能，大大简化了代码复杂度。

多模态能力矩阵

Gemini API支持丰富的多模态输入和输出，其能力矩阵如下表所示：

模态类型	输入支持	输出支持	典型应用场景
文本	✅	✅	内容生成、翻译、摘要
图像	✅	✅	图像描述、视觉问答
音频	✅	✅	语音识别、音乐生成
视频	✅	✅	视频分析、实时交互
PDF文档	✅	❌	文档理解、信息提取
代码	✅	✅	代码生成、调试

核心功能特性

1. 智能内容生成

Gemini API的核心功能之一是强大的内容生成能力。通过简单的API调用，开发者可以生成各种类型的内容：

# 文本生成示例
response = client.models.generate_content(
    model=MODEL_ID,
    contents="写一篇关于人工智能未来发展的短文"
)

print(response.text)

2. 多模态理解

Gemini能够同时处理和理解多种类型的数据输入，这种多模态能力通过以下流程图展示：

mermaid

3. 函数调用与工具使用

Gemini API支持函数调用功能，允许模型与外部工具和API进行交互：

# 函数定义示例
functions = [
    types.FunctionDeclaration(
        name="get_weather",
        description="获取指定城市的天气信息",
        parameters=types.Schema(
            type=types.Type.OBJECT,
            properties={
                "location": types.Schema(
                    type=types.Type.STRING,
                    description="城市名称"
                )
            },
            required=["location"]
        )
    )
]

# 使用函数调用
response = client.models.generate_content(
    model=MODEL_ID,
    contents="北京今天的天气怎么样？",
    tools=[types.Tool(function_declarations=functions)]
)

4. 实时交互能力

通过Live API功能，Gemini支持实时音频和视频交互：

class LiveAPIHandler:
    def __init__(self, video_mode="default"):
        self.client = genai.Client(api_key=API_KEY)
        
    def send_realtime(self, audio_data, video_frames):
        """发送实时音视频数据"""
        response = self.client.models.generate_content(
            model="gemini-live",
            contents=[
                types.Content(parts=[types.Part(audio_data=audio_data)]),
                types.Content(parts=[types.Part(video_data=video_frames)])
            ]
        )
        return response

模型生态系统

Gemini API提供多种模型选择，每个模型针对不同的使用场景进行优化：

模型名称	主要特点	适用场景
gemini-2.5-flash	快速响应，成本效益高	实时应用、大规模部署
gemini-2.5-pro	最强能力，复杂推理	研究、复杂任务处理
gemini-2.0-flash-exp	多模态实验特性	原型开发、功能测试
gemini-live	实时音视频处理	对话系统、直播应用

安全与可控性

Gemini API内置了强大的安全机制和内容控制功能：

# 安全设置示例
safety_settings = [
    types.SafetySetting(
        category=types.HarmCategory.HARM_CATEGORY_HARASSMENT,
        threshold=types.HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE
    ),
    types.SafetySetting(
        category=types.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
        threshold=types.HarmBlockThreshold.BLOCK_ONLY_HIGH
    )
]

response = client.models.generate_content(
    model=MODEL_ID,
    contents="用户输入内容",
    safety_settings=safety_settings
)

开发工作流程

典型的Gemini API开发工作流程如下所示：

mermaid

性能优化特性

Gemini API提供了多种性能优化机制：

令牌计数与成本控制

# 令牌计数
token_count = client.models.count_tokens(
    model=MODEL_ID,
    contents="需要计数的文本内容"
)
print(f"输入令牌数: {token_count.total_tokens}")

上下文缓存

# 启用上下文缓存
response = client.models.generate_content(
    model=MODEL_ID,
    contents="用户查询",
    config=types.GenerateContentConfig(
        cached_content="之前的相关内容"
    )
)

扩展性与集成

Gemini API设计具有良好的扩展性，支持多种集成方式：

REST API直接调用：适合各种编程语言环境
官方SDK支持：Python、Go、Node.js、Dart、Android、Swift
第三方库集成：与主流开发框架无缝集成
云平台部署：支持Google Cloud Vertex AI企业级部署

通过这种全面而灵活的设计，Gemini API为开发者提供了一个强大、易用且可扩展的人工智能开发平台，无论是简单的文本生成还是复杂的多模态应用，都能找到合适的解决方案。

API密钥获取与认证配置详解

在开始使用Gemini API之前，获取和配置API密钥是至关重要的第一步。本节将详细指导您如何创建API密钥、安全地存储密钥，以及在不同开发环境中正确配置认证。

API密钥的创建与获取

Gemini API使用API密钥进行身份验证，您可以通过Google AI Studio快速创建API密钥：

访问Google AI Studio：打开浏览器并导航至 https://aistudio.google.com/app/apikey
创建API密钥：使用您的Google账户登录后，点击"创建API密钥"按钮，系统将自动生成一个唯一的API密钥
复制并保存密钥：将生成的API密钥复制到安全的位置，建议使用密码管理器进行存储

重要安全提示：API密钥相当于您的账户密码，请勿将其直接硬编码在代码中或提交到版本控制系统（如GitHub）。

环境变量配置方法

在不同开发环境中，推荐使用环境变量来安全地管理API密钥：

Linux/macOS系统配置

# 临时环境变量（仅当前终端会话有效）
export GOOGLE_API_KEY="your_actual_api_key_here"

# 永久环境变量（添加到shell配置文件）
echo 'export GOOGLE_API_KEY="your_actual_api_key_here"' >> ~/.bashrc
source ~/.bashrc

Windows系统配置

# 命令行设置（仅当前会话）
set GOOGLE_API_KEY=your_actual_api_key_here

# PowerShell设置
$env:GOOGLE_API_KEY="your_actual_api_key_here"

Python代码中的环境变量使用

import os
from google import genai

# 从环境变量读取API密钥
api_key = os.environ.get('GOOGLE_API_KEY')

if not api_key:
    raise ValueError("GOOGLE_API_KEY environment variable not set")

# 初始化Gemini客户端
client = genai.Client(api_key=api_key)

Colab环境中的密钥管理

在Google Colab环境中，推荐使用Colab Secrets功能来安全存储API密钥：

from google.colab import userdata
from google import genai

# 从Colab Secrets读取API密钥
try:
    GOOGLE_API_KEY = userdata.get('GOOGLE_API_KEY')
    client = genai.Client(api_key=GOOGLE_API_KEY)
except userdata.SecretNotFoundError:
    print("请先在Colab Secrets中设置GOOGLE_API_KEY")
except userdata.NotebookAccessError:
    print("请授权笔记本访问Secrets")

认证配置流程图

以下是API密钥认证配置的完整流程：

mermaid

多环境配置策略

在实际开发中，您可能需要为不同环境配置不同的API密钥：

开发环境配置

# config.py - 环境配置管理
import os
from dataclasses import dataclass

@dataclass
class GeminiConfig:
    api_key: str
    base_url: str = "https://generativelanguage.googleapis.com"
    model: str = "gemini-2.0-flash"

def get_config(env: str = "development") -> GeminiConfig:
    configs = {
        "development": GeminiConfig(
            api_key=os.getenv("DEV_GOOGLE_API_KEY"),
            model="gemini-2.0-flash"
        ),
        "production": GeminiConfig(
            api_key=os.getenv("PROD_GOOGLE_API_KEY"),
            model="gemini-2.5-pro"
        ),
        "testing": GeminiConfig(
            api_key=os.getenv("TEST_GOOGLE_API_KEY"),
            model="gemini-2.5-flash-lite"
        )
    }
    return configs.get(env, configs["development"])

密钥轮换与安全管理

为确保API密钥的安全性，建议实施以下最佳实践：

定期轮换密钥：每3-6个月更换一次API密钥
最小权限原则：仅为必要功能授予API密钥权限
监控使用情况：定期检查API调用日志，发现异常及时处理
多密钥策略：为不同应用和服务使用不同的API密钥

# 密钥轮换示例
import datetime
from google import genai

class ManagedGeminiClient:
    def __init__(self):
        self.api_key = self._get_current_api_key()
        self.client = genai.Client(api_key=self.api_key)
        self.last_rotation = datetime.datetime.now()
    
    def _get_current_api_key(self):
        # 实现密钥轮换逻辑
        current_env = os.getenv("APP_ENV", "development")
        return os.getenv(f"{current_env.upper()}_GOOGLE_API_KEY")
    
    def check_and_rotate(self):
        # 检查是否需要轮换密钥
        if (datetime.datetime.now() - self.last_rotation).days > 90:
            self._rotate_key()
    
    def _rotate_key(self):
        # 实现密钥轮换逻辑
        new_key = self._get_new_api_key()
        self.api_key = new_key
        self.client = genai.Client(api_key=new_key)
        self.last_rotation = datetime.datetime.now()

常见问题与解决方案

问题类型	错误信息	解决方案
密钥未设置	`GOOGLE_API_KEY environment variable not set`	检查环境变量设置或使用Colab Secrets
密钥无效	`401 Unauthorized`	重新生成API密钥并更新配置
权限不足	`403 Permission Denied`	检查API密钥的权限设置
速率限制	`429 Too Many Requests`	实现请求限流和重试机制

通过遵循上述认证配置指南，您可以确保Gemini API的安全、可靠访问，为后续的API调用奠定坚实基础。

基础文本生成与多模态输入实践

Gemini API 提供了强大的文本生成和多模态处理能力，让开发者能够构建智能的AI应用。本节将深入探讨如何使用Gemini API进行基础文本生成以及处理多种模态的输入数据。

文本生成基础

Gemini API的核心功能是通过generate_content方法生成文本响应。以下是一个简单的文本生成示例：

from google import genai
from google.genai import types

# 初始化客户端
client = genai.Client(api_key="YOUR_API_KEY")

# 选择模型
MODEL_ID = "gemini-2.5-flash"

# 发送文本提示
response = client.models.generate_content(
    model=MODEL_ID,
    contents="解释量子计算的基本原理"
)

print(response.text)

令牌计数

在处理文本时，了解令牌数量对于成本控制和性能优化至关重要：

# 计算输入令牌数量
response = client.models.count_tokens(
    model=MODEL_ID,
    contents="量子计算使用量子比特而不是经典比特"
)

print(f"总令牌数: {response.total_tokens}")

多模态输入处理

Gemini API支持多种输入模态，包括图像、音频、视频和文档。以下是处理不同模态输入的实践方法：

图像处理

import requests
import pathlib
from PIL import Image

# 下载并处理图像
image_url = "https://example.com/sample.jpg"
img_bytes = requests.get(image_url).content
img_path = pathlib.Path('sample.jpg')
img_path.write_bytes(img_bytes)

# 使用图像进行多模态推理
response = client.models.generate_content(
    model=MODEL_ID,
    contents=[
        "描述这张图片中的场景",
        types.Part.from_bytes(
            data=img_bytes,
            mime_type="image/jpeg"
        )
    ]
)

print(response.text)

音频处理

# 上传音频文件
audio_sample = client.files.upload(file='sample.mp3')

# 使用音频进行多模态分析
response = client.models.generate_content(
    model=MODEL_ID,
    contents=audio_sample
)

print(response.text)

多模态输入组合

Gemini API支持同时处理多种模态的输入，实现更复杂的推理任务：

# 组合文本和图像输入
response = client.models.generate_content(
    model=MODEL_ID,
    contents=[
        "基于这张图片和以下描述生成一个故事：",
        types.Part.from_bytes(data=img_bytes, mime_type="image/jpeg"),
        "图片展示了一个古老的城堡，周围有茂密的森林"
    ]
)

输入格式支持

Gemini API支持多种文件格式，具体支持情况如下表所示：

模态类型	支持格式	MIME类型	最大文件大小
图像	JPEG, PNG, WEBP, GIF	image/jpeg, image/png, image/webp, image/gif	20MB
音频	MP3, WAV, FLAC	audio/mpeg, audio/wav, audio/flac	10MB
视频	MP4, MOV, AVI	video/mp4, video/quicktime, video/x-msvideo	100MB
文档	PDF, DOCX, TXT	application/pdf, application/vnd.openxmlformats-officedocument.wordprocessingml.document, text/plain	10MB

多模态处理流程

以下是Gemini API处理多模态输入的基本流程：

mermaid

最佳实践

文件预处理：确保输入文件格式正确，大小符合要求
令牌优化：对于大文件，考虑使用count_tokens预先计算成本
错误处理：实现适当的异常处理机制
性能考虑：多模态处理通常需要更多计算资源，合理设计请求频率

实际应用场景

图像描述生成

def generate_image_description(image_path, context_prompt=""):
    with open(image_path, 'rb') as f:
        image_data = f.read()
    
    prompt = "详细描述这张图片的内容和场景"
    if context_prompt:
        prompt = f"{context_prompt}\n{prompt}"
    
    response = client.models.generate_content(
        model=MODEL_ID,
        contents=[
            prompt,
            types.Part.from_bytes(data=image_data, mime_type="image/jpeg")
        ]
    )
    return response.text

多语言图像理解

def multilingual_image_analysis(image_path, target_language="中文"):
    with open(image_path, 'rb') as f:
        image_data = f.read()
    
    response = client.models.generate_content(
        model=MODEL_ID,
        contents=[
            f"用{target_language}描述这张图片并分析其中的主要元素",
            types.Part.from_bytes(data=image_data, mime_type="image/jpeg")
        ]
    )
    return response.text

通过掌握基础文本生成和多模态输入处理，开发者可以构建更加智能和交互性强的AI应用。Gemini API的多模态能力为创意应用开发提供了强大的技术基础。

实时API与流式响应处理技巧

Gemini API的实时API（Live API）和流式响应处理是现代AI应用开发中的关键技术，它们为开发者提供了低延迟、双向交互的能力，让AI应用更加自然和响应迅速。本节将深入探讨这些技术的核心概念、实现方法和最佳实践。

实时API架构与工作原理

Gemini Live API采用WebSocket协议实现双向实时通信，支持音频、视频和文本的多模态交互。其核心架构基于事件驱动的异步处理模型：

mermaid

实时API的核心优势在于其低延迟特性，特别适合需要即时反馈的应用场景，如语音助手、实时翻译和交互式对话系统。

流式响应处理基础

流式响应允许应用在模型生成完整响应之前就开始处理部分结果，显著提升用户体验。Gemini API提供了多种流式处理方式：

Python SDK流式处理

from google import genai

# 初始化客户端
client = genai.Client(api_key=GOOGLE_API_KEY)

# 同步流式处理
for chunk in client.models.generate_content_stream(
    model='gemini-2.0-flash',
    contents='请讲述一个关于人工智能的故事'
):
    if chunk.text:
        print(chunk.text, end='', flush=True)

异步流式处理

import asyncio

async def async_stream_example():
    async for chunk in await client.aio.models.generate_content_stream(
        model='gemini-2.0-flash',
        contents="写一个关于猫的可爱故事"
    ):
        if chunk.text:
            print(chunk.text, end='', flush=True)

# 运行异步流
await async_stream_example()

实时API的多模态处理

Live API支持同时处理多种输入和输出模态，以下是主要的配置选项：

模态类型	输入支持	输出支持	适用场景
文本(TEXT)	✅	✅	传统聊天对话
音频(AUDIO)	✅	✅	语音助手、播客
视频(VIDEO)	✅	❌	视频分析、实时监控
图像(IMAGE)	✅	❌	视觉问答、图像描述

多模态配置示例

# 配置响应模态
config = {
    "response_modalities": ["TEXT", "AUDIO"]
}

async with client.aio.live.connect(
    model="gemini-live-2.5-flash-preview", 
    config=config
) as session:
    # 发送多模态请求
    await session.send_client_content(
        turns={
            "role": "user", 
            "parts": [{"text": "请用中文回答这个问题"}]
        }, 
        turn_complete=True
    )
    
    # 处理多模态响应
    turn = session.receive()
    async for chunk in turn:
        if chunk.text is not None:
            print(f'文本: {chunk.text}')
        if chunk.audio is not None:
            # 处理音频数据
            process_audio(chunk.audio)

音频流处理技巧

处理实时音频流需要特殊的缓冲和处理技术，以下是一个完整的音频处理示例：

import wave
import base64
from IPython.display import Audio, display

class AudioStreamProcessor:
    def __init__(self, sample_rate=24000, channels=1):
        self.sample_rate = sample_rate
        self.channels = channels
        self.audio_buffer = bytearray()
    
    def process_audio_chunk(self, audio_data_b64):
        """处理base64编码的音频数据"""
        pcm_data = base64.b64decode(audio_data_b64)
        self.audio_buffer.extend(pcm_data)
        return len(pcm_data)
    
    def save_to_wav(self, filename):
        """保存音频缓冲为WAV文件"""
        with wave.open(filename, 'wb') as wf:
            wf.setnchannels(self.channels)
            wf.setsampwidth(2)  # 16-bit PCM
            wf.setframerate(self.sample_rate)
            wf.writeframes(self.audio_buffer)
    
    def play_audio(self):
        """在Jupyter中播放音频"""
        display(Audio(data=bytes(self.audio_buffer), 
                     rate=self.sample_rate))

# 使用示例
audio_processor = AudioStreamProcessor()

async def handle_audio_stream(session):
    turn = session.receive()
    async for chunk in turn:
        if hasattr(chunk, 'inline_data') and chunk.inline_data:
            audio_size = audio_processor.process_audio_chunk(
                chunk.inline_data.data
            )
            print(f"收到音频数据: {audio_size} 字节")
        
        if chunk.text:
            print(f"模型说: {chunk.text}")

错误处理与重连机制

实时连接需要健壮的错误处理机制：

import asyncio
from websockets.exceptions import ConnectionClosed

class RobustLiveAPIClient:
    def __init__(self, max_retries=3, retry_delay=2):
        self.max_retries = max_retries
        self.retry_delay = retry_delay
    
    async def connect_with_retry(self):
        """带重试机制的连接"""
        for attempt in range(self.max_retries):
            try:
                async with client.aio.live.connect(
                    model=MODEL, 
                    config=CONFIG
                ) as session:
                    return session
            except ConnectionClosed as e:
                print(f"连接断开，尝试 {attempt + 1}/{self.max_retries}")
                if attempt == self.max_retries - 1:
                    raise e
                await asyncio.sleep(self.retry_delay * (attempt + 1))
    
    async def safe_send(self, session, message):
        """安全的发送消息"""
        try:
            await session.send_client_content(
                turns={"role": "user", "parts": [{"text": message}]},
                turn_complete=True
            )
        except Exception as e:
            print(f"发送失败: {e}")
            # 重新建立连接
            return await self.connect_with_retry()
        return session

性能优化技巧

1. 连接池管理

对于高并发应用，实现连接池可以显著提升性能：

from queue import Queue
import asyncio

class ConnectionPool:
    def __init__(self, max_size=10):
        self.max_size = max_size
        self.pool = Queue(max_size)
        self._lock = asyncio.Lock()
    
    async def get_connection(self):
        """从池中获取连接"""
        async with self._lock:
            if not self.pool.empty():
                return self.pool.get()
            # 创建新连接
            return await client.aio.live.connect(
                model=MODEL, config=CONFIG)
    
    async def release_connection(self, connection):
        """释放连接回池中"""
        async with self._lock:
            if self.pool.qsize() < self.max_size:
                self.pool.put(connection)
            else:
                await connection.close()

2. 流式响应批处理

对于大量小文本块的流式响应，使用批处理减少IO操作：

class StreamingBatchProcessor:
    def __init__(self, batch_size=5, flush_interval=0.5):
        self.batch_size = batch_size
        self.flush_interval = flush_interval
        self.buffer = []
        self.last_flush = asyncio.get_event_loop().time()
    
    async def process_chunk(self, chunk):
        """处理流式块"""
        self.buffer.append(chunk.text)
        
        current_time = asyncio.get_event_loop().time()
        time_since_flush = current_time - self.last_flush
        
        if (len(self.buffer) >= self.batch_size or 
            time_since_flush >= self.flush_interval):
            await self.flush_buffer()
    
    async def flush_buffer(self):
        """刷新缓冲区"""
        if self.buffer:
            combined_text = ''.join(self.buffer)
            # 处理合并后的文本
            process_combined_text(combined_text)
            self.buffer.clear()
            self.last_flush = asyncio.get_event_loop().time()

实时API的高级应用模式

1. 多轮对话管理

class ConversationManager:
    def __init__(self, max_history=10):
        self.conversation_history = []
        self.max_history = max_history
    
    def add_message(self, role, content):
        """添加消息到历史"""
        self.conversation_history.append({
            "role": role,
            "content": content,
            "timestamp": asyncio.get_event_loop().time()
        })
        # 保持历史长度
        if len(self.conversation_history) > self.max_history:
            self.conversation_history.pop(0)
    
    async def continue_conversation(self, session, user_input):
        """继续多轮对话"""
        self.add_message("user", user_input)
        
        # 构建包含历史的请求
        turns = []
        for msg in self.conversation_history:
            turns.append({
                "role": msg["role"],
                "parts": [{"text": msg["content"]}]
            })
        
        await session.send_client_content(
            turns=turns,
            turn_complete=True
        )
        
        # 处理响应
        response_text = ""
        turn = session.receive()
        async for chunk in turn:
            if chunk.text:
                response_text += chunk.text
                print(chunk.text, end='', flush=True)
        
        self.add_message("assistant", response_text)
        return response_text

2. 实时音频转录与响应

import speech_recognition as sr

class RealTimeAudioProcessor:
    def __init__(self):
        self.recognizer = sr.Recognizer()
        self.microphone = sr.Microphone()
    
    async def audio_to_text_stream(self):
        """实时音频转文本流"""
        with self.microphone as source:
            self.recognizer.adjust_for_ambient_noise(source)
            print("开始聆听...")
            
            while True:
                try:
                    # 监听音频输入
                    audio = self.recognizer.listen(
                        source, timeout=1, phrase_time_limit=5
                    )
                    
                    # 识别语音
                    text = self.recognizer.recognize_google(
                        audio, language='zh-CN'
                    )
                    yield text
                    
                except sr.WaitTimeoutError:
                    continue
                except sr.UnknownValueError:
                    print("无法识别语音")
                except Exception as e:
                    print(f"识别错误: {e}")
                    break

# 使用示例
async def real_time_chat():
    audio_processor = RealTimeAudioProcessor()
    async with client.aio.live.connect(model=MODEL) as session:
        async for user_speech in audio_processor.audio_to_text_stream():
            print(f"用户说: {user_speech}")
            
            await session.send_client_content(
                turns={"role": "user", "parts": [{"text": user_speech}]},
                turn_complete=True
            )
            
            # 获取AI响应
            response = ""
            turn = session.receive()
            async for chunk in turn:
                if chunk.text:
                    response += chunk.text
                    print(chunk.text, end='', flush=True)
            
            print(f"\nAI响应: {response}")

监控与调试技巧

实时应用的调试需要特殊的工具和技术：

import logging
from datetime import datetime

class LiveAPIMonitor:
    def __init__(self):
        self.logger = logging.getLogger('LiveAPIMonitor')
        self.stats = {
            'messages_sent': 0,
            'messages_received': 0,
            'total_audio_bytes': 0,
            'start_time': datetime.now()
        }
    
    def log_message(self, direction, content_type, size=0):
        """记录消息统计"""
        timestamp = datetime.now().isoformat()
        self.logger.info(
            f"{timestamp} | {direction} | {content_type} | {size} bytes"
        )
        
        if direction == 'sent':
            self.stats['messages_sent'] += 1
        else:
            self.stats['messages_received'] += 1
            if content_type == 'audio':
                self.stats['total_audio_bytes'] += size
    
    def get_stats(self):
        """获取统计信息"""
        duration = datetime.now() - self.stats['start_time']
        return {
            **self.stats,
            'duration_seconds': duration.total_seconds(),
            'avg_throughput': self.stats['total_audio_bytes'] / 
                             duration.total_seconds() if duration.total_seconds() > 0 else 0
        }

# 使用监控
monitor = LiveAPIMonitor()

async def monitored_send(session, message):
    await session.send_client_content(
        turns={"role": "user", "parts": [{"text": message}]},
        turn_complete=True
    )
    monitor.log_message('sent', 'text', len(message.encode('utf-8')))

这些实时API与流式响应处理技巧为开发者提供了构建高性能、低延迟AI应用的基础。通过合理运用这些技术，可以创建出更加自然、响应迅速的交互体验，满足现代用户对实时AI应用的高期望。

总结

通过本指南的学习，您已经全面掌握了Gemini API的核心功能和使用方法。从API概述与核心功能、密钥获取与认证配置，到基础文本生成与多模态输入实践，再到实时API与流式响应处理技巧，您已经具备了使用Gemini API构建智能应用的能力。Gemini API的强大功能和灵活性为开发者提供了丰富的可能性，无论是简单的文本生成还是复杂的多模态应用，都能找到合适的解决方案。希望本指南能为您的AI开发之旅提供有力的支持，助您构建出更加智能和创新的应用程序。

【免费下载链接】cookbook A collection of guides and examples for the Gemini API. 项目地址: https://gitcode.com/GitHub_Trending/coo/cookbook

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考