Merge pull request #41 from studio-recoding/fix/case2

[fix] case 넘버와 함께 반환

Author: uommou

app/dto/openai_dto.py

@@ -5,4 +5,8 @@ class PromptRequest(BaseModel):
     prompt: str
 
 class ChatResponse(BaseModel):
-    ness: str
+    ness: str
+
+class ChatCaseResponse(BaseModel):
+    ness: str
+    case: int

app/prompt/openai_config.ini

@@ -1,4 +1,14 @@
 [NESS_NORMAL]
 TEMPERATURE     = 0
 MAX_TOKENS      = 2048
+MODEL_NAME      = gpt-3.5-turbo-1106
+
+[NESS_CASE]
+TEMPERATURE     = 0
+MAX_TOKENS      = 2048
+MODEL_NAME      = gpt-4
+
+[NESS_RECOMMENDATION]
+TEMPERATURE     = 0
+MAX_TOKENS      = 2048
 MODEL_NAME      = gpt-3.5-turbo-1106

app/routers/chat.py

@@ -7,7 +7,7 @@
 from langchain_community.chat_models import ChatOpenAI
 from langchain_core.prompts import PromptTemplate
 
-from app.dto.openai_dto import PromptRequest, ChatResponse
+from app.dto.openai_dto import PromptRequest, ChatResponse, ChatCaseResponse
 from app.prompt import openai_prompt
 
 import app.database.chroma_db as vectordb
@@ -26,15 +26,15 @@
 config = configparser.ConfigParser()
 config.read(CONFIG_FILE_PATH)
 
-@router.post("/case", status_code=status.HTTP_200_OK, response_model=ChatResponse)
-async def get_langchain_case(data: PromptRequest) -> ChatResponse:
+@router.post("/case", status_code=status.HTTP_200_OK, response_model=ChatCaseResponse)
+async def get_langchain_case(data: PromptRequest) -> ChatCaseResponse:
     # description: use langchain
 
-    config_normal = config['NESS_NORMAL']
+    config_chat = config['NESS_CHAT']
 
-    chat_model = ChatOpenAI(temperature=config_normal['TEMPERATURE'],  # 창의성 (0.0 ~ 2.0)
-                            max_tokens=config_normal['MAX_TOKENS'],  # 최대 토큰수
-                            model_name=config_normal['MODEL_NAME'],  # 모델명
+    chat_model = ChatOpenAI(temperature=config_chat['TEMPERATURE'],  # 창의성 (0.0 ~ 2.0)
+                            max_tokens=config_chat['MAX_TOKENS'],  # 최대 토큰수
+                            model_name=config_chat['MODEL_NAME'],  # 모델명
                             openai_api_key=OPENAI_API_KEY  # API 키
                             )
     question = data.prompt
@@ -48,28 +48,32 @@ async def get_langchain_case(data: PromptRequest) -> ChatResponse:
     print(case)
     case = int(case)
     if case == 1:
-        return await get_langchain_normal(data)
+        response = await get_langchain_normal(data)
 
     elif case == 2:
-        return await get_langchain_schedule(data)
+        response = await get_langchain_schedule(data)
 
     elif case == 3:
-        return await get_langchain_rag(data)
+        response = await get_langchain_rag(data)
 
     else:
         print("wrong case classification")
         # 적절한 HTTP 상태 코드와 함께 오류 메시지를 반환하거나, 다른 처리를 할 수 있습니다.
         raise HTTPException(status_code=400, detail="Wrong case classification")
 
+    return ChatCaseResponse(ness=response, case=case)
+
 
 # case 1 : normal
 #@router.post("/case/normal") # 테스트용 엔드포인트
-async def get_langchain_normal(data: PromptRequest) -> ChatResponse: # case 1 : normal
+async def get_langchain_normal(data: PromptRequest): # case 1 : normal
     print("running case 1")
     # description: use langchain
-    chat_model = ChatOpenAI(temperature=0,  # 창의성 (0.0 ~ 2.0)
-                            max_tokens=2048,  # 최대 토큰수
-                            model_name='gpt-3.5-turbo-1106',  # 모델명
+    config_normal = config['NESS_NORMAL']
+
+    chat_model = ChatOpenAI(temperature=config_normal['TEMPERATURE'],  # 창의성 (0.0 ~ 2.0)
+                            max_tokens=config_normal['MAX_TOKENS'],  # 최대 토큰수
+                            model_name=config_normal['MODEL_NAME'],  # 모델명
                             openai_api_key=OPENAI_API_KEY  # API 키
                             )
     question = data.prompt
@@ -82,16 +86,18 @@ async def get_langchain_normal(data: PromptRequest) -> ChatResponse: # case 1 :
     prompt = PromptTemplate.from_template(my_template)
     response = chat_model.predict(prompt.format(output_language="Korean", question=question))
     print(response)
-    return ChatResponse(ness=response)
+    return response
 
 # case 2 : 일정 생성
 #@router.post("/case/make_schedule") # 테스트용 엔드포인트
-async def get_langchain_schedule(data: PromptRequest) -> ChatResponse:
+async def get_langchain_schedule(data: PromptRequest):
     print("running case 2")
     # description: use langchain
-    chat_model = ChatOpenAI(temperature=0,  # 창의성 (0.0 ~ 2.0)
-                            max_tokens=2048,  # 최대 토큰수
-                            model_name='gpt-3.5-turbo-1106',  # 모델명
+    config_normal = config['NESS_NORMAL']
+
+    chat_model = ChatOpenAI(temperature=config_normal['TEMPERATURE'],  # 창의성 (0.0 ~ 2.0)
+                            max_tokens=config_normal['MAX_TOKENS'],  # 최대 토큰수
+                            model_name=config_normal['MODEL_NAME'],  # 모델명
                             openai_api_key=OPENAI_API_KEY  # API 키
                             )
     question = data.prompt
@@ -100,16 +106,18 @@ async def get_langchain_schedule(data: PromptRequest) -> ChatResponse:
     prompt = PromptTemplate.from_template(case2_template)
     response = chat_model.predict(prompt.format(output_language="Korean", question=question))
     print(response)
-    return ChatResponse(ness=response)
+    return response
 
 # case 3 : rag
 #@router.post("/case/rag") # 테스트용 엔드포인트
-async def get_langchain_rag(data: PromptRequest) -> ChatResponse:
+async def get_langchain_rag(data: PromptRequest):
     print("running case 3")
     # description: use langchain
-    chat_model = ChatOpenAI(temperature=0,  # 창의성 (0.0 ~ 2.0)
-                            max_tokens=2048,  # 최대 토큰수
-                            model_name='gpt-3.5-turbo-1106',  # 모델명
+    config_normal = config['NESS_NORMAL']
+
+    chat_model = ChatOpenAI(temperature=config_normal['TEMPERATURE'],  # 창의성 (0.0 ~ 2.0)
+                            max_tokens=config_normal['MAX_TOKENS'],  # 최대 토큰수
+                            model_name=config_normal['MODEL_NAME'],  # 모델명
                             openai_api_key=OPENAI_API_KEY  # API 키
                             )
     question = data.prompt
@@ -123,4 +131,4 @@ async def get_langchain_rag(data: PromptRequest) -> ChatResponse:
     prompt = PromptTemplate.from_template(case3_template)
     response = chat_model.predict(prompt.format(output_language="Korean", question=question, schedule=schedule))
     print(response)
-    return ChatResponse(ness=response)
+    return response

app/routers/recommendation.py

@@ -2,7 +2,7 @@
 import os
 
 from dotenv import load_dotenv
-from fastapi import APIRouter, Depends, status
+from fastapi import APIRouter, Depends, status, HTTPException
 from langchain_community.chat_models import ChatOpenAI
 from langchain_core.prompts import PromptTemplate
 
@@ -27,23 +27,28 @@
 
 @router.post("/main", status_code=status.HTTP_200_OK)
 async def get_recommendation(user_data: RecommendationMainRequestDTO) -> ChatResponse:
+    try:
+        # 모델
+        config_recommendation = config['NESS_RECOMMENDATION']
 
-    # 모델
-    chat_model = ChatOpenAI(temperature=0.5,  # 창의성 (0.0 ~ 2.0)
-                            max_tokens=2048,  # 최대 토큰수
-                            model_name='gpt-3.5-turbo-1106',  # 모델명
-                            openai_api_key=OPENAI_API_KEY  # API 키
-                            )
+        chat_model = ChatOpenAI(temperature=config_recommendation['TEMPERATURE'],  # 창의성 (0.0 ~ 2.0)
+                                max_tokens=config_recommendation['MAX_TOKENS'],  # 최대 토큰수
+                                model_name=config_recommendation['MODEL_NAME'],  # 모델명
+                                openai_api_key=OPENAI_API_KEY  # API 키
+                                )
 
-    # vectordb에서 유저의 정보를 가져온다.
-    schedule = await vectordb.db_recommendation_main(user_data)
+        # vectordb에서 유저의 정보를 가져온다.
+        schedule = await vectordb.db_recommendation_main(user_data)
 
-    print(schedule)
+        print(schedule)
 
-    # 템플릿
-    recommendation_template = openai_prompt.Template.recommendation_template
+        # 템플릿
+        recommendation_template = openai_prompt.Template.recommendation_template
 
-    prompt = PromptTemplate.from_template(recommendation_template)
-    result = chat_model.predict(prompt.format(output_language="Korean", schedule=schedule))
-    print(result)
-    return ChatResponse(ness=result)
+        prompt = PromptTemplate.from_template(recommendation_template)
+        result = chat_model.predict(prompt.format(output_language="Korean", schedule=schedule))
+        print(result)
+        return ChatResponse(ness=result)
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))