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

import requests
import json
import time
from typing import List, Dict, Optional

class ChatGPTAPI:
    """ChatGPT API调用类 - 简易API中转站版本"""
    
    def __init__(self, api_key: str):
        """
        初始化ChatGPT API客户端
        
        Args:
            api_key (str): 从简易API中转站获取的API密钥
        """
        self.api_key = api_key
        self.base_url = "https://api.jeniya.cn/v1/chat/completions"
        self.headers = {
            "Content-Type": "application/json",
            "Authorization": f"Bearer {api_key}"
        }
    
    def chat(self, 
             prompt: str, 
             model: str = "gpt-3.5-turbo",
             temperature: float = 0.7,
             max_tokens: int = 1000) -> str:
        """
        基础对话功能
        
        Args:
            prompt (str): 用户输入的问题
            model (str): 模型版本 (gpt-3.5-turbo, gpt-4, gpt-4-turbo)
            temperature (float): 创造性参数 0.0-1.0
            max_tokens (int): 最大输出长度
            
        Returns:
            str: ChatGPT的回复
        """
        data = {
            "model": model,
            "messages": [
                {"role": "user", "content": prompt}
            ],
            "temperature": temperature,
            "max_tokens": max_tokens
        }
        
        try:
            response = requests.post(
                self.base_url, 
                headers=self.headers, 
                json=data, 
                timeout=60
            )
            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 chat_with_history(self, 
                         messages: List[Dict[str, str]], 
                         model: str = "gpt-3.5-turbo",
                         temperature: float = 0.7,
                         max_tokens: int = 1000) -> str:
        """
        支持对话历史的多轮对话
        
        Args:
            messages (List[Dict]): 对话历史记录
            model (str): 模型版本
            temperature (float): 创造性参数
            max_tokens (int): 最大输出长度
            
        Returns:
            str: ChatGPT的回复
        """
        data = {
            "model": model,
            "messages": messages,
            "temperature": temperature,
            "max_tokens": max_tokens
        }
        
        try:
            response = requests.post(
                self.base_url, 
                headers=self.headers, 
                json=data, 
                timeout=60
            )
            response.raise_for_status()
            
            result = response.json()
            return result["choices"][0]["message"]["content"]
            
        except Exception as e:
            return f"多轮对话错误: {e}"
    
    def stream_chat(self, 
                   prompt: str, 
                   model: str = "gpt-3.5-turbo",
                   temperature: float = 0.7) -> str:
        """
        流式对话 - 实时获取回复
        
        Args:
            prompt (str): 用户输入
            model (str): 模型版本
            temperature (float): 创造性参数
            
        Yields:
            str: 实时生成的文本片段
        """
        data = {
            "model": model,
            "messages": [{"role": "user", "content": prompt}],
            "temperature": temperature,
            "stream": True
        }
        
        try:
            response = requests.post(
                self.base_url, 
                headers=self.headers, 
                json=data, 
                stream=True, 
                timeout=60
            )
            response.raise_for_status()
            
            full_response = ""
            for line in response.iter_lines():
                if line:
                    line = line.decode('utf-8')
                    if line.startswith('data: '):
                        data_str = line[6:]
                        if data_str != '[DONE]':
                            try:
                                chunk_data = json.loads(data_str)
                                delta = chunk_data['choices'][0]['delta']
                                if 'content' in delta:
                                    content = delta['content']
                                    full_response += content
                                    yield content
                            except:
                                continue
            
            return full_response
            
        except Exception as e:
            yield f"流式对话错误: {e}"
    
    def generate_code(self, 
                     description: str, 
                     language: str = "python",
                     model: str = "gpt-4") -> str:
        """
        代码生成专用函数
        
        Args:
            description (str): 代码功能描述
            language (str): 编程语言
            model (str): 推荐使用GPT-4获得更好的代码质量
            
        Returns:
            str: 生成的代码
        """
        prompt = f"""请用{language}编写代码实现以下功能：

{description}

要求：
1. 代码简洁高效
2. 添加详细注释
3. 包含错误处理
4. 提供使用示例"""

        return self.chat(prompt, model=model, temperature=0.2)
    
    def analyze_image(self, 
                     image_base64: str, 
                     prompt: str = "请描述这张图片",
                     model: str = "gpt-4-vision-preview") -> str:
        """
        图像分析功能 (GPT-4 Vision)
        
        Args:
            image_base64 (str): Base64编码的图片
            prompt (str): 分析提示
            model (str): 视觉模型
            
        Returns:
            str: 图片分析结果
        """
        data = {
            "model": model,
            "messages": [
                {
                    "role": "user",
                    "content": [
                        {"type": "text", "text": prompt},
                        {
                            "type": "image_url",
                            "image_url": {
                                "url": f"data:image/jpeg;base64,{image_base64}"
                            }
                        }
                    ]
                }
            ],
            "temperature": 0.5,
            "max_tokens": 800
        }
        
        try:
            response = requests.post(
                self.base_url, 
                headers=self.headers, 
                json=data, 
                timeout=60
            )
            response.raise_for_status()
            
            result = response.json()
            return result["choices"][0]["message"]["content"]
            
        except Exception as e:
            return f"图像分析错误: {e}"

# 使用示例和测试代码
if __name__ == "__main__":
    # 初始化API客户端
    api_key = "your_api_key_here"  # 替换为您的API密钥
    chatgpt = ChatGPTAPI(api_key)
    
    print("=== ChatGPT API功能演示 ===\n")
    
    # 1. 基础对话测试
    print("1. 基础对话测试：")
    basic_response = chatgpt.chat(
        "请简单介绍一下人工智能的发展历程",
        model="gpt-3.5-turbo"
    )
    print(f"ChatGPT回复: {basic_response}\n")
    print("-" * 60)
    
    # 2. GPT-4高质量对话
    print("2. GPT-4高质量对话：")
    gpt4_response = chatgpt.chat(
        "请分析一下当前人工智能技术在医疗领域的应用前景和挑战",
        model="gpt-4",
        temperature=0.3
    )
    print(f"GPT-4回复: {gpt4_response}\n")
    print("-" * 60)
    
    # 3. 代码生成测试
    print("3. 代码生成测试：")
    code_result = chatgpt.generate_code(
        "实现一个简单的计算器类，支持四则运算和历史记录功能",
        language="python"
    )
    print(f"生成的代码:\n{code_result}\n")
    print("-" * 60)
    
    # 4. 多轮对话测试
    print("4. 多轮对话测试：")
    conversation = [
        {"role": "user", "content": "什么是机器学习？"},
    ]
    
    first_response = chatgpt.chat_with_history(conversation)
    print(f"第一轮回复: {first_response}")
    
    conversation.append({"role": "assistant", "content": first_response})
    conversation.append({
        "role": "user", 
        "content": "机器学习和深度学习有什么区别？"
    })
    
    second_response = chatgpt.chat_with_history(conversation)
    print(f"第二轮回复: {second_response}\n")
    print("-" * 60)
    
    # 5. 流式对话演示
    print("5. 流式对话演示：")
    print("正在生成回复...")
    stream_response = ""
    for chunk in chatgpt.stream_chat(
        "请写一首关于春天的诗",
        model="gpt-3.5-turbo"
    ):
        print(chunk, end="", flush=True)
        stream_response += chunk
        time.sleep(0.05)  # 模拟打字效果
    
    print(f"\n\n完整回复: {stream_response}")
    
    print("\n=== 演示结束 ===")
    print("更多功能请参考API文档: https://jeniya.top/")

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

/**
 * ChatGPT API JavaScript客户端
 * 适用于Node.js环境和前端开发
 */
class ChatGPTAPI {
    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>} ChatGPT回复
     */
    async chat(prompt, options = {}) {
        const {
            model = 'gpt-3.5-turbo',
            temperature = 0.7,
            maxTokens = 1000,
            systemMessage = null
        } = options;

        const messages = [];
        if (systemMessage) {
            messages.push({ role: 'system', content: systemMessage });
        }
        messages.push({ role: 'user', content: prompt });

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

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

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

    /**
     * 多轮对话功能
     * @param {Array} messages - 对话历史
     * @param {Object} options - 配置选项
     * @returns {Promise<string>} ChatGPT回复
     */
    async chatWithHistory(messages, options = {}) {
        const {
            model = 'gpt-3.5-turbo',
            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: 60000
            });

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

    /**
     * 流式对话功能
     * @param {string} prompt - 用户输入
     * @param {Function} onData - 数据回调函数
     * @param {Object} options - 配置选项
     * @returns {Promise<string>} 完整回复
     */
    async streamChat(prompt, onData, options = {}) {
        const {
            model = 'gpt-3.5-turbo',
            temperature = 0.7
        } = options;

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

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

            let fullResponse = '';
            
            return new Promise((resolve, reject) => {
                response.data.on('data', (chunk) => {
                    const lines = chunk.toString().split('\n');
                    
                    for (const line of lines) {
                        if (line.startsWith('data: ')) {
                            const data = line.slice(6);
                            if (data !== '[DONE]') {
                                try {
                                    const parsed = JSON.parse(data);
                                    const delta = parsed.choices[0].delta;
                                    if (delta.content) {
                                        fullResponse += delta.content;
                                        onData(delta.content);
                                    }
                                } catch (e) {
                                    // 忽略解析错误
                                }
                            }
                        }
                    }
                });

                response.data.on('end', () => {
                    resolve(fullResponse);
                });

                response.data.on('error', (error) => {
                    reject(error);
                });
            });
        } catch (error) {
            this.handleError(error);
        }
    }

    /**
     * 代码生成专用功能
     * @param {string} description - 功能描述
     * @param {string} language - 编程语言
     * @param {Object} options - 配置选项
     * @returns {Promise<string>} 生成的代码
     */
    async generateCode(description, language = 'javascript', options = {}) {
        const prompt = `请用${language}编写代码实现以下功能：

${description}

要求：
1. 代码结构清晰
2. 添加详细注释
3. 包含错误处理
4. 提供使用示例
5. 遵循最佳实践`;

        return await this.chat(prompt, {
            model: 'gpt-4',
            temperature: 0.2,
            ...options
        });
    }

    /**
     * 文本优化功能
     * @param {string} text - 原始文本
     * @param {string} task - 优化任务类型
     * @returns {Promise<string>} 优化后的文本
     */
    async optimizeText(text, task = '润色') {
        const taskPrompts = {
            '润色': '请对以下文本进行润色，使其更加流畅、专业：',
            '纠错': '请检查并纠正以下文本中的语法和拼写错误：',
            '翻译': '请将以下文本翻译成英文：',
            '总结': '请对以下文本进行总结，提取要点：',
            '扩写': '请对以下文本进行扩写，丰富内容和细节：'
        };

        const prompt = `${taskPrompts[task] || taskPrompts['润色']}

${text}`;

        return await this.chat(prompt, {
            model: 'gpt-3.5-turbo',
            temperature: 0.3
        });
    }

    /**
     * 智能问答功能
     * @param {string} question - 问题
     * @param {string} context - 上下文信息
     * @returns {Promise<string>} 回答
     */
    async answerQuestion(question, context = '') {
        let prompt = question;
        if (context) {
            prompt = `基于以下背景信息回答问题：

背景信息：
${context}

问题：${question}

请提供准确、详细的回答。`;
        }

        return await this.chat(prompt, {
            model: 'gpt-4',
            temperature: 0.3
        });
    }

    /**
     * 创意写作功能
     * @param {string} topic - 写作主题
     * @param {string} style - 写作风格
     * @param {number} length - 预期长度
     * @returns {Promise<string>} 创作内容
     */
    async creativeWriting(topic, style = '正式', length = 500) {
        const prompt = `请以"${topic}"为主题进行创意写作。

要求：
- 风格：${style}
- 长度：大约${length}字
- 内容要有创意和深度
- 结构清晰，逻辑连贯`;

        return await this.chat(prompt, {
            model: 'gpt-3.5-turbo',
            temperature: 0.8
        });
    }

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

// 使用示例和演示
async function demonstrateChatGPT() {
    const chatgpt = new ChatGPTAPI('your_api_key_here'); // 替换为您的API密钥

    try {
        console.log('=== ChatGPT API JavaScript演示 ===\n');

        // 1. 基础对话
        console.log('1. 基础对话演示：');
        const basicResponse = await chatgpt.chat(
            '请简要介绍一下JavaScript的特点和应用场景'
        );
        console.log('ChatGPT回复:', basicResponse);
        console.log('\n' + '-'.repeat(60) + '\n');

        // 2. GPT-4高质量对话
        console.log('2. GPT-4专业分析：');
        const professionalResponse = await chatgpt.chat(
            '分析一下前端开发技术的发展趋势，包括框架演进和新技术采用',
            { model: 'gpt-4', temperature: 0.3 }
        );
        console.log('专业分析:', professionalResponse);
        console.log('\n' + '-'.repeat(60) + '\n');

        // 3. 代码生成
        console.log('3. 代码生成演示：');
        const codeResult = await chatgpt.generateCode(
            '创建一个Vue.js组件，实现待办事项列表功能',
            'javascript'
        );
        console.log('生成的代码:', codeResult);
        console.log('\n' + '-'.repeat(60) + '\n');

        // 4. 多轮对话
        console.log('4. 多轮对话演示：');
        let conversation = [
            { role: 'user', content: '什么是RESTful API？' }
        ];

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

        conversation.push({ role: 'assistant', content: firstReply });
        conversation.push({
            role: 'user',
            content: 'RESTful API和GraphQL有什么区别？'
        });

        const secondReply = await chatgpt.chatWithHistory(conversation);
        console.log('第二轮回复:', secondReply);
        console.log('\n' + '-'.repeat(60) + '\n');

        // 5. 流式对话
        console.log('5. 流式对话演示：');
        console.log('正在生成回复...');
        const streamResult = await chatgpt.streamChat(
            '请写一段关于人工智能未来发展的文章',
            (chunk) => process.stdout.write(chunk) // 实时输出
        );
        console.log('\n\n完整回复长度:', streamResult.length);
        console.log('\n' + '-'.repeat(60) + '\n');

        // 6. 文本优化
        console.log('6. 文本优化演示：');
        const originalText = '人工智能技术发展很快，在各个领域都有应用。';
        const optimizedText = await chatgpt.optimizeText(originalText, '扩写');
        console.log('原文:', originalText);
        console.log('扩写后:', optimizedText);
        console.log('\n' + '-'.repeat(60) + '\n');

        // 7. 创意写作
        console.log('7. 创意写作演示：');
        const creativeContent = await chatgpt.creativeWriting(
            '未来城市生活',
            '科幻风格',
            300
        );
        console.log('创意作品:', creativeContent);

    } catch (error) {
        console.error('演示过程中出错:', error.message);
    }
}

// 运行演示
demonstrateChatGPT();

// 导出模块
module.exports = ChatGPTAPI;