# chatapi

**Repository Path**: siyueyiri_1/chatapi

## Basic Information

- **Project Name**: chatapi
- **Description**: 本代码是一个使用OpenAI Chat API和FastAPI构建的聊天机器人的示例。它实现了普通聊天请求和流式聊天请求的功能。

- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2023-09-11
- **Last Updated**: 2023-09-11

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# OpenAI Chatbot API 使用指南

本代码是一个使用OpenAI Chat API和FastAPI构建的聊天机器人的示例。它实现了普通聊天请求和流式聊天请求的功能。

## 开始之前

在运行代码之前，需要进行以下准备工作：

1. 获取OpenAI API 密钥：你需要访问OpenAI官方网站并获取一个API密钥。

2. 安装依赖：请确保已安装所需的依赖库，可以使用以下命令进行安装：

```bash
pip install fastapi openai uvicorn
```

## 使用示例

### 代码1：OpenAIChatbot 类

```python
import openai
import asyncio


class OpenAIChatbot:
    def __init__(self, api_key, model, max_tokens=100, temperature=0.7):
        openai.api_key = api_key
        openai.api_base = "https://api.openai.com"  # 填入正确的API URL
        self.model = model
        self.temperature = temperature
        self.max_tokens = max_tokens
        self.messages = [{"role": "system", "content": "你是一个智能助手，知道一切。问我任何问题！"}]

    async def get_prompt_response(self, string):
        # 发送聊天请求并返回助手的回复
        self.messages.append(
            {"role": "user", "content": string}
        )
        response = await self.send_chat_request(self.messages, self.model, self.temperature, self.max_tokens)
        return {
            "role": "assistant",
            "content": response['content'].strip()
        }

    async def get_prompt_response_stream(self, string):
        # 发送流式聊天请求并返回助手的回复
        self.messages.append(
            {"role": "user", "content": string}
        )
        return await self.send_chat_stream(self.messages, self.model, self.temperature, self.max_tokens)

    @staticmethod
    async def send_chat_stream(messages, model, temperature, max_tokens):
        # 发送流式聊天请求并返回响应
        response = openai.ChatCompletion.create(
            model=model,
            messages=messages,
            temperature=temperature,
            max_tokens=max_tokens,
            n=1,
            stop=None,
            stream=True
        )
        return response

    @staticmethod
    async def send_chat_request(messages, model, temperature, max_tokens):
        # 发送聊天请求并返回响应
        completion = openai.Completion.create(
            engine="text-davinci-003",  # 填入正确的引擎名称
            model=model,
            messages=messages,
            temperature=temperature,
            max_tokens=max_tokens,
            n=1,
            stop=None
        )
        return completion.choices[0]['message']
```

在这个示例代码中，`OpenAIChatbot` 类封装了与OpenAI Chat API 进行聊天的逻辑。通过初始化函数 `__init__` 来设置OpenAI API 的密钥、模型名称以及其他参数。`get_prompt_response` 方法用于发送普通的聊天请求，`get_prompt_response_stream` 方法用于发送流式聊天请求。

### 代码2：FastAPI 接口

```python
from fastapi import FastAPI
from starlette.requests import Request
from fastapi.responses import StreamingResponse

from gpt import OpenAIChatbot

app = FastAPI()

openai_key = "YOUR_OPENAI_API_KEY"


class SessionCache:
    def __init__(self):
        self.sessions = {}

    def get_session(self, session_id: str, request_json: dict):
        # 获取或创建会话对象
        if self.sessions.get(session_id):
            return self.sessions.get(session_id)
        new_bot = OpenAIChatbot(api_key=openai_key,
                                model=request_json.get('model', 'text-davinci-003'),  # 填入正确的模型名称
                                max_tokens=request_json.get('max_tokens', 100),
                                temperature=request_json.get('temperature', 0.7))
        self.sessions[session_id] = new_bot
        return new_bot


SESSION_DATAS = SessionCache()


class ParamsException(Exception):
    def __init__(self, error):
        super(ParamsException, self).__init__(error)
        self.msg = error


def check_chat_params(request_json):
    # 检查聊天请求的参数是否合法
    if request_json.get("message") is None:
        raise ParamsException("message参数不能为空！")


def generate_data(response):
    # 将流式响应转换为生成器
    completion = {'role': '', 'content': ''}
    for event in response:
        if event['choices'][0]['finish_reason'] == 'stop':
            print(f'收到的完成数据: {completion}')
            break
        for delta_k, delta_v in event['choices'][0]['delta'].items():
            print(f'流响应数据: {delta_k} = {delta_v}')
            yield delta_v
            completion[delta_k] += delta_v
    return completion


@app.post("/api/chat/{session_id}")
async def chat(request:Request, session_id):
    # 处理普通的聊天请求的接口
    request_json = await request.json()
    try:
        check_chat_params(request_json)
        session = SESSION_DATAS.get_session(session_id, request_json)
        session: OpenAIChatbot
        return await session.get_prompt_response(request_json['message'])
    except ParamsException as e:
        return {
            "message": e.msg,
            "code": 500
        }


@app.post("/api/stream/chat/{session_id}")
async def stream_chat(request:Request, session_id):
    # 处理流式聊天请求的接口
    request_json = await request.json()
    try:
        check_chat_params(request_json)
        session = SESSION_DATAS.get_session(session_id, request_json)
        session: OpenAIChatbot
        response = await session.get_prompt_response_stream(request_json['message'])
        return StreamingResponse(generate_data(response))
    except ParamsException as e:
        return {
            "message": e.msg,
            "code": 500
        }
```

上述示例代码实现了使用FastAPI创建了两个接口，分别用于处理普通聊天请求和流式聊天请求。其中，`chat` 接口接收普通聊天请求，并使用 `get_prompt_response` 方法获取助手的回复。`stream_chat` 接口接收流式聊天请求，并使用 `get_prompt_response` 方法获取助手的回复的流式响应。

## 运行应用

运行应用之前，请确保已正确配置了OpenAI API的密钥信息并安装了依赖。

可以使用以下命令运行应用：

```bash
uvicorn main:app --host 0.0.0.0 --port 8000
```

在运行成功后，API将在 `http://localhost:8000` 上监听请求。

## 发送聊天请求

### 普通聊天请求

使用以下命令发送普通聊天请求：

```bash
curl -X POST "http://localhost:8000/api/chat/your_session_id" -H  "Content-Type: application/json" -d "{\"message\":\"Hello\"}"
```

其中，`your_session_id` 是会话的唯一标识符。

### 流式聊天请求

使用以下命令发送流式聊天请求：

```bash
curl -X POST "http://localhost:8000/api/stream/chat/your_session_id" -H  "Content-Type: application/json" -d "{\"message\":\"Hello\"}"
```

其中，`your_session_id` 是会话的唯一标识符。

## 注意事项

- 在运行应用之前，请确保在代码中正确配置了OpenAI API的密钥、模型名称和其他参数。
- 请根据具体需求自行修改代码和配置。
- 这只是一个示例代码，可能需要根据具体应用场景做更多的定制和改进。

Enjoy chatting with the AI-powered chatbot!