100 《Gemini API 权威指南：从入门到精通》

                                
                                    

                            
1
                            
python -m venv venv
                        
                                
                            

                                
                                    

                            
1
                            
venv\Scripts\activate
                        
                                
                            

                                
                                    

                            
1
                            
source venv/bin/activate
                        
                                
                            

                                
                                    

                            
1
                            
npm init -y
                        
                                
                            

                                
                                    

                            
1
                            
pip install google-generativeai
                        
                                
                            

                                
                                    

                            
1
                            
npm install @google/generative-ai
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            

                        

                            
4
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY") # 从环境变量中获取 API 密钥
                        

                            
5
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        
                                
                            

                                
                                    

                            
1
                            
const { GoogleGenerativeAI } = require("@google/generative-ai");
                        

                            
2
                            
require('dotenv').config(); // 如果使用 .env 文件管理环境变量
                        

                            
3
                            

                        

                            
4
                            
const GOOGLE_API_KEY = process.env.GOOGLE_API_KEY; // 从环境变量中获取 API 密钥
                        

                            
5
                            
const genAI = new GoogleGenerativeAI(GOOGLE_API_KEY);
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            

                        

                            
4
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
                        

                            
5
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        

                            
6
                            

                        

                            
7
                            
model = genai.GenerativeModel('gemini-pro')
                        
                                
                            

                                
                                    

                            
1
                            
response = model.generate_content("请写一段关于人工智能未来的展望。")
                        

                            
2
                            
print(response.text)
                        
                                
                            

                                
                                    

                            
1
                            
问题：什么是人工智能？
                        

                            
2
                            
答案：人工智能是研究、开发用于模拟、延伸和扩展人的智能的理论、方法、技术及应用系统的一门新的技术科学。
                        

                            
3
                            

                        

                            
4
                            
问题：人工智能有哪些应用领域？
                        

                            
5
                            
答案：人工智能的应用领域非常广泛，包括机器学习、计算机视觉、自然语言处理、机器人技术等。
                        

                            
6
                            

                        

                            
7
                            
问题：Gemini API 是什么？
                        

                            
8
                            
答案：
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            

                        

                            
4
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
                        

                            
5
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        

                            
6
                            
model = genai.GenerativeModel('gemini-pro')
                        

                            
7
                            

                        

                            
8
                            
article = """
                        

                            
9
                            
人工智能（Artificial Intelligence, AI）是当前科技领域最热门的研究方向之一。随着计算能力的提升和数据规模的增长，人工智能技术取得了巨大的突破，并在各个领域展现出广阔的应用前景。
                        

                            
10
                            
人工智能的应用领域非常广泛，包括自然语言处理、计算机视觉、机器学习、机器人技术等。在自然语言处理领域，人工智能可以用于机器翻译、文本摘要、情感分析、对话系统等任务。在计算机视觉领域，人工智能可以用于图像识别、目标检测、图像生成、图像编辑等任务。在机器学习领域，人工智能可以用于分类、回归、聚类、推荐系统等任务。在机器人技术领域，人工智能可以用于自主导航、路径规划、物体抓取、人机交互等任务。
                        

                            
11
                            
人工智能的发展离不开大量的训练数据和强大的计算资源。深度学习是人工智能领域最重要的技术之一，它通过构建深层神经网络模型，从海量数据中学习复杂的模式和表示，从而实现各种人工智能任务。
                        

                            
12
                            
未来，人工智能将继续深入发展，并在更多领域得到应用。例如，在医疗领域，人工智能可以辅助医生进行疾病诊断、药物研发、患者监护等。在教育领域，人工智能可以提供个性化的学习辅导、智能评测、学习资源推荐等。在交通领域，人工智能可以实现自动驾驶、智能交通管理、交通拥堵预测等。
                        

                            
13
                            
然而，人工智能的发展也面临着一些挑战和伦理问题，例如数据隐私、算法偏见、就业影响、安全风险等。我们需要在发展人工智能技术的同时，也要关注和解决这些挑战和问题，确保人工智能技术能够造福人类社会。
                        

                            
14
                            
"""
                        

                            
15
                            

                        

                            
16
                            
prompt = f"""
                        

                            
17
                            
请对以下文章进行摘要，字数控制在 100 字左右：
                        

                            
18
                            

                        

                            
19
                            
{article}
                        

                            
20
                            
"""
                        

                            
21
                            

                        

                            
22
                            
response = model.generate_content(prompt)
                        

                            
23
                            
print("文章摘要：")
                        

                            
24
                            
print(response.text)
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            

                        

                            
4
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
                        

                            
5
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        

                            
6
                            
model = genai.GenerativeModel('gemini-pro')
                        

                            
7
                            

                        

                            
8
                            
prompt = """
                        

                            
9
                            
请用 Python 编写一个函数，计算斐波那契数列的第 n 项。
                        

                            
10
                            
"""
                        

                            
11
                            

                        

                            
12
                            
response = model.generate_content(prompt)
                        

                            
13
                            
print("生成的 Python 代码：")
                        

                            
14
                            
print(response.text)
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            

                        

                            
4
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
                        

                            
5
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        

                            
6
                            
model = genai.GenerativeModel('gemini-pro')
                        

                            
7
                            

                        

                            
8
                            
prompt = "你好！"
                        

                            
9
                            

                        

                            
10
                            
response_stream = model.generate_content(prompt, stream=True)
                        

                            
11
                            

                        

                            
12
                            
print("模型回复：")
                        

                            
13
                            
for chunk in response_stream.stream():
                        

                            
14
                            
    print(chunk.text, end="")
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            

                        

                            
4
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
                        

                            
5
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        

                            
6
                            
model = genai.GenerativeModel('gemini-pro')
                        

                            
7
                            

                        

                            
8
                            
prompt = "请写一首关于夏天的诗歌。"
                        

                            
9
                            

                        

                            
10
                            
# temperature = 0.1，较低的随机性
                        

                            
11
                            
generation_config_low_temp = genai.GenerationConfig(temperature=0.1)
                        

                            
12
                            
response_low_temp = model.generate_content(prompt, generation_config=generation_config_low_temp)
                        

                            
13
                            
print("Temperature = 0.1 的生成结果：")
                        

                            
14
                            
print(response_low_temp.text)
                        

                            
15
                            

                        

                            
16
                            
print("-" * 30) # 分隔线
                        

                            
17
                            

                        

                            
18
                            
# temperature = 0.9，较高的随机性
                        

                            
19
                            
generation_config_high_temp = genai.GenerationConfig(temperature=0.9)
                        

                            
20
                            
response_high_temp = model.generate_content(prompt, generation_config=generation_config_high_temp)
                        

                            
21
                            
print("Temperature = 0.9 的生成结果：")
                        

                            
22
                            
print(response_high_temp.text)
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            

                        

                            
4
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
                        

                            
5
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        

                            
6
                            

                        

                            
7
                            
model = genai.GenerativeModel('gemini-pro-vision')
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            

                        

                            
4
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
                        

                            
5
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        

                            
6
                            
model = genai.GenerativeModel('gemini-pro-vision')
                        

                            
7
                            

                        

                            
8
                            
prompt = "一只戴着墨镜的柯基犬在海滩上冲浪"
                        

                            
9
                            

                        

                            
10
                            
response = model.generate_content([prompt])
                        

                            
11
                            

                        

                            
12
                            
if response.parts and hasattr(response.parts[0], 'inline_data') and response.parts[0].inline_data.mime_type.startswith('image/'):
                        

                            
13
                            
    image_data = response.parts[0].inline_data.data
                        

                            
14
                            
    # 将 image_data 保存为图片文件，例如 PNG 格式
                        

                            
15
                            
    with open("corgi_surfer.png", "wb") as f:
                        

                            
16
                            
        f.write(image_data)
                        

                            
17
                            
    print("图像已保存为 corgi_surfer.png")
                        

                            
18
                            
else:
                        

                            
19
                            
    print("未生成图像内容")
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            
import base64
                        

                            
4
                            

                        

                            
5
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
                        

                            
6
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        

                            
7
                            
model = genai.GenerativeModel('gemini-pro-vision')
                        

                            
8
                            

                        

                            
9
                            
# 读取输入图像文件并进行 base64 编码
                        

                            
10
                            
def encode_image(image_path):
                        

                            
11
                            
    with open(image_path, "rb") as image_file:
                        

                            
12
                            
        return base64.b64encode(image_file.read()).decode('utf-8')
                        

                            
13
                            

                        

                            
14
                            
input_image_path = "input_image.png" # 替换为您的输入图像路径
                        

                            
15
                            
image_data_base64 = encode_image(input_image_path)
                        

                            
16
                            

                        

                            
17
                            
prompt = "将图片中的猫咪变成狗狗"
                        

                            
18
                            

                        

                            
19
                            
image_content = {
                        

                            
20
                            
    "mime_type": "image/png", # 根据您的图像类型修改 mime_type
                        

                            
21
                            
    "data": image_data_base64
                        

                            
22
                            
}
                        

                            
23
                            

                        

                            
24
                            
response = model.generate_content([prompt, image_content])
                        

                            
25
                            

                        

                            
26
                            
if response.parts and hasattr(response.parts[0], 'inline_data') and response.parts[0].inline_data.mime_type.startswith('image/'):
                        

                            
27
                            
    output_image_data = response.parts[0].inline_data.data
                        

                            
28
                            
    # 将 output_image_data 保存为图片文件，例如 output_image.png
                        

                            
29
                            
    with open("output_image.png", "wb") as f:
                        

                            
30
                            
        f.write(output_image_data)
                        

                            
31
                            
    print("图像已保存为 output_image.png")
                        

                            
32
                            
else:
                        

                            
33
                            
    print("未生成图像内容")
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            
import base64
                        

                            
4
                            

                        

                            
5
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
                        

                            
6
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        

                            
7
                            
model = genai.GenerativeModel('gemini-pro-vision')
                        

                            
8
                            

                        

                            
9
                            
# 读取本地图像文件并进行 Base64 编码
                        

                            
10
                            
def encode_image(image_path):
                        

                            
11
                            
    with open(image_path, "rb") as image_file:
                        

                            
12
                            
        return base64.b64encode(image_file.read()).decode('utf-8')
                        

                            
13
                            

                        

                            
14
                            
image_path = "input_image.jpg" # 替换为您的图像路径
                        

                            
15
                            
image_base64 = encode_image(image_path)
                        

                            
16
                            

                        

                            
17
                            
prompt_text = "描述这张图片的内容"
                        

                            
18
                            

                        

                            
19
                            
image_part = {
                        

                            
20
                            
    "mime_type": "image/jpeg", # 根据您的图像类型修改 mime_type
                        

                            
21
                            
    "data": image_base64
                        

                            
22
                            
}
                        

                            
23
                            

                        

                            
24
                            
text_part = {
                        

                            
25
                            
    "text": prompt_text
                        

                            
26
                            
}
                        

                            
27
                            

                        

                            
28
                            
response = model.generate_content([text_part, image_part]) # 注意输入 parts 的顺序
                        

                            
29
                            

                        

                            
30
                            
print(response.text)
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            

                        

                            
4
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
                        

                            
5
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        

                            
6
                            
text_model = genai.GenerativeModel('gemini-pro')
                        

                            
7
                            

                        

                            
8
                            
text_prompt = "请描述一下你想象中的未来城市是什么样的？"
                        

                            
9
                            
text_response = text_model.generate_content(text_prompt)
                        

                            
10
                            
future_city_description = text_response.text
                        

                            
11
                            
print("未来城市描述：")
                        

                            
12
                            
print(future_city_description)
                        
                                
                            

                                
                                    

                            
1
                            
image_model = genai.GenerativeModel('gemini-pro-vision')
                        

                            
2
                            
image_prompt = future_city_description # 使用之前生成的文本描述作为图像 prompt
                        

                            
3
                            
image_response = image_model.generate_content([image_prompt])
                        

                            
4
                            

                        

                            
5
                            
if image_response.parts and hasattr(image_response.parts[0], 'inline_data') and image_response.parts[0].inline_data.mime_type.startswith('image/'):
                        

                            
6
                            
    future_city_image_data = image_response.parts[0].inline_data.data
                        

                            
7
                            
    # 保存图像
                        

                            
8
                            
    with open("future_city_image.png", "wb") as f:
                        

                            
9
                            
        f.write(future_city_image_data)
                        

                            
10
                            
    print("未来城市图像已保存为 future_city_image.png")
                        

                            
11
                            
else:
                        

                            
12
                            
    print("未生成图像内容")
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            
import base64
                        

                            
4
                            

                        

                            
5
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
                        

                            
6
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        

                            
7
                            
model = genai.GenerativeModel('gemini-pro-vision')
                        

                            
8
                            

                        

                            
9
                            
def encode_image(image_path): # 图像编码函数 (与之前示例相同)
                        

                            
10
                            
    with open(image_path, "rb") as image_file:
                        

                            
11
                            
        return base64.b64encode(image_file.read()).decode('utf-8')
                        

                            
12
                            

                        

                            
13
                            
def multimodal_chatbot(user_input_text, user_input_image_path=None):
                        

                            
14
                            
    input_parts = []
                        

                            
15
                            
    if user_input_text:
                        

                            
16
                            
        input_parts.append({"text": user_input_text})
                        

                            
17
                            
    if user_input_image_path:
                        

                            
18
                            
        image_base64 = encode_image(user_input_image_path)
                        

                            
19
                            
        input_parts.append({
                        

                            
20
                            
            "mime_type": "image/jpeg", # 假设用户上传的是 JPEG 图像
                        

                            
21
                            
            "data": image_base64
                        

                            
22
                            
        })
                        

                            
23
                            

                        

                            
24
                            
    response = model.generate_content(input_parts)
                        

                            
25
                            
    return response.text
                        

                            
26
                            

                        

                            
27
                            
# 示例对话
                        

                            
28
                            
print("用户：你好！")
                        

                            
29
                            
response1 = multimodal_chatbot("你好！")
                        

                            
30
                            
print("机器人：" + response1)
                        

                            
31
                            

                        

                            
32
                            
print("\n用户：这张照片里的建筑是什么？ (上传图像 landmark.jpg)")
                        

                            
33
                            
response2 = multimodal_chatbot("这张照片里的建筑是什么？", "landmark.jpg") # 假设用户上传了名为 landmark.jpg 的图像
                        

                            
34
                            
print("机器人：" + response2)
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            

                        

                            
4
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
                        

                            
5
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        

                            
6
                            
model = genai.GenerativeModel('gemini-pro')
                        

                            
7
                            

                        

                            
8
                            
prompt = "请用一句话概括人工智能的优势。"
                        

                            
9
                            

                        

                            
10
                            
response_stream = model.generate_content(prompt, stream=True) # 启用流式响应
                        

                            
11
                            

                        

                            
12
                            
print("模型回复 (流式输出)：")
                        

                            
13
                            
for chunk in response_stream.stream(): # 使用 .stream() 方法迭代获取 token 流
                        

                            
14
                            
    print(chunk.text, end="") # 逐 token 打印输出
                        
                                
                            

                                
                                    

                            
1
                            
import json
                        

                            
2
                            

                        

                            
3
                            
def get_weather(city_name):
                        

                            
4
                            
    """
                        

                            
5
                            
    获取指定城市的天气信息。
                        

                            
6
                            

                        

                            
7
                            
    Args:
                        

                            
8
                            
        city_name: 城市名称 (字符串).
                        

                            
9
                            

                        

                            
10
                            
    Returns:
                        

                            
11
                            
        包含天气信息的 JSON 字符串，例如：
                        

                            
12
                            
        '{"city": "北京", "temperature": "25℃", "condition": "晴"}'
                        

                            
13
                            
        如果城市不存在或获取天气信息失败，则返回 None.
                        

                            
14
                            
    """
                        

                            
15
                            
    if city_name == "北京":
                        

                            
16
                            
        weather_info = {"city": "北京", "temperature": "28℃", "condition": "晴朗"}
                        

                            
17
                            
    elif city_name == "上海":
                        

                            
18
                            
        weather_info = {"city": "上海", "temperature": "26℃", "condition": "多云"}
                        

                            
19
                            
    else:
                        

                            
20
                            
        return None # 城市不存在或获取天气信息失败时返回 None
                        

                            
21
                            
    return json.dumps(weather_info, ensure_ascii=False) # 返回 JSON 字符串
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            

                        

                            
4
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
                        

                            
5
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        

                            
6
                            
model = genai.GenerativeModel('gemini-pro')
                        

                            
7
                            

                        

                            
8
                            
# 函数定义列表
                        

                            
9
                            
function_declarations = [
                        

                            
10
                            
    {
                        

                            
11
                            
        "name": "get_weather", # 函数名称，需要与实际定义的函数名一致
                        

                            
12
                            
        "description": "获取指定城市的天气信息", # 函数描述，帮助模型理解函数功能
                        

                            
13
                            
        "parameters": {
                        

                            
14
                            
            "type": "OBJECT", # 参数类型，这里是 JSON 对象
                        

                            
15
                            
            "properties": {
                        

                            
16
                            
                "city_name": { # 参数名称
                        

                            
17
                            
                    "type": "STRING", # 参数类型，字符串
                        

                            
18
                            
                    "description": "城市名称" # 参数描述
                        

                            
19
                            
                }
                        

                            
20
                            
            },
                        

                            
21
                            
            "required": ["city_name"] # 必选参数列表
                        

                            
22
                            
        }
                        

                            
23
                            
    }
                        

                            
24
                            
]
                        

                            
25
                            

                        

                            
26
                            
prompt = "今天北京天气怎么样？"
                        

                            
27
                            

                        

                            
28
                            
response = model.generate_content(
                        

                            
29
                            
    prompt,
                        

                            
30
                            
    function_declarations=function_declarations # 传递函数定义列表
                        

                            
31
                            
)
                        

                            
32
                            

                        

                            
33
                            
if response.parts and response.parts[0].function_call: # 判断是否返回函数调用请求
                        

                            
34
                            
    function_call = response.parts[0].function_call
                        

                            
35
                            
    function_name = function_call.name # 获取函数名称
                        

                            
36
                            
    function_arguments = function_call.args # 获取函数参数
                        

                            
37
                            

                        

                            
38
                            
    print(f"模型请求调用函数: {function_name}")
                        

                            
39
                            
    print(f"函数参数: {function_arguments}")
                        

                            
40
                            

                        

                            
41
                            
    if function_name == "get_weather": # 判断调用的函数是否为 get_weather
                        

                            
42
                            
        city_name = function_arguments.get("city_name") # 获取城市名称参数
                        

                            
43
                            
        weather_result = get_weather(city_name) # 调用实际的 get_weather 函数
                        

                            
44
                            
        if weather_result:
                        

                            
45
                            
            print(f"函数执行结果: {weather_result}")
                        

                            
46
                            
            # 将函数执行结果作为 tool_outputs 传递给模型，让模型继续生成回复
                        

                            
47
                            
            tool_outputs = [
                        

                            
48
                            
                {
                        

                            
49
                            
                    "function_name": function_name,
                        

                            
50
                            
                    "content": weather_result # 函数执行结果
                        

                            
51
                            
                }
                        

                            
52
                            
            ]
                        

                            
53
                            
            response = model.generate_content(
                        

                            
54
                            
                prompt,
                        

                            
55
                            
                function_declarations=function_declarations,
                        

                            
56
                            
                tool_outputs=tool_outputs # 传递函数执行结果
                        

                            
57
                            
            )
                        

                            
58
                            
            print("模型最终回复：")
                        

                            
59
                            
            print(response.text)
                        

                            
60
                            
        else:
                        

                            
61
                            
            print("获取天气信息失败")
                        

                            
62
                            
else: # 如果没有函数调用请求，则直接输出模型生成的文本回复
                        

                            
63
                            
    print("模型回复：")
                        

                            
64
                            
    print(response.text)
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            

                        

                            
4
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
                        

                            
5
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        

                            
6
                            
model = genai.GenerativeModel('gemini-pro')
                        

                            
7
                            

                        

                            
8
                            
prompt = "请写一段包含暴力内容的文字。" # 故意生成有害内容
                        

                            
9
                            

                        

                            
10
                            
# 安全设置：只屏蔽高风险的有害内容 (BLOCK_ONLY_HIGH)
                        

                            
11
                            
safety_settings_moderate = [
                        

                            
12
                            
    {
                        

                            
13
                            
        "category": genai.HarmCategory.HARM_CATEGORY_HARASSMENT,
                        

                            
14
                            
        "threshold": genai.SafetySetting.BLOCK_ONLY_HIGH
                        

                            
15
                            
    },
                        

                            
16
                            
    {
                        

                            
17
                            
        "category": genai.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
                        

                            
18
                            
        "threshold": genai.SafetySetting.BLOCK_ONLY_HIGH
                        

                            
19
                            
    },
                        

                            
20
                            
    {
                        

                            
21
                            
        "category": genai.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
                        

                            
22
                            
        "threshold": genai.SafetySetting.BLOCK_ONLY_HIGH
                        

                            
23
                            
    },
                        

                            
24
                            
    {
                        

                            
25
                            
        "category": genai.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
                        

                            
26
                            
        "threshold": genai.SafetySetting.BLOCK_ONLY_HIGH
                        

                            
27
                            
    }
                        

                            
28
                            
]
                        

                            
29
                            

                        

                            
30
                            
response_moderate = model.generate_content(
                        

                            
31
                            
    prompt,
                        

                            
32
                            
    safety_settings=safety_settings_moderate # 应用安全设置
                        

                            
33
                            
)
                        

                            
34
                            
print("安全设置为 BLOCK_ONLY_HIGH 的生成结果：")
                        

                            
35
                            
print(response_moderate.text)
                        

                            
36
                            

                        

                            
37
                            
print("-" * 30) # 分隔线
                        

                            
38
                            

                        

                            
39
                            
# 安全设置：屏蔽所有风险等级的有害内容 (BLOCK_NONE) - 谨慎使用！
                        

                            
40
                            
safety_settings_none = [
                        

                            
41
                            
    {
                        

                            
42
                            
        "category": genai.HarmCategory.HARM_CATEGORY_HARASSMENT,
                        

                            
43
                            
        "threshold": genai.SafetySetting.BLOCK_NONE # 不屏蔽任何内容
                        

                            
44
                            
    },
                        

                            
45
                            
    {
                        

                            
46
                            
        "category": genai.HarmCategory.HARM_CATEGORY_HATE_SPEECH,
                        

                            
47
                            
        "threshold": genai.SafetySetting.BLOCK_NONE # 不屏蔽任何内容
                        

                            
48
                            
    },
                        

                            
49
                            
    {
                        

                            
50
                            
        "category": genai.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT,
                        

                            
51
                            
        "threshold": genai.SafetySetting.BLOCK_NONE # 不屏蔽任何内容
                        

                            
52
                            
    },
                        

                            
53
                            
    {
                        

                            
54
                            
        "category": genai.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT,
                        

                            
55
                            
        "threshold": genai.SafetySetting.BLOCK_NONE # 不屏蔽任何内容
                        

                            
56
                            
    }
                        

                            
57
                            
]
                        

                            
58
                            

                        

                            
59
                            
response_none = model.generate_content(
                        

                            
60
                            
    prompt,
                        

                            
61
                            
    safety_settings=safety_settings_none # 应用安全设置
                        

                            
62
                            
)
                        

                            
63
                            
print("安全设置为 BLOCK_NONE 的生成结果 (请谨慎使用!)：")
                        

                            
64
                            
print(response_none.text)
                        
                                
                            

                                
                                    

                            
1
                            
请根据以下要点，撰写一篇 500 字左右的新闻稿，主题为“最新款智能手机发布”：
                        

                            
2
                            

                        

                            
3
                            
要点：
                        

                            
4
                            
- 手机型号：XYZ Phone Pro
                        

                            
5
                            
- 发布日期：2024年1月1日
                        

                            
6
                            
- 主要特点：
                        

                            
7
                            
    - 强大的处理器
                        

                            
8
                            
    - 优秀的摄像头
                        

                            
9
                            
    - 创新的设计
                        

                            
10
                            
- 售价：人民币 5999 元起
                        

                            
11
                            
- 目标受众：科技爱好者，年轻用户
                        
                                
                            

                                
                                    

                            
1
                            
请为一款新推出的咖啡豆撰写一句广告语，要求：
                        

                            
2
                            

                        

                            
3
                            
- 产品名称：星夜特调咖啡豆
                        

                            
4
                            
- 产品特点：口感醇厚，香气浓郁，回味悠长
                        

                            
5
                            
- 目标受众：咖啡爱好者，追求高品质生活的人群
                        

                            
6
                            
- 风格：简洁，大气，有格调
                        
                                
                            

                                
                                    

                            
1
                            
请为以下旅游目的地撰写一条微博文案，字数控制在 140 字以内，风格活泼有趣，吸引年轻用户：
                        

                            
2
                            

                        

                            
3
                            
旅游目的地：
                        

                            
4
                            
- 三亚
                        

                            
5
                            
- 丽江
                        

                            
6
                            
- 成都
                        

                            
7
                            
- 厦门
                        

                            
8
                            
- 哈尔滨
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            

                        

                            
4
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
                        

                            
5
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        

                            
6
                            
model = genai.GenerativeModel('gemini-pro')
                        

                            
7
                            

                        

                            
8
                            
prompt = "请用 Markdown 格式列出人工智能的主要应用领域。"
                        

                            
9
                            

                        

                            
10
                            
response = model.generate_content(prompt)
                        

                            
11
                            
print(response.text)
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            

                        

                            
4
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
                        

                            
5
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        

                            
6
                            
model = genai.GenerativeModel('gemini-pro')
                        

                            
7
                            

                        

                            
8
                            
prompt = """
                        

                            
9
                            
问题：小明有 5 个苹果，小红给了他 3 个苹果，然后小明又吃了 2 个苹果，请问小明现在还剩下几个苹果？
                        

                            
10
                            

                        

                            
11
                            
思考过程：
                        

                            
12
                            
1. 小明最初有 5 个苹果。
                        

                            
13
                            
2. 小红给了他 3 个苹果，所以现在有 5 + 3 = 8 个苹果。
                        

                            
14
                            
3. 小明吃了 2 个苹果，所以现在还剩下 8 - 2 = 6 个苹果。
                        

                            
15
                            

                        

                            
16
                            
答案：小明现在还剩下 6 个苹果。
                        

                            
17
                            

                        

                            
18
                            
请用同样的思考方式，解答以下问题：
                        

                            
19
                            
问题：一个书包 30 元，一支笔 5 元，小刚买了一个书包和两支笔，一共花了多少钱？
                        

                            
20
                            
"""
                        

                            
21
                            

                        

                            
22
                            
response = model.generate_content(prompt)
                        

                            
23
                            
print(response.text)
                        
                                
                            

                                
                                    

                            
1
                            
import google.generativeai as genai
                        

                            
2
                            
import os
                        

                            
3
                            
import time
                        

                            
4
                            

                        

                            
5
                            
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
                        

                            
6
                            
genai.configure(api_key=GOOGLE_API_KEY)
                        

                            
7
                            
model = genai.GenerativeModel('gemini-pro')
                        

                            
8
                            

                        

                            
9
                            
prompt = "请写一段关于人工智能的未来展望。"
                        

                            
10
                            

                        

                            
11
                            
max_retries = 3 # 最大重试次数
                        

                            
12
                            
retry_delay = 5 # 重试延迟时间 (秒)
                        

                            
13
                            

                        

                            
14
                            
for retry_count in range(max_retries + 1):
                        

                            
15
                            
    try:
                        

                            
16
                            
        response = model.generate_content(prompt)
                        

                            
17
                            
        print(response.text)
                        

                            
18
                            
        break # 请求成功，跳出循环
                        

                            
19
                            
    except Exception as e:
                        

                            
20
                            
        if retry_count < max_retries and "429" in str(e): # 捕获频率限制错误 (状态码 429)
                        

                            
21
                            
            retry_after = 60 # 假设 Retry-After 为 60 秒 (实际应从 Response Headers 中获取)
                        

                            
22
                            
            print(f"API 频率限制，第 {retry_count + 1} 次重试，等待 {retry_after} 秒...")
                        

                            
23
                            
            time.sleep(retry_after) # 等待指定时间后重试
                        

                            
24
                            
        else: # 其他错误或超过最大重试次数
                        

                            
25
                            
            print(f"API 请求失败: {e}")
                        

                            
26
                            
            break
                        
                                
                            

                                
                                    

                            
1
                            
const { GoogleGenerativeAI } = require("@google/generative-ai");
                        

                            
2
                            
require('dotenv').config();
                        

                            
3
                            

                        

                            
4
                            
const GOOGLE_API_KEY = process.env.GOOGLE_API_KEY;
                        

                            
5
                            
const genAI = new GoogleGenerativeAI(GOOGLE_API_KEY);
                        

                            
6
                            
const model = genAI.GenerativeModel('gemini-pro');
                        

                            
7
                            

                        

                            
8
                            
const prompt = "请写一段关于人工智能的未来展望。";
                        

                            
9
                            

                        

                            
10
                            
const maxRetries = 3; // 最大重试次数
                        

                            
11
                            
const retryDelay = 5; // 重试延迟时间 (秒)
                        

                            
12
                            

                        

                            
13
                            
async function generateContentWithRetry(prompt, retries) {
                        

                            
14
                            
    try {
                        

                            
15
                            
        const response = await model.generateContent(prompt);
                        

                            
16
                            
        console.log(response.response.text());
                        

                            
17
                            
    } catch (error) {
                        

                            
18
                            
        if (retries < maxRetries && error.message.includes("429")) { // 捕获频率限制错误 (状态码 429)
                        

                            
19
                            
            const retryAfter = 60; // 假设 Retry-After 为 60 秒 (实际应从 Response Headers 中获取)
                        

                            
20
                            
            console.log(`API 频率限制，第 ${retries + 1} 次重试，等待 ${retryAfter} 秒...`);
                        

                            
21
                            
            await new Promise(resolve => setTimeout(resolve, retryAfter * 1000)); // 等待指定时间后重试
                        

                            
22
                            
            await generateContentWithRetry(prompt, retries + 1); // 递归重试
                        

                            
23
                            
        } else { // 其他错误或超过最大重试次数
                        

                            
24
                            
            console.error(`API 请求失败: ${error}`);
                        

                            
25
                            
        }
                        

                            
26
                            
    }
                        

                            
27
                            
}
                        

                            
28
                            

                        

                            
29
                            
generateContentWithRetry(prompt, 0);