Google AI Studio API - 免费 Gemini API 接口服务

import google.generativeai as genai

# 配置 API 密钥
genai.configure(api_key="YOUR_API_KEY")

# 创建模型实例（使用最新的稳定版模型）
model = genai.GenerativeModel('gemini-2.5-flash')

# 发送请求
response = model.generate_content("你好，介绍一下你自己")
print(response.text)

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key=YOUR_API_KEY \
  -H 'Content-Type: application/json' \
  -d '{
    "contents": [{
      "parts":[{"text": "你好，介绍一下你自己"}]
    }]
  }'

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")
# 推荐使用 Gemini 2.5 Flash（稳定版）或 Gemini 3 Flash（最新预览版）
model = genai.GenerativeModel('gemini-2.5-flash')

# 简单对话
response = model.generate_content("解释一下什么是机器学习")
print(response.text)

# 带参数的请求
response = model.generate_content(
    "写一首关于秋天的诗",
    generation_config={
        "temperature": 0.9,
        "top_p": 0.95,
        "max_output_tokens": 1024,
    }
)
print(response.text)

curl https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent?key=YOUR_API_KEY \
  -H 'Content-Type: application/json' \
  -d '{
    "contents": [{
      "parts":[{"text": "解释一下什么是机器学习"}]
    }],
    "generationConfig": {
      "temperature": 0.7,
      "maxOutputTokens": 1024
    }
  }'

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")
model = genai.GenerativeModel('gemini-2.5-flash')

# 创建对话会话
chat = model.start_chat(history=[])

# 第一轮对话
response = chat.send_message("你好，我想学习 Python")
print(response.text)

# 第二轮对话（模型会记住上下文）
response = chat.send_message("应该从哪里开始？")
print(response.text)

# 查看对话历史
print(chat.history)

import google.generativeai as genai
from PIL import Image

genai.configure(api_key="YOUR_API_KEY")
model = genai.GenerativeModel('gemini-2.5-flash')

# 加载图片
image = Image.open('example.jpg')

# 发送图片和问题
response = model.generate_content([
    "这张图片里有什么？请详细描述。",
    image
])
print(response.text)

import google.generativeai as genai
from PIL import Image
import requests
from io import BytesIO

genai.configure(api_key="YOUR_API_KEY")
model = genai.GenerativeModel('gemini-2.5-flash')

# 从 URL 加载图片
response = requests.get('https://example.com/image.jpg')
image = Image.open(BytesIO(response.content))

# 分析图片
response = model.generate_content(["分析这张图片", image])
print(response.text)

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")
model = genai.GenerativeModel('gemini-2.5-flash')

# 流式输出
response = model.generate_content(
    "写一篇关于人工智能的文章",
    stream=True
)

for chunk in response:
    print(chunk.text, end='')

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

# 定义函数
def get_weather(city: str):
    """获取指定城市的天气"""
    # 这里应该调用真实的天气 API
    return f"{city}的天气：晴天，25°C"

# 定义函数描述
tools = [{
    "function_declarations": [{
        "name": "get_weather",
        "description": "获取指定城市的天气信息",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "城市名称"
                }
            },
            "required": ["city"]
        }
    }]
}]

model = genai.GenerativeModel(
    'gemini-2.5-flash',
    tools=tools
)

# 发送请求
chat = model.start_chat()
response = chat.send_message("上海今天天气怎么样？")

# 检查是否需要调用函数
if response.candidates[0].content.parts[0].function_call:
    function_call = response.candidates[0].content.parts[0].function_call
    
    # 调用函数
    if function_call.name == "get_weather":
        result = get_weather(function_call.args["city"])
        
        # 将结果返回给模型
        response = chat.send_message({
            "function_response": {
                "name": "get_weather",
                "response": {"result": result}
            }
        })
        print(response.text)

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

# 启用 Google Search Grounding
model = genai.GenerativeModel('gemini-2.5-flash')

# ⚠️ 注意：Grounding 功能可能会单独计费，请查看最新定价
response = model.generate_content(
    "最新的 AI 技术发展趋势是什么？",
    tools=[{"google_search_retrieval": {}}]
)

print(response.text)

# 查看引用来源
for candidate in response.candidates:
    if hasattr(candidate, 'grounding_metadata'):
        print("\n引用来源：")
        for attribution in candidate.grounding_metadata.grounding_attributions:
            print(f"- {attribution.source_id.grounding_passage.url}")

pip install google-generativeai

npm install @google/generative-ai

go get github.com/google/generative-ai-go

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_GOOGLE_API_KEY",
    base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
)

response = client.chat.completions.create(
    model="gemini-2.5-flash",
    messages=[
        {"role": "user", "content": "你好"}
    ]
)

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

# 检查 API 密钥
import google.generativeai as genai
genai.configure(api_key="YOUR_API_KEY")

# 列出可用模型以验证
for model in genai.list_models():
    print(model.name)

import time
from google.api_core.exceptions import ResourceExhausted

def call_with_backoff(prompt, max_retries=3):
    for i in range(max_retries):
        try:
            return model.generate_content(prompt)
        except ResourceExhausted:
            if i < max_retries - 1:
                wait_time = 2 ** i  # 指数退避
                print(f"速率限制，等待 {wait_time} 秒...")
                time.sleep(wait_time)
            else:
                raise

from google.api_core import timeout

# 设置超时
timeout_config = timeout.ExponentialTimeout(initial=30, maximum=120)
response = model.generate_content(prompt, timeout=timeout_config)

from functools import lru_cache

@lru_cache(maxsize=100)
def cached_api_call(prompt):
    return model.generate_content(prompt).text

import asyncio
from google.generativeai import GenerativeModel

async def batch_generate(prompts):
    model = GenerativeModel('gemini-2.5-flash')
    tasks = [model.generate_content_async(p) for p in prompts]
    return await asyncio.gather(*tasks)

# 使用
prompts = ["问题1", "问题2", "问题3"]
responses = asyncio.run(batch_generate(prompts))

def process_large_text(text, chunk_size=10000):
    chunks = [text[i:i+chunk_size] for i in range(0, len(text), chunk_size)]
    results = []
    
    for chunk in chunks:
        response = model.generate_content(f"总结：{chunk}")
        results.append(response.text)
    
    return " ".join(results)