airs chat completion

README.md

@@ -8,3 +8,6 @@ pinned: false
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+
+此项目实现在huggingface运行的映射访问到各个大模型。各个大模型安装各自的api规范进行调用就可以了。

app.py

@@ -1,13 +1,9 @@
 # 在终端运行命令：uvicorn app:app --host 0.0.0.0 --port 7860 --reload
-from fastapi import FastAPI, HTTPException, Body
+from fastapi import FastAPI
 from pydantic import BaseModel
 from typing import List
-import logging
 
-# import google.generativeai as genai
-# import json, time, uuid, os
-
-from openai_model import TextCompletionRequest, TextCompletionResponse, ChatCompletionRequest, TbsChatCompletionRequest
+from openai_model import TextCompletionRequest, AirsChatCompletionRequest
 from models import *
 
 app = FastAPI()
@@ -16,11 +12,6 @@ app = FastAPI()
 def greet_json():
     return {"Hello": "World!"}
 
-# 请求和响应模型
-# class ChatRequest(BaseModel):
-#     model: str
-#     messages: List[dict]
-
 class ChatResponse(BaseModel):
     model: str
     messages: List[dict]
@@ -31,9 +22,9 @@ async def create_text_completion(request: TextCompletionRequest):
     response = ModelClass().create_text_completion(request)
     return response
 
-@app.post("/myapp/v1/chat/completions")
-async def create_chat_response(request: TbsChatCompletionRequest):
+# 下面是 airs 的 chat completion 接口
+@app.post("/airs/v1/chat/completions")
+async def airs_create_chat_response(request: AirsChatCompletionRequest):
     ModelClass = class_by_modelname(request.model)
-    response = ModelClass().create_chat_response(request)
-    return response
-
+    response = ModelClass().do_request(request)
+    return response

gemini_api.py

@@ -1,12 +1,50 @@
-from openai_model import TextCompletionRequest, TextCompletionResponse, ChatCompletionRequest, TbsChatCompletionRequest
+# gemini 的 api 文档地址： 
+
+from openai_model import TextCompletionRequest
 import google.generativeai as genai
 import uuid, time
-# from google.generativeai import BaseGenerateContentResponse
 
 class gemini:
     def __init__(self):
         pass
-        # print("gemini instance created!")
+    
+    def do_request(self, request):
+        model = genai.GenerativeModel(request.model)
+        messages=request.messages
+        if not messages:
+            return "No messages provided"
+        if messages[0]["role"] == 'system':
+            messages[0]["role"]='user'
+            content=messages[0]["content"]
+            messages[0]["content"] = f"系统消息：{content}"
+        message = messages[-1]
+        history=messages
+        history.pop()
+        converted_history = [{'role': msg['role'], 'parts': msg['content']} for msg in messages ]
+
+        chat = model.start_chat(history=converted_history)
+        gemini_response = chat.send_message(message["content"])
+        response = {
+            "candidates":[
+                {
+                    "content": {
+                        "parts": [
+                            {
+                                "text": gemini_response.candidates[0].content.parts[0].text
+                            }
+                        ]
+                    }
+                }
+            ],
+            "usage_metadata": {
+                "promptTokenCount": gemini_response.usage_metadata.prompt_token_count,
+                "candidatesTokenCount": gemini_response.usage_metadata.candidates_token_count,
+                "totalTokenCount": gemini_response.usage_metadata.total_token_count
+
+            }
+        }
+        return response
+
 
     def create_text_completion(self, request: TextCompletionRequest):
         model = genai.GenerativeModel(request.model)
@@ -32,110 +70,4 @@ class gemini:
 		    }
 	    }
         return response
-    
-    def create_chat_response(self, request: TbsChatCompletionRequest):
-        print('request',request)
-        model=request.model
-        system=request.system
-        prompt=request.prompt
-        messages=request.messages
-
-        combined_history = []
-        if messages and (len(messages) > 0):
-            for message in messages:
-                # 检查 'role' 是否等于 'system'，如果是，则将其更改为 'user'
-                role = 'user' if message['role'] == 'system' else message['role']
-                combined_history.append({
-                    "role": role,
-                    "parts": [message['content']]
-                })
-        if system:
-            combined_history.append({"role": "user", "parts": [system]})
-        print('combined_history',combined_history)
-
-        
-        model = genai.GenerativeModel(request.model)
-        chat = model.start_chat(history=combined_history)
-        gemini_response = chat.send_message(prompt)
-        # print(f"\n\ngemini_response\n{gemini_response}")
-
-        response = {
-            "id": f"cmpl-{uuid.uuid4()}",
-            "object": "chat.completion",
-            "created": int(time.time()),
-            "model": request.model,
-            "choices": [
-                {
-                    "message": {
-                        "role": "assistant", "content": f"\n\n{gemini_response.candidates[0].content.parts[0].text}"
-                    },
-                    "index": gemini_response.candidates[0].index,
-                    "logprobs": None,
-                    "finish_reason": gemini_response.candidates[0].finish_reason
-                }
-            ],
-            "usage": {
-			    "prompt_tokens": gemini_response.usage_metadata.prompt_token_count,
-			    "completion_tokens": gemini_response.usage_metadata.candidates_token_count,
-			    "total_tokens": gemini_response.usage_metadata.total_token_count 
-            }
-        }
-        return response
-    
-
-
-"""
-{
-    "model": 'gemini-1.5-flash',
-    "system": '你的角色是一个超级厉害的提示词工程师，当有人问你是谁时，你就说你是一个超级厉害的提示词工程师就可以。',
-    "prompt": '请介绍你自己',
-    "messages": [
-        {
-            'role': 'user',
-            'content': '你是一个专业的提示词专家，如果有人问你，你是谁的时候，你就说你是专业的提示词专家'
-        }, 
-        {
-            'role': 'user', 
-            'content': '你是谁？'
-        }, 
-        {'role': 'model', 
-            'content': '我是一个专业的提示词专家'
-        }, 
-        {
-            'role': 'user', 
-            'content': '巴拉巴拉'
-        }
-    ]
-}
-combined_history = [
-    {
-        'role': 'user', 
-        'parts': [
-            '你的角色是一个超级厉害的提示词工程师，当有人问你是谁时，你就说你是一个超级厉害的提示词工程师就可以。'
-        ]
-    }, 
-    {'role': 'user', 
-        'parts': [
-            '你是一个专业的提示词专家，如果有人问你，你是谁的时候，你就说你是专业的提示词专家'
-        ]
-    }, 
-    {
-        'role': 'user', 
-        'parts': [
-            '你是谁？'
-        ]
-    }, 
-    {
-        'role': 'model', 
-        'parts': [
-            '我是一个专业的提示词专家'
-        ]
-    }, 
-    {
-        'role': 'user', 
-        'parts': [
-            '巴拉巴拉'
-        ]
-    }
-]
-"""
+    

openai_model.py

@@ -1,34 +1,25 @@
 from pydantic import BaseModel
 from typing import List, Optional
 
+# 注意：下面的代码，主要聚焦在ChatCompletion上，而不是TextCompletion上。
+
 # 请求和响应模型
 class TextCompletionRequest(BaseModel):
     model: str
     prompt: str
     
-class TextCompletionResponse(BaseModel):
-    text: str
-    model: str
-    candidates: List = []
+# class TextCompletionResponse(BaseModel):
+#     text: str
+#     model: str
+#     candidates: List = []
 
-class ChatCompletionRequest(BaseModel):
-    model: str
-    prompt: str
-    # messages: List[dict] | None = None
-    messages: Optional[List[dict]] = None
+# class ChatCompletionRequest(BaseModel):
+#     model: str
+#     prompt: str
+#     # messages: List[dict] | None = None
+#     messages: Optional[List[dict]] = None
 
-# 
-# ########## 【特殊设计注意】 ###########
-# 
-# 下面的数据结构类里包含了system 字符串，此设计和 OpenAI 不一致，
-# 当其为None 时，默认为空字符串，不改变 system 参数
-# 当其为 '' ，时，会清空 system 参数
-# 当其为正常字符串时，更新fastapi服务器上的system参数
-# 为了保证多次设置系统提示词时最新的信息优先生效，system参数会放到历史纪录的最末尾一条，
-# 而且存储时，system不存储到messages里，避免多次重复
-class TbsChatCompletionRequest(BaseModel):
+class AirsChatCompletionRequest(BaseModel):
     model: str
-    system: Optional[str] = None  # 设置可选，且默认值为 None
-    prompt: Optional[str] = '你好'
-    # messages: List[dict] | None = None
-    messages: Optional[List[dict]] = None
+    messages: List[dict]
+