Gemini API Key 获取教程【2025最新】

import requests
import json
import base64

# 设置API密钥和接口地址
api_key = "your_api_key_here"  # 替换为您在简易API中转站获取的API密钥
api_url = "https://api.jeniya.cn/v1/chat/completions"

headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {api_key}"
}

def chat_with_gemini(prompt, model="gemini-pro", temperature=0.7):
    """
    调用Gemini API进行文本对话
    
    Args:
        prompt (str): 用户提问内容
        model (str): 模型名称，可选 gemini-pro, gemini-pro-vision
        temperature (float): 创造性参数，0.0-1.0
    
    Returns:
        str: Gemini的回复内容
    """
    data = {
        "model": model,
        "messages": [
            {"role": "user", "content": prompt}
        ],
        "temperature": temperature,
        "max_tokens": 1000
    }
    
    try:
        response = requests.post(api_url, headers=headers, json=data)
        response.raise_for_status()
        
        result = response.json()
        return result["choices"][0]["message"]["content"]
    
    except requests.exceptions.RequestException as e:
        return f"API调用错误: {e}"
    except KeyError as e:
        return f"响应格式错误: {e}"

def analyze_image_with_gemini(image_path, prompt="描述这张图片"):
    """
    使用Gemini Vision分析图片
    
    Args:
        image_path (str): 图片文件路径
        prompt (str): 分析提示词
    
    Returns:
        str: 图片分析结果
    """
    try:
        # 读取并编码图片
        with open(image_path, "rb") as image_file:
            image_data = base64.b64encode(image_file.read()).decode('utf-8')
        
        data = {
            "model": "gemini-pro-vision",
            "messages": [
                {
                    "role": "user",
                    "content": [
                        {"type": "text", "text": prompt},
                        {
                            "type": "image_url",
                            "image_url": {
                                "url": f"data:image/jpeg;base64,{image_data}"
                            }
                        }
                    ]
                }
            ],
            "temperature": 0.5,
            "max_tokens": 800
        }
        
        response = requests.post(api_url, headers=headers, json=data)
        response.raise_for_status()
        
        result = response.json()
        return result["choices"][0]["message"]["content"]
        
    except Exception as e:
        return f"图片分析错误: {e}"

# 基础使用示例
if __name__ == "__main__":
    # 文本对话示例
    print("=== Gemini文本对话示例 ===")
    text_result = chat_with_gemini(
        "解释一下量子计算的基本原理，并说明它与传统计算的区别",
        temperature=0.3
    )
    print("Gemini回复:")
    print(text_result)
    print("\n" + "="*50 + "\n")
    
    # 代码生成示例
    print("=== Gemini代码生成示例 ===")
    code_result = chat_with_gemini(
        "用Python写一个快速排序算法，并添加详细注释",
        model="gemini-pro",
        temperature=0.2
    )
    print("生成的代码:")
    print(code_result)
    print("\n" + "="*50 + "\n")
    
    # 图片分析示例（需要替换为实际图片路径）
    # image_result = analyze_image_with_gemini(
    #     "path/to/your/image.jpg",
    #     "详细分析这张图片中的内容，包括物体、场景、颜色等"
    # )
    # print("图片分析结果:")
    # print(image_result)

// 安装依赖: npm install axios form-data
const axios = require('axios');
const fs = require('fs');

/**
 * Gemini API调用类
 */
class GeminiAPI {
    constructor(apiKey) {
        this.apiKey = apiKey;
        this.baseURL = 'https://api.jeniya.cn/v1/chat/completions';
        this.headers = {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${this.apiKey}`
        };
    }

    /**
     * 文本对话
     * @param {string} prompt - 用户输入
     * @param {Object} options - 可选参数
     * @returns {Promise<string>} Gemini的回复
     */
    async chat(prompt, options = {}) {
        const {
            model = 'gemini-pro',
            temperature = 0.7,
            maxTokens = 1000
        } = options;

        const requestData = {
            model,
            messages: [
                { role: 'user', content: prompt }
            ],
            temperature,
            max_tokens: maxTokens
        };

        try {
            const response = await axios.post(this.baseURL, requestData, {
                headers: this.headers,
                timeout: 30000
            });

            return response.data.choices[0].message.content;
        } catch (error) {
            this.handleError(error);
        }
    }

    /**
     * 图片分析
     * @param {string} imagePath - 图片路径
     * @param {string} prompt - 分析提示
     * @returns {Promise<string>} 分析结果
     */
    async analyzeImage(imagePath, prompt = '分析这张图片') {
        try {
            // 读取图片并转换为base64
            const imageBuffer = fs.readFileSync(imagePath);
            const imageBase64 = imageBuffer.toString('base64');
            const mimeType = this.getMimeType(imagePath);

            const requestData = {
                model: 'gemini-pro-vision',
                messages: [
                    {
                        role: 'user',
                        content: [
                            { type: 'text', text: prompt },
                            {
                                type: 'image_url',
                                image_url: {
                                    url: `data:${mimeType};base64,${imageBase64}`
                                }
                            }
                        ]
                    }
                ],
                temperature: 0.5,
                max_tokens: 800
            };

            const response = await axios.post(this.baseURL, requestData, {
                headers: this.headers,
                timeout: 45000
            });

            return response.data.choices[0].message.content;
        } catch (error) {
            this.handleError(error);
        }
    }

    /**
     * 多轮对话
     * @param {Array} messages - 对话历史
     * @param {Object} options - 可选参数
     * @returns {Promise<string>} Gemini的回复
     */
    async chatWithHistory(messages, options = {}) {
        const {
            model = 'gemini-pro',
            temperature = 0.7,
            maxTokens = 1000
        } = options;

        const requestData = {
            model,
            messages,
            temperature,
            max_tokens: maxTokens
        };

        try {
            const response = await axios.post(this.baseURL, requestData, {
                headers: this.headers,
                timeout: 30000
            });

            return response.data.choices[0].message.content;
        } catch (error) {
            this.handleError(error);
        }
    }

    /**
     * 代码分析和生成
     * @param {string} codeRequest - 代码需求描述
     * @param {string} language - 编程语言
     * @returns {Promise<string>} 生成的代码
     */
    async generateCode(codeRequest, language = 'python') {
        const prompt = `请用${language}编写代码：${codeRequest}。要求代码简洁、高效，并包含必要的注释。`;
        
        return await this.chat(prompt, {
            model: 'gemini-pro',
            temperature: 0.2,
            maxTokens: 1500
        });
    }

    /**
     * 获取文件MIME类型
     * @param {string} filePath - 文件路径
     * @returns {string} MIME类型
     */
    getMimeType(filePath) {
        const ext = filePath.toLowerCase().split('.').pop();
        const mimeTypes = {
            'jpg': 'image/jpeg',
            'jpeg': 'image/jpeg',
            'png': 'image/png',
            'gif': 'image/gif',
            'webp': 'image/webp'
        };
        return mimeTypes[ext] || 'image/jpeg';
    }

    /**
     * 错误处理
     * @param {Error} error - 错误对象
     */
    handleError(error) {
        if (error.response) {
            throw new Error(`API错误 ${error.response.status}: ${error.response.data.error?.message || '未知错误'}`);
        } else if (error.request) {
            throw new Error('网络连接错误，请检查网络设置');
        } else {
            throw new Error(`请求配置错误: ${error.message}`);
        }
    }
}

// 使用示例
async function main() {
    const gemini = new GeminiAPI('your_api_key_here');  // 替换为您的API密钥

    try {
        // 基础文本对话
        console.log('=== 文本对话示例 ===');
        const textResult = await gemini.chat(
            '解释一下机器学习中的过拟合问题，并提供3种解决方案'
        );
        console.log('Gemini回复:', textResult);

        // 代码生成示例
        console.log('\n=== 代码生成示例 ===');
        const codeResult = await gemini.generateCode(
            '实现一个二叉搜索树的插入和搜索功能',
            'javascript'
        );
        console.log('生成的代码:', codeResult);

        // 多轮对话示例
        console.log('\n=== 多轮对话示例 ===');
        const conversation = [
            { role: 'user', content: '什么是深度学习？' }
        ];

        const firstResponse = await gemini.chatWithHistory(conversation);
        console.log('第一轮回复:', firstResponse);

        conversation.push({ role: 'assistant', content: firstResponse });
        conversation.push({ 
            role: 'user', 
            content: '深度学习在计算机视觉领域有哪些应用？' 
        });

        const secondResponse = await gemini.chatWithHistory(conversation);
        console.log('第二轮回复:', secondResponse);

        // 图片分析示例（需要实际图片文件）
        // const imageResult = await gemini.analyzeImage(
        //     './sample-image.jpg',
        //     '详细描述这张图片的内容，包括物体、场景、颜色等信息'
        // );
        // console.log('图片分析结果:', imageResult);

    } catch (error) {
        console.error('调用出错:', error.message);
    }
}

// 运行示例
main();