Gemini 2.0 Flash Experimental API完全指南：图像生成/思考链应用/国内稳定访问【2025最新】

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "生成一张高品质的中国传统山水画"
        }
      ]
    }
  ],
  "tools": [
    {
      "image_generation": {
        "prompt": "生成一张高品质的中国传统山水画",
        "resolution": "1024x1024"
      }
    }
  ],
  "generation_config": {
    "temperature": 0.4,
    "top_p": 0.95,
    "top_k": 40,
    "max_output_tokens": 2048
  },
  "system_instruction": {
    "parts": [
      {
        "text": "你是一个专业的图像生成助手，请生成高质量和符合要求的图片。"
      }
    ]
  }
}

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "解决这个数学问题：一个水池有两个水管，一个注水管每小时能注满1/4池水，一个排水管每小时能排空1/6池水。如果水池初始是空的，同时打开两个水管，需要多少小时才能注满水池？"
        }
      ]
    }
  ],
  "model": "gemini-2.0-flash-experimental",
  "generation_config": {
    "temperature": 0.2,
    "top_p": 0.95,
    "top_k": 40,
    "max_output_tokens": 4096
  },
  "thinking": true,
  "thinking_prompts": {
    "parts": [
      {
        "text": "分析这个问题时，请展示你的详细计算过程和推理步骤。"
      }
    ]
  }
}

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "生成一张高品质的中国传统山水画"
        }
      ]
    }
  ],
  "tools": [
    {
      "image_generation": {
        "prompt": "生成一张高品质的中国传统山水画",
        "resolution": "1024x1024"
      }
    }
  ],
  "generation_config": {
    "temperature": 0.4,
    "top_p": 0.95,
    "top_k": 40,
    "max_output_tokens": 2048
  },
  "system_instruction": {
    "parts": [
      {
        "text": "你是一个专业的图像生成助手，请生成高质量和符合要求的图片。"
      }
    ]
  }
}

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "生成一张高品质的中国传统山水画"
        }
      ]
    }
  ],
  "tools": [
    {
      "image_generation": {
        "prompt": "生成一张高品质的中国传统山水画",
        "resolution": "1024x1024"
      }
    }
  ],
  "generation_config": {
    "temperature": 0.4,
    "top_p": 0.95,
    "top_k": 40,
    "max_output_tokens": 2048
  },
  "system_instruction": {
    "parts": [
      {
        "text": "你是一个专业的图像生成助手，请生成高质量和符合要求的图片。"
      }
    ]
  }
}

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "生成一张高品质的中国传统山水画"
        }
      ]
    }
  ],
  "tools": [
    {
      "image_generation": {
        "prompt": "生成一张高品质的中国传统山水画",
        "resolution": "1024x1024"
      }
    }
  ],
  "generation_config": {
    "temperature": 0.4,
    "top_p": 0.95,
    "top_k": 40,
    "max_output_tokens": 2048
  },
  "system_instruction": {
    "parts": [
      {
        "text": "你是一个专业的图像生成助手，请生成高质量和符合要求的图片。"
      }
    ]
  }
}

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "解决这个数学问题：一个水池有两个水管，一个注水管每小时能注满1/4池水，一个排水管每小时能排空1/6池水。如果水池初始是空的，同时打开两个水管，需要多少小时才能注满水池？"
        }
      ]
    }
  ],
  "model": "gemini-2.0-flash-experimental",
  "generation_config": {
    "temperature": 0.2,
    "top_p": 0.95,
    "top_k": 40,
    "max_output_tokens": 4096
  },
  "thinking": true,
  "thinking_prompts": {
    "parts": [
      {
        "text": "分析这个问题时，请展示你的详细计算过程和推理步骤。"
      }
    ]
  }
}

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "生成一篇关于中国传统山水画的文章"
        }
      ]
    }
  ],
  "model": "gemini-2.0-flash-experimental",
  "generation_config": {
    "temperature": 0.7,
    "top_p": 0.95,
    "top_k": 40,
    "max_output_tokens": 1024
  },
  "system_instruction": {
    "parts": [
      {
        "text": "你是一个专业的文本生成助手，请生成一篇关于中国传统山水画的文章。"
      }
    ]
  }
}

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "描述这张图片的内容"
        }
      ]
    }
  ],
  "model": "gemini-2.0-flash-experimental",
  "generation_config": {
    "temperature": 0.5,
    "top_p": 0.95,
    "top_k": 40,
    "max_output_tokens": 512
  },
  "system_instruction": {
    "parts": [
      {
        "text": "你是一个专业的图像理解助手，请描述这张图片的内容。"
      }
    ]
  }
}

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "生成一个简单的Python函数，用于计算两个数的和"
        }
      ]
    }
  ],
  "model": "gemini-2.0-flash-experimental",
  "generation_config": {
    "temperature": 0.8,
    "top_p": 0.95,
    "top_k": 40,
    "max_output_tokens": 256
  },
  "system_instruction": {
    "parts": [
      {
        "text": "你是一个专业的代码生成助手，请生成一个简单的Python函数，用于计算两个数的和。"
      }
    ]
  }
}

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "解释这段代码的功能"
        }
      ]
    }
  ],
  "model": "gemini-2.0-flash-experimental",
  "generation_config": {
    "temperature": 0.5,
    "top_p": 0.95,
    "top_k": 40,
    "max_output_tokens": 512
  },
  "system_instruction": {
    "parts": [
      {
        "text": "你是一个专业的文本理解助手，请解释这段代码的功能。"
      }
    ]
  }
}

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "生成一张中国传统山水画的文本描述"
        }
      ]
    }
  ],
  "model": "gemini-2.0-flash-experimental",
  "generation_config": {
    "temperature": 0.7,
    "top_p": 0.95,
    "top_k": 40,
    "max_output_tokens": 1024
  },
  "system_instruction": {
    "parts": [
      {
        "text": "你是一个专业的文本生成助手，请生成一张中国传统山水画的文本描述。"
      }
    ]
  }
}

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
          "text": "解释这段代码的思考过程"
        }
      ]
    }
  ],
  "model": "gemini-2.0-flash-experimental",
  "generation_config": {
    "temperature": 0.5,
    "top_p": 0.95,
    "top_k": 40,
    "max_output_tokens": 512
  },
  "thinking": true,
  "thinking_prompts": {
    "parts": [
      {
        "text": "分析这段代码的思考过程，并解释每一步的逻辑。"
      }
    ]
  }
}

# 原Google API调用
import google.generativeai as genai
genai.configure(api_key="YOUR_GOOGLE_API_KEY")
model = genai.GenerativeModel("gemini-2.0-flash-experimental")

# 改为laozhang.ai中转API（仅需修改两行）
import google.generativeai as genai
genai.configure(api_key="YOUR_LAOZHANG_API_KEY", 
               api_base="https://api.laozhang.ai")
model = genai.GenerativeModel("gemini-2.0-flash-experimental")

import google.generativeai as genai
import os

# 官方API调用
# genai.configure(api_key=os.environ.get("GOOGLE_API_KEY"))

# laozhang.ai中转API调用
genai.configure(
    api_key="您的LAOZHANG_API_KEY", 
    api_base="https://api.laozhang.ai"
)

# 创建模型实例
model = genai.GenerativeModel("gemini-2.0-flash-experimental")

# 简单文本生成
response = model.generate_content("写一篇关于人工智能与艺术融合的短文")
print(response.text)

# 设置参数的高级文本生成
response = model.generate_content(
    "写一篇关于人工智能与艺术融合的短文",
    generation_config={
        "temperature": 0.7,
        "top_p": 0.95,
        "top_k": 40,
        "max_output_tokens": 800,
    }
)
print(response.text)

# 使用思考链功能
response = model.generate_content(
    "解释为什么π是一个无理数",
    generation_config={
        "temperature": 0.2,
        "thinking": True
    }
)
print("思考过程:", response.thinking)
print("\n最终回答:", response.text)

import google.generativeai as genai
import os
import base64
from PIL import Image
from io import BytesIO

# laozhang.ai中转API调用
genai.configure(
    api_key="您的LAOZHANG_API_KEY", 
    api_base="https://api.laozhang.ai"
)

# 创建模型实例
model = genai.GenerativeModel("gemini-2.0-flash-experimental")

# 图像生成函数
def generate_and_save_image(prompt, filename, resolution="1024x1024", temperature=0.4):
    response = model.generate_content(
        prompt,
        generation_config={
            "temperature": temperature,
            "output_type": "image",
            "resolution": resolution
        }
    )
    
    # 解析返回的图像数据
    image_data = base64.b64decode(response.parts[0].image.data)
    
    # 保存图像
    image = Image.open(BytesIO(image_data))
    image.save(filename)
    print(f"图像已保存为 {filename}")
    return image

# 示例：生成一幅传统中国山水画
generate_and_save_image(
    "创建一幅传统中国水墨山水画，有高山、流水、小船和远处的村庄，风格优雅细腻。",
    "chinese_landscape.png",
    resolution="1024x1024",
    temperature=0.3
)

# 示例：生成一幅未来科技城市插画
generate_and_save_image(
    "创建一幅未来主义科技城市的插画，有飞行汽车、悬浮建筑和全息广告，色彩鲜明，科技感强。",
    "future_city.png",
    resolution="1024x1024", 
    temperature=0.7
)

import google.generativeai as genai
import json

# laozhang.ai中转API调用
genai.configure(
    api_key="您的LAOZHANG_API_KEY", 
    api_base="https://api.laozhang.ai"
)

# 创建模型实例
model = genai.GenerativeModel("gemini-2.0-flash-experimental")

# 自定义思考提示
THINKING_PROMPTS = [
    "我需要解析这个问题的关键点和已知条件。",
    "确定解决这个问题需要用到的数学原理或概念。",
    "逐步规划解题思路和计算过程。",
    "检查我的解题过程是否正确，结果是否合理。",
    "总结最终答案并确保回答了原问题。"
]

def solve_math_problem(problem):
    response = model.generate_content(
        problem,
        generation_config={
            "temperature": 0.2,
            "thinking": True,
            "thinking_prompts": THINKING_PROMPTS,
            "max_output_tokens": 1000
        }
    )
    
    # 提取思考过程
    thinking_steps = response.thinking
    
    # 格式化输出
    print("📝 问题：\n", problem)
    print("\n🧠 思考过程：")
    for i, step in enumerate(thinking_steps, 1):
        print(f"\n步骤 {i}：\n{step}")
    
    print("\n✅ 最终答案：\n", response.text)
    
    return {
        "problem": problem,
        "thinking_steps": thinking_steps,
        "answer": response.text
    }

# 示例：解决一个数学问题
result = solve_math_problem("""
一个圆形游泳池的周长增加了20%，请问它的面积增加了多少百分比？
请详细解释解题过程和数学原理。
""")

# 保存结果（可选）
with open("math_solution.json", "w", encoding="utf-8") as f:
    json.dump(result, f, ensure_ascii=False, indent=2)

# 实现简单的结果缓存示例
import hashlib
import json
import os
import google.generativeai as genai

# 简单的磁盘缓存实现
class SimpleCache:
    def __init__(self, cache_dir="./cache"):
        self.cache_dir = cache_dir
        os.makedirs(cache_dir, exist_ok=True)
    
    def _get_cache_key(self, content, params):
        # 创建一个唯一的缓存键
        key_data = {
            "content": content,
            "params": params
        }
        key_str = json.dumps(key_data, sort_keys=True)
        return hashlib.md5(key_str.encode()).hexdigest()
    
    def get(self, content, params):
        key = self._get_cache_key(content, params)
        cache_file = os.path.join(self.cache_dir, key + ".json")
        
        if os.path.exists(cache_file):
            with open(cache_file, "r", encoding="utf-8") as f:
                print("命中缓存!")
                return json.load(f)
        return None
    
    def set(self, content, params, result):
        key = self._get_cache_key(content, params)
        cache_file = os.path.join(self.cache_dir, key + ".json")
        
        with open(cache_file, "w", encoding="utf-8") as f:
            json.dump(result, f, ensure_ascii=False)

# 初始化缓存和API
cache = SimpleCache()
genai.configure(api_key="YOUR_API_KEY", api_base="https://api.laozhang.ai")
model = genai.GenerativeModel("gemini-2.0-flash-experimental")

# 带缓存的API调用函数
def generate_with_cache(prompt, **params):
    # 检查缓存
    cached_result = cache.get(prompt, params)
    if cached_result:
        return cached_result
    
    # 调用API
    response = model.generate_content(prompt, generation_config=params)
    
    # 将结果存入缓存
    result = {"text": response.text}
    if params.get("thinking"):
        result["thinking"] = response.thinking
    
    cache.set(prompt, params, result)
    return result

# 使用示例
result = generate_with_cache(
    "解释量子计算的基本原理",
    temperature=0.2,
    max_output_tokens=500
)