Gemini-API

一个针对 Google Gemini 网页应用（前身为 Bard）的逆向工程异步 Python 封装库。

特性

• 持久化 Cookie - 自动在后台刷新 Cookie。专为常开服务优化。
• 图像生成 - 原生支持通过自然语言生成和编辑图像。
• 视频与音频生成 - 原生支持生成视频以及音频/音乐内容。
• 深度研究 - 提供完整的深度研究工作流程，包括计划创建、状态轮询和结果获取。
• 系统提示词 - 支持使用 Gemini Gems 自定义模型的系统提示词。
• 扩展支持 - 支持使用 Gemini 扩展，如 YouTube 和 Gmail，生成内容。
• 分类输出 - 对响应中的文本、思考、图片、视频和音频进行分类。
• 流式模式 - 支持流式生成，可在生成过程中逐步返回部分输出。
• CLI 工具 - 独立的命令行界面，方便快速交互。
• 官方风格 - 提供简洁优雅的接口，灵感源自 Google Generative AI 的官方 API。
• 异步支持 - 使用 asyncio 运行生成任务，并高效地返回结果。

目录

• 特性
• 目录
• 安装
• 认证
• 使用方法
  • 初始化
  • 生成内容
  • 使用文件生成内容
  • 多轮对话
  • 继续之前的对话
  • 读取对话历史
  • 从 Gemini 历史中删除之前的对话
  • 临时模式
  • 流式模式
  • 选择语言模型
  • 列出可用模型
  • 使用 Gemini Gems 应用系统提示词
  • 管理自定义 Gems
    • 创建自定义 Gem
    • 更新现有 Gem
    • 删除自定义 Gem
  • 获取模型的思考过程
  • 获取响应中的图片
  • 生成和编辑图像
  • 获取视频和音频
  • 使用 Gemini 扩展生成内容
  • 检查并切换其他回复候选
  • 深度研究
  • 日志配置
• CLI 工具
  • Cookie 设置
  • CLI 命令
  • 深度研究工作流程
• 参考文献
• 星标用户

安装

[!注意]

本包需要 Python 3.10 或更高版本。

使用 pip 安装或更新该包。

pip install -U gemini_webapi

可选地，该包还提供通过可选依赖 browser-cookie3 从本地浏览器自动导入 Cookie 的功能。若要启用此功能，请安装 gemini_webapi[browser]。支持的平台和浏览器请参阅 此处。

pip install -U gemini_webapi[browser]

身份验证

[!TIP]

如果已安装 browser-cookie3，您可以跳过此步骤，直接前往使用方法部分。只需确保您已在浏览器中登录 https://gemini.google.com。

• 访问 https://gemini.google.com 并使用您的 Google 帐户登录
• 按 F12 打开开发者工具，切换到 Network 选项卡，并刷新页面
• 点击任意请求，复制 __Secure-1PSID 和 __Secure-1PSIDTS 的 Cookie 值

[!NOTE]

如果您的应用部署在容器化环境中（例如 Docker），建议将 Cookie 存储在卷中以持久化保存，从而避免每次容器重建时都需要重新进行身份验证。您可以设置 GEMINI_COOKIE_PATH 环境变量来指定自动刷新的 Cookie 存储路径。请确保该路径对应用程序可写。

以下是一个示例 docker-compose.yml 文件的部分内容：

services:
    main:
        environment:
            GEMINI_COOKIE_PATH: /tmp/gemini_webapi
        volumes:
            - ./gemini_cookies:/tmp/gemini_webapi

[!NOTE]

API 的自动刷新 Cookie 功能无需依赖 browser-cookie3，并且默认已启用。它允许您持续运行 API 服务，而无需担心 Cookie 过期的问题。

使用此功能时，可能需要您再次在浏览器中登录 Google 帐户。这是预期行为，不会影响 API 的正常功能。

为了避免这种情况，建议从一个独立的浏览器会话中获取 Cookie，并在获取完成后尽快关闭该会话，以达到最佳效果（例如，在浏览器的隐私模式下进行全新登录）。更多详情请参阅 此处。

使用方法

初始化

导入所需的包，并使用上一步获取的 Cookie 初始化客户端。初始化成功后，只要进程保持运行，API 就会在后台自动刷新 __Secure-1PSIDTS。

import asyncio
from gemini_webapi import GeminiClient

# 将“COOKIE VALUE HERE”替换为您的实际 Cookie 值。
# 如果您的帐户没有 Secure_1PSIDTS，请将其留空。
Secure_1PSID = "COOKIE VALUE HERE"
Secure_1PSIDTS = "COOKIE VALUE HERE"

async def main():
    # 如果已安装 browser-cookie3，可以直接使用 `client = GeminiClient()`
    client = GeminiClient(Secure_1PSID, Secure_1PSIDTS, proxy=None)
    await client.init(timeout=30, auto_close=False, close_delay=300, auto_refresh=True)

asyncio.run(main())

[!TIP]

auto_close 和 close_delay 是可选参数，用于在一定时间无活动后自动关闭客户端。此功能默认关闭。对于聊天机器人等始终在线的服务，建议将 auto_close 设置为 True，并合理设置 close_delay 值，以更好地管理资源。

生成内容

通过调用 GeminiClient.generate_content 发送单轮问题，该方法会返回一个 gemini_webapi.ModelOutput 对象，其中包含生成的文本、图片、思考内容以及对话元数据。

async def main():
    response = await client.generate_content("Hello World!")
    print(response.text)

asyncio.run(main())

[!TIP]

如果您只想查看响应文本，可以直接使用 print(response) 来获得相同输出。

使用文件生成内容

Gemini 支持文件输入，包括图片和文档。您可以选择将文件路径列表（以 str 或 pathlib.Path 格式）与文本提示一起传递给 GeminiClient.generate_content。

async def main():
    response = await client.generate_content(
            "请介绍这两份文件的内容。它们之间有什么联系吗？",
            files=["assets/sample.pdf", Path("assets/banner.png")],
        )
    print(response.text)

asyncio.run(main())

多轮对话

如果您希望保持对话的连续性，可以使用 GeminiClient.start_chat 创建一个 gemini_webapi.ChatSession 对象，并通过该对象发送消息。对话历史将自动处理并在每一轮结束后更新。

async def main():
    chat = client.start_chat()
    response1 = await chat.send_message(
        "请介绍这两份文件的内容。它们之间有什么联系吗？",
        files=["assets/sample.pdf", Path("assets/banner.png")],
    )
    print(response1.text)
    response2 = await chat.send_message(
        "请使用图像生成工具，用另一种字体和设计修改横幅。"
    )
    print(response2.text, response2.images, sep="\n\n----------------------------------\n\n")

asyncio.run(main())

[!TIP]

与 GeminiClient.generate_content 类似，ChatSession.send_message 也接受 image 作为可选参数。

继续之前的对话

要手动检索之前的对话，可以在创建新的 ChatSession 时，将先前 ChatSession 的元数据传递给 GeminiClient.start_chat。或者，您也可以将之前的元数据持久化到文件或数据库中，以便在当前 Python 进程退出后仍能访问这些信息。

async def main():
    # 开始一个新的聊天会话
    chat = client.start_chat()
    await chat.send_message("今天天气真好")

    # 保存聊天的元数据
    previous_session = chat.metadata

    # 加载之前的对话
    previous_chat = client.start_chat(metadata=previous_session)
    await previous_chat.send_message("我之前发了什么消息？")
    print(await previous_chat.send_message("我之前发了什么消息？"))

asyncio.run(main())

阅读对话历史

您可以通过调用 GeminiClient.read_chat 并传入聊天 ID 来阅读特定聊天的对话历史。该方法会返回一个 ChatHistory 对象，其中包含按时间顺序从最新到最旧排列的 ChatTurn 对象列表。

async def main():
    chat = client.start_chat()
    await chat.send_message("法国的首都是哪里？")

    # 阅读聊天历史
    history = await client.read_chat(chat.cid)
    if history:
        for turn in history.turns:
            print(f"[{turn.role.upper()}] {turn.text}")
            print("\n----------------------------------\n")

asyncio.run(main())

要列出所有最近的聊天，可以使用 GeminiClient.list_chats：

async def main():
    chats = client.list_chats()
    if chats:
        for chat_info in chats:
            print(f"{chat_info.cid}: {chat_info.title}")

asyncio.run(main())

从 Gemini 历史中删除之前的对话

您可以通过调用 GeminiClient.delete_chat 并传入聊天 ID，从服务器端删除特定的聊天记录。

async def main():
    # 开始一个新的聊天会话
    chat = client.start_chat()
    await chat.send_message("这是一个临时对话。")

    # 删除该聊天
    await client.delete_chat(chat.cid)
    print(f"聊天已删除：{chat.cid}")

asyncio.run(main())```

### 临时模式

您可以通过将 `temporary=True` 传递给 `GeminiClient.generate_content` 或 `ChatSession.send_message` 来开始一个临时聊天。临时聊天不会保存在 Gemini 的历史记录中。

```python
async def main():
    response = await client.generate_content("Hello World!", temporary=True)
    print(response.text, "\n\n----------------------------------\n\n")

    chat = client.start_chat()
    await chat.send_message("Fine weather today", temporary=False)
    response2 = await chat.send_message("What's my last message?", temporary=True)
    print(response2.text)

asyncio.run(main())

流式模式

对于较长的回复，您可以使用流式模式，在生成时逐步接收部分输出。这能提供更流畅的用户体验，尤其适用于聊天机器人等实时应用。

generate_content_stream 方法会生成 ModelOutput 对象，其中的 text_delta 属性仅包含自上次生成以来接收到的新字符，从而便于显示增量更新。

async def main():
    async for chunk in client.generate_content_stream(
        "What's the difference between 'await' and 'async for'?"
    ):
        print(chunk.text_delta, end="", flush=True)

    print()

asyncio.run(main())

[!TIP]

流式模式接受与 generate_content 相同的参数。您还可以在多轮对话中使用 ChatSession.send_message_stream 进行流式交互。

选择语言模型

您可以通过将 model 参数传递给 GeminiClient.generate_content 或 GeminiClient.start_chat 来指定要使用的语言模型。默认值为 unspecified。

可用模型会在初始化时根据您的账户层级动态发现。Model 枚举提供了便捷的快捷方式。

from gemini_webapi.constants import Model

async def main():
    response1 = await client.generate_content(
        "What's your language model version? Reply with the version number only.",
        model=Model.BASIC_FLASH,
    )
    print(f"Model version ({Model.BASIC_FLASH.model_name}): {response1.text}")

    chat = client.start_chat(model="gemini-3-pro")
    response2 = await chat.send_message("What's your language model version? Reply with the version number only.")
    print(f"Model version (gemini-3-pro): {response2.text}")

asyncio.run(main())

您也可以直接传递自定义的模型头信息字符串，以访问未列出的模型。

# 必须包含 "model_name" 和 "model_header" 键
custom_model = {
    "model_name": "xxx",
    "model_header": {
        "x-goog-ext-525001261-jspb": "[1,null,null,null,'e6fa609c3fa255c0',null,null,null,[4]]"
    },
}

response = await client.generate_content(
    "What's your model version?",
    model=custom_model
)

列出可用模型

客户端会在初始化时动态发现您账户可用的模型。使用 GeminiClient.list_models 可查看所有可用模型及其详细信息。

async def main():
    await client.init()  # 确保客户端已初始化
    models = client.list_models()
    if models:
        for model in models:
            print(f"{model.display_name}: {model.model_name}")

asyncio.run(main())

使用 Gemini Gems 应用系统提示

系统提示可以通过 Gemini Gems 应用于对话中。要使用某个宝石，您可以将 gem 参数传递给 GeminiClient.generate_content 或 GeminiClient.start_chat。gem 可以是宝石 ID 字符串或 gemini_webapi.Gem 对象。单次对话中只能应用一个宝石。

[!TIP]

存在一些系统预设的宝石，默认情况下不会对用户显示（因此可能无法正常工作）。使用 client.fetch_gems(include_hidden=True) 可将其包含在获取结果中。

async def main():
    # 获取当前账户的所有宝石，包括预设和用户创建的
    await client.fetch_gems(include_hidden=False)

    # 获取后，宝石会被缓存在 `GeminiClient.gems` 中
    gems = client.gems

    # 获取您想要使用的宝石
    system_gems = gems.filter(predefined=True)
    coding_partner = system_gems.get(id="coding-partner")

    response1 = await client.generate_content(
        "What's your system prompt?",
        gem=coding_partner,
    )
    print(response1.text)

    # 另一个使用用户自定义宝石的例子
    # 宝石 ID 是一致的字符串，可将其存储起来，避免每次都重新获取宝石
    your_gem = gems.get(name="Your Gem Name")
    your_gem_id = your_gem.id
    chat = client.start_chat(gem=your_gem_id)
    response2 = await chat.send_message("What's your system prompt?")
    print(response2)

管理自定义宝石

您可以通过 API 以编程方式创建、更新和删除自定义宝石。请注意，预设的系统宝石无法修改或删除。

创建自定义宝石

使用名称、系统提示（指令）以及可选的描述来创建一个新的自定义宝石：

async def main():
    # 创建一个新的自定义宝石
    new_gem = await client.create_gem(
        name="Python Tutor",
        prompt="You are a helpful Python programming tutor.",
        description="A specialized gem for Python programming"
    )

    print(f"Custom gem created: {new_gem}")

    # 在对话中使用新创建的宝石
    response = await client.generate_content(
        "Explain how list comprehensions work in Python",
        gem=new_gem
    )
    print(response.text)

asyncio.run(main())

更新现有宝石

[!NOTE]

更新宝石时，必须提供所有参数（名称、提示、描述），即使您只想更改其中一个。

async def main():
    # 获取一个自定义宝石（假设您有一个名为“Python Tutor”的宝石）
    await client.fetch_gems()
    python_tutor = client.gems.get(name="Python Tutor")

    # 用新的指令更新宝石
    updated_gem = await client.update_gem(
        gem=python_tutor,  // 也可以传入宝石 ID 字符串
        name="Advanced Python Tutor",
        prompt="You are an expert Python programming tutor.",
        description="An advanced Python programming assistant"
    )

    print(f"Custom gem updated: {updated_gem}")

asyncio.run(main())

删除自定义宝石

async def main():
    # 获取要删除的宝石
    await client.fetch_gems()
    gem_to_delete = client.gems.get(name="Advanced Python Tutor")

    # 删除宝石
    await client.delete_gem(gem_to_delete)  // 也可以传入宝石 ID 字符串
    print(f"Custom gem deleted: {gem_to_delete.name}")

asyncio.run(main())

获取模型的思考过程

当使用具备思考能力的模型时，模型的思考过程会被填充到 ModelOutput.thoughts 中。

async def main():
    response = await client.generate_content(
            "1加1等于多少？", model="gemini-3-pro"
        )
    print(response.thoughts)
    print(response.text)

asyncio.run(main())

获取响应中的图片

API 输出中的图片以 gemini_webapi.Image 对象列表的形式存储。你可以通过调用 Image.title、Image.url 和 Image.alt 分别获取图片的标题、URL 和描述。

async def main():
    response = await client.generate_content("给我一些猫的图片")
    for image in response.images:
        print(image, "\n\n----------------------------------\n\n")

asyncio.run(main())

生成和编辑图片

你可以使用自然语言请求 Gemini 利用 Google 最新的图像模型 Nano Banana 来生成和编辑图片。

[!IMPORTANT]

Google 对 Gemini 的图像生成功能有一些限制，因此其可用性可能因地区或账户而异。以下是摘自官方文档（截至 2025 年 9 月 10 日）的摘要：

此功能在任何特定 Gemini 应用程序中的可用性也仅限于该应用程序支持的语言和国家。

目前，此功能对 18 岁以下的用户不可用。

要使用此功能，你必须登录 Gemini 应用程序。

你可以通过调用 Image.save() 将 Gemini 返回的图片保存到本地。可选地，你可以通过向该函数传递 path 和 filename 参数来指定文件路径和文件名。这适用于 WebImage 和 GeneratedImage。

async def main():
    response = await client.generate_content("生成一些猫的图片")
    for i, image in enumerate(response.images):
        await image.save(path="temp/", filename=f"cat_{i}.png", verbose=True)
        print(image, "\n\n----------------------------------\n\n")

asyncio.run(main())

[!NOTE]

默认情况下，当被要求发送图片时（如上例所示），Gemini 会发送从网上抓取的图片，而不是使用 AI 模型生成图片，除非你在提示中明确要求它“生成”图片。在此软件包中，网络图片和生成图片分别被视为 WebImage 和 GeneratedImage，并在输出中自动分类。

获取视频和音频

Gemini 可以生成视频以及音频/音乐内容。这些内容分别以 GeneratedVideo 和 GeneratedMedia 对象的形式返回在 ModelOutput.videos 和 ModelOutput.media 中。你可以像处理图片一样将它们保存到磁盘。

[!NOTE]

你可能需要有效的订阅才能访问 Gemini 的视频和音频生成功能。

async def main():
    response = await client.generate_content("生成一段猫咪玩耍的短视频")

    # 保存生成的视频
    for video in response.videos:
        result = await video.save(path="temp/", verbose=True)
        print(f"视频已保存：{result}")

    # 保存生成的媒体（音频/音乐）
    for media in response.media:
        result = await media.save(path="temp/", verbose=True)
        print(f"媒体已保存：{result}")

asyncio.run(main())

[!NOTE]

GeneratedMedia.save() 接受一个 download_type 参数："audio"、"video" 或 "both"（默认）。生成的视频/音频可能需要一些时间来渲染——保存方法会自动轮询，直到内容准备就绪。

使用 Gemini 扩展生成内容

[!IMPORTANT]

要在 API 中访问 Gemini 扩展，你必须先在Gemini 网站上启用它们。与图像生成一样，Google 对 Gemini 扩展的可用性也有一定的限制。以下是摘自官方文档（截至 2025 年 3 月 19 日）的摘要：

要将应用连接到 Gemini，你必须开启 Gemini 应用活动功能。

要使用此功能，你必须登录 Gemini 应用程序。

重要提示：如果你未满 18 岁，Google Workspace 和 Maps 应用目前仅支持使用英语提示与 Gemini 交互。

在为你的账户启用扩展后，你可以在提示中以自然语言形式或以“@”加上扩展关键词的方式访问它们。

async def main():
    response1 = await client.generate_content("@Gmail 我的邮箱里最新的一条消息是什么？")
    print(response1, "\n\n----------------------------------\n\n")

    response2 = await client.generate_content("@Youtube 泰勒·斯威夫特最近在做什么？")
    print(response2, "\n\n----------------------------------\n\n")

asyncio.run(main())

[!NOTE]

关于区域可用性，你的 Google 账户的首选语言只需设置为上述三种支持语言之一即可。你可以在此处更改语言设置：这里。

检查并切换其他回复候选

Gemini 的响应有时会包含多个具有不同生成内容的回复候选。你可以查看所有候选，并选择其中一个继续对话。默认情况下，会选择第一个候选。

async def main():
    # 开始一次对话并列出所有回复候选
    chat = client.start_chat()
    response = await chat.send_message("给我推荐一本科幻小说。")
    for candidate in response.candidates:
        print(candidate, "\n\n----------------------------------\n\n")

    if len(response.candidates) > 1:
        # 通过手动选择候选来控制正在进行的对话流程
        new_candidate = chat.choose_candidate(index=1)  # 在这里选择第二个候选
        followup_response = await chat.send_message("请多告诉我一些关于它的信息。")  # 将基于所选候选生成内容
        print(new_candidate, followup_response, sep="\n\n----------------------------------\n\n")
    else:
        print("只有一个候选可用。")

asyncio.run(main())

深度研究

Gemini 的深度研究功能是一个自主的研究代理，它会浏览网页、分析资料来源，并生成一份全面的报告。您可以通过 API 以编程方式访问此功能。

[!NOTE]

您可能需要有效的订阅才能使用 Gemini 的深度研究功能。

快速单次调用方法：

async def main():
    result = await client.deep_research(
        "比较前三大云服务提供商及其 AI 产品",
        poll_interval=10.0,
        timeout=600.0,
    )
    print(f"完成：{result.done}")
    print(result.text)

asyncio.run(main())

分步工作流，以便获得更精细的控制：

async def main():
    # 第一步：创建研究计划
    plan = await client.create_deep_research_plan(
        "量子计算领域的最新进展有哪些？"
    )
    print(f"标题：{plan.title}")
    print(f"预计完成时间：{plan.eta_text}")
    for step in plan.steps:
        print(f"  - {step}")

    # 第二步：开始研究
    await client.start_deep_research(plan)

    # 第三步：轮询检查是否完成
    result = await client.wait_for_deep_research(
        plan,
        poll_interval=10.0,
        timeout=600.0,
        on_status=lambda s: print(f"状态：{s.state}"),
    )

    print(result.text)

asyncio.run(main())

日志配置

本包使用 loguru 进行日志记录，并提供 set_log_level 函数来控制日志级别。您可以将日志级别设置为以下值之一：DEBUG、INFO、WARNING、ERROR 和 CRITICAL。默认值为 INFO。

from gemini_webapi import set_log_level

set_log_level("DEBUG")

[!NOTE]

首次调用 set_log_level 将会 全局地 移除所有现有的 loguru 处理器。为了避免此问题并获得对日志行为更高级的控制，您可能希望直接使用 loguru 来配置日志记录。

命令行工具

为了方便在终端中与 Gemini 交互，我们提供了一个独立的命令行工具 (cli.py)。它支持单轮提问、多轮对话、深度研究、图片下载以及账户诊断等功能。

Cookie 设置

请从 gemini.google.com 导出您的 Cookie，并将其保存为 JSON 文件。CLI 支持多种格式：

{ "__Secure-1PSID": "value...", "__Secure-1PSIDTS": "value..." }

您也可以使用浏览器 Cookie 扩展程序导出的文件（支持对象数组格式）。

[!NOTE]

CLI 在每次运行后会自动将更新后的 Cookie 持久化回 JSON 文件。如果您不想启用此行为，可以使用 --no-persist 参数。

CLI 命令

全局选项（置于子命令之前）：

--cookies-json PATH    Cookie JSON 文件路径（必填）
--proxy URL            代理 URL（或使用 HTTPS_PROXY 环境变量）
--model NAME           模型名称（参见 'models' 命令）
--verbose              启用调试日志
--no-persist           不在运行后更新 Cookie 文件
--request-timeout SEC  HTTP 请求超时时间（默认：300 秒）

可用命令：

# 提问（默认为流式输出）
python cli.py --cookies-json cookies.json ask "什么是量子计算？"

# 带图片输入的提问
python cli.py --cookies-json cookies.json ask --image photo.jpg "描述这张照片"

# 非流式输出模式
python cli.py --cookies-json cookies.json ask --no-stream "你好"

# 继续对话（使用上一次输出的聊天 ID）
python cli.py --cookies-json cookies.json reply c_abc123 "再告诉我一些吧"

# 列出聊天历史
python cli.py --cookies-json cookies.json list

# 查看特定聊天记录
python cli.py --cookies-json cookies.json read c_abc123

# 列出可用模型
python cli.py --cookies-json cookies.json models

# 下载生成的图片
python cli.py --cookies-json cookies.json download "https://..." -o output.png

# 账户诊断（检查功能可用性）
python cli.py --cookies-json cookies.json inspect

深度研究工作流

CLI 支持 Gemini 的深度研究功能——一个能够自主浏览网页、分析资料来源并生成综合报告的研究代理。

# 1. 提交研究任务
python cli.py --cookies-json cookies.json research send --prompt "2025 年 AI 芯片竞争"

# 2. 检查进度（使用步骤 1 中的聊天 ID）
python cli.py --cookies-json cookies.json research check c_abc123

# 3. 获取完整结果
python cli.py --cookies-json cookies.json research get c_abc123

# 4. 将结果保存到文件
python cli.py --cookies-json cookies.json research get c_abc123 --output report.md

参考文献

Google AI Studio

acheong08/Bard

星标用户

Gemini-API 快速上手指南

Gemini-API 是一个逆向工程的异步 Python 封装库，用于访问 Google Gemini (原 Bard) 网页版功能。它支持持久化 Cookie、多模态生成（文本、图片、音视频）、深度研究以及流式输出等高级特性。

环境准备

• 操作系统：Windows, macOS, Linux
• Python 版本：3.10 或更高
• 前置依赖：
  • 基础使用：无额外依赖
  • 自动获取浏览器 Cookie（可选）：需安装 browser-cookie3 扩展包
• 网络要求：需能访问 https://gemini.google.com

安装步骤

使用 pip 安装基础版本：

pip install -U gemini_webapi

若希望自动从本地浏览器读取 Cookie（需确保浏览器已登录 Gemini），可安装带浏览器支持的版本：

pip install -U gemini_webapi[browser]

提示：国内用户如遇下载缓慢，可指定清华或阿里云镜像源：

pip install -U gemini_webapi -i https://pypi.tuna.tsinghua.edu.cn/simple

基本使用

1. 获取认证 Cookie

若未安装 browser-cookie3，需手动获取 Cookie：

1. 在浏览器中登录 https://gemini.google.com
2. 按 F12 打开开发者工具，切换至 Network 标签页
3. 刷新页面，点击任意请求
4. 在请求头中找到并复制以下两个 Cookie 值：
   • __Secure-1PSID
   • __Secure-1PSIDTS（若不存在可留空）

2. 初始化客户端并生成内容

以下是最简单的单轮对话示例：

import asyncio
from gemini_webapi import GeminiClient

# 替换为你的实际 Cookie 值
Secure_1PSID = "YOUR_1PSID_COOKIE"
Secure_1PSIDTS = "YOUR_1PSIDTS_COOKIE"

async def main():
    # 初始化客户端
    client = GeminiClient(Secure_1PSID, Secure_1PSIDTS)
    await client.init(timeout=30, auto_refresh=True)

    # 发送消息并打印回复
    response = await client.generate_content("你好，请介绍一下你自己！")
    print(response.text)

if __name__ == "__main__":
    asyncio.run(main())

说明：

• auto_refresh=True 启用后台自动刷新 Cookie，适合长期运行的服务。
• 若已安装 gemini_webapi[browser] 且浏览器已登录，可直接使用 client = GeminiClient() 省略 Cookie 参数。