Merge pull request #22 from CodeHex16/fixes-bazzan-sprint15

Author: lucaribon

app/config.py

@@ -3,10 +3,10 @@
 
 
 class Settings(BaseSettings):
-    OPENAI_API_KEY: str = os.environ.get("OPENAI_API_KEY", "")
+    OPENAI_API_KEY: str = os.environ.get("OPENAI_API_KEY")
     DOCUMENTS_FOLDER: str = "documenti"
     VECTOR_DB_PROVIDER: str = "chroma"
-    VECTOR_DB_PERSIST_DIRECTORY: str = "chroma_db"
+    VECTOR_DB_DIRECTORY: str = "chroma_db"
     EMBEDDING_MODEL_NAME: str = "text-embedding-ada-002"
     LLM_MODEL_NAME: str = "gpt-4o-mini"
     LLM_PROVIDER: str = "openai"
@@ -16,24 +16,11 @@ class Settings(BaseSettings):
         Missione:
         Assistere gli utenti nell'esplorazione dei prodotti forniti dall'azienda, informarli sulle caratteristiche del prodotto e consigliane l'acquisto.
 
-        Tratti della personalità:
-        - Conoscenza: Fornisce risposte accurate dalla base di conoscenze.
-        - Amichevole: cordiale e disponibile.
-        - Trasparente: condivide solo informazioni convalidate.
-
-        Capacità:
-        - Educare: Spiegare i prodotti presenti, consigliarne i possibili usi, la storia dell'azienda e i suoi valori utilizzando la base di conoscenze.
-        - Assistere: Consigliare prodotti e fornire informazioni rigorosamente basate sui dati approvati.
-        - Ispirare: evidenziare i vantaggi e gli usi di ogni prodotto.
-        - Coinvolgere: Rispondere alle domande in modo chiaro ed educato, reindirizzando gli utenti al supporto se le risposte non sono disponibili.
-
-        Tono:
-        - Positivo, professionale e privo di gergo.
-        - Rispettoso ed empatico per garantire un'esperienza di supporto.
-
         Regole comportamentali:
-        - Utilizzare solo la base di conoscenze fornita.
+        - È essenziale che tu usi il più possibile le informazioni fornite dai documenti passati come contesto.
         - Se una risposta non è disponibile, informare l'utente e suggerire di consultare l'assistenza clienti.
+        - Sii chiaro ed elenca metodicamente le informazioni richieste.
+		- Non esprimere opinioni personali o fare supposizioni.
         - Non fornire informazioni personali.
         """
     CHUNK_SIZE: int = 400

app/main.py

@@ -1,6 +1,5 @@
 from fastapi import FastAPI
-from app.routes import llm
-from app.routes import documents
+from app.routes import llm, documents, faq
 
 app = FastAPI(
     title="LLM API",
@@ -10,3 +9,4 @@
 
 app.include_router(llm.router)
 app.include_router(documents.router)
+app.include_router(faq.router)

app/routes/documents.py

@@ -1,9 +1,7 @@
-from fastapi import APIRouter, Depends, HTTPException, File, UploadFile, Query
-from app.services.llm_service import LLM, OpenAI
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form, Depends
 from typing import List
 import os
 
-# from app.services.chroma_services import embedding
 from app.services.file_manager_service import (
     get_file_manager,
     get_file_manager_by_extension,
@@ -18,18 +16,17 @@
 )
 
 
-@router.post("/upload_file")
-async def upload_file(files: List[UploadFile] = File(...), token: str=Query(...)):
+@router.post("")
+async def upload_file(files: List[UploadFile], token: str):
     """
-    Carica il file nel database vettoriale
+    Carica il file nel database vettoriale.
 
-    Args:
-    - files (List[UploadFile]): I file da caricare. Devono essere file di testo o PDF.
+    ### Args:
+    * **files (List[UploadFile])**: I file da caricare. Devono essere file di testo o PDF.
 
-    Raises:
-    - HTTPException: Se il file non è valido o se si verifica un errore durante il caricamento.
-    - HTTPException: Se il file esiste già nel database vettoriale.
-    - HTTPException: Se si verifica un errore durante il caricamento e l'elaborazione del file.
+    ### Raises:
+    * **HTTPException.400_BAD_REQUEST**: Se non sono stati forniti file o se i file non sono di tipo testo o PDF.
+    * **HTTPException.500_INTERNAL_SERVER_ERROR**: Se si verifica un errore durante il caricamento dei file.
     """
 
     if not files:
@@ -97,59 +94,50 @@ async def upload_file(files: List[UploadFile] = File(...), token: str=Query(...)
         }
 
 
-@router.delete("/delete_file")
+@router.delete("")
 async def delete_file(fileDelete: schemas.DocumentDelete):
+    """
+    Elimina un file dal database.
+
+    ### Args:
+    * **fileDelete (schemas.DocumentDelete)**: Il file da eliminare. Deve contenere il titolo, il token e la password corrente.
+
+    ### Raises:
+    * **HTTPException.400_BAD_REQUEST**: Se il file non esiste o se si verifica un errore durante l'eliminazione.
+    * **HTTPException.500_INTERNAL_SERVER_ERROR**: Se si verifica un errore durante l'eliminazione del file.
+    """
     print("delete file title:", fileDelete)
-    file_manager = get_file_manager_by_extension(fileDelete.title)
-    if file_manager is None:
-        raise HTTPException(status_code=400, detail="File manager not found")
     try:
+        file_manager = get_file_manager_by_extension(fileDelete.title)
+        if file_manager is None:
+            raise HTTPException(status_code=400, detail="File manager not found")
+
         file_path = file_manager.get_full_path(fileDelete.title)
         print("file path:", file_path)
         await file_manager.delete_document(
             fileDelete.id, file_path, fileDelete.token, fileDelete.current_password
         )
-    except HTTPException as e:
-        match e.status_code:
-            case 404:
-                print("error detail:", e.detail)
-                raise HTTPException(
-                    status_code=404,
-                    detail="Document not found",
-                )
-            case 500:
-                print("error detail:", e.detail)
-                raise HTTPException(
-                    status_code=500,
-                    detail="Error in deleting file",
-                )
-            case _:
-                print("error detail:", e.detail)
-                raise HTTPException(
-                    status_code=500,
-                    detail="Error in deleting file",
-                )
 
+        return {"message": "File deleted successfully"}
+    except HTTPException as http_exc:
+        raise http_exc
     except Exception as e:
-        print("error detail:", e)
-        raise HTTPException(
-            status_code=500,
-            detail="Error in deleting file",
-        )
-
-    return {"message": "File deleted successfully"}
+        raise HTTPException(status_code=500, detail=f"Error in deleting file: {str(e)}")
 
 
-@router.get("/get_documents")
+@router.get("")
 def get_documents():
     """
-    Ottiene la lista dei documenti dal database.
+    Restituisce il numero di documenti e i loro nomi.
 
-    Args:
-    - token (str): Il token di autenticazione dell'utente.
-
-    Raises:
-    - HTTPException: Se si verifica un errore durante il recupero dei documenti.
+    ### Returns:
+    * **int**: Il numero di documenti.
+    * **List[str]**: I nomi dei documenti.
+    * **List[str]**: I nomi dei file nella directory /data/documents.
     """
-
-    return os.listdir("/data/documents")
+    file_manager = get_file_manager()
+    return (
+        file_manager.get_documents_number(),
+        file_manager.get_documents(),
+        os.listdir("/data/documents"),
+    )

app/routes/faq.py

@@ -0,0 +1,87 @@
+from fastapi import APIRouter, HTTPException
+
+from app.services.file_manager_service import (
+    get_file_manager_by_extension,
+)
+
+import app.schemas as schemas
+
+
+router = APIRouter(
+    tags=["faqs"],
+    prefix="/faqs",
+)
+
+
+@router.post("")
+async def create_faq(faq: schemas.FAQBase, token: str):
+    """
+    Crea una nuova FAQ.
+
+    ### Args:
+    * **faq (schemas.FAQCreate)**: I dati della FAQ da creare.
+    * **token (str)**: Il token di autenticazione.
+
+    ### Raises:
+    * **HTTPException.400_BAD_REQUEST**: Se non sono stati forniti dati per la creazione della FAQ.
+    * **HTTPException.500_INTERNAL_SERVER_ERROR**: Se si verifica un errore durante la creazione della FAQ.
+    """
+    if not faq:
+        raise HTTPException(status_code=400, detail="No data provided for creation")
+
+    file_manager = get_file_manager_by_extension()
+    if file_manager is None:
+        raise HTTPException(status_code=500, detail="File manager not found")
+
+    faq_db = await file_manager.add_faq(faq, token)
+
+    return {"faq": faq_db, "message": "FAQ created successfully"}
+
+
+@router.delete("")
+async def delete_faq(faq: schemas.FAQDelete, token: str):
+    """
+    Elimina una FAQ esistente.
+
+    ### Args:
+    * **faq (schemas.FAQDelete)**: I dati della FAQ da eliminare.
+
+    ### Raises:
+    * **HTTPException.400_BAD_REQUEST**: Se non sono stati forniti dati per l'eliminazione.
+    * **HTTPException.404_NOT_FOUND**: Se la FAQ non esiste.
+    * **HTTPException.500_INTERNAL_SERVER_ERROR**: Se si verifica un errore durante l'eliminazione della FAQ.
+    """
+    if not faq:
+        raise HTTPException(status_code=400, detail="No data provided for deletion")
+
+    file_manager = get_file_manager_by_extension()
+    if file_manager is None:
+        raise HTTPException(status_code=500, detail="File manager not found")
+
+    await file_manager.delete_faq(faq, token)
+    return {"message": "FAQ deleted successfully"}
+
+
+@router.put("")
+async def update_faq(faq: schemas.FAQ, token: str):
+    """
+    Aggiorna una FAQ esistente.
+
+    ### Args:
+    * **faq (schemas.FAQUpdate)**: I dati della FAQ da aggiornare.
+    * **faq_id (str)**: L'ID della FAQ da aggiornare.
+
+    ### Raises:
+    * **HTTPException.400_BAD_REQUEST**: Se non sono stati forniti dati per l'aggiornamento.
+    * **HTTPException.404_NOT_FOUND**: Se la FAQ non esiste.
+    * **HTTPException.500_INTERNAL_SERVER_ERROR**: Se si verifica un errore durante l'aggiornamento della FAQ.
+    """
+    if not faq:
+        raise HTTPException(status_code=400, detail="No data provided for update")
+
+    file_manager = get_file_manager_by_extension()
+    if file_manager is None:
+        raise HTTPException(status_code=500, detail="File manager not found")
+
+    faq_db = await file_manager.update_faq(faq, token)
+    return {"faq": faq_db, "message": "FAQ updated successfully"}

app/routes/llm.py

@@ -1,8 +1,5 @@
 from fastapi import APIRouter, Depends, HTTPException
-from app.services.llm_service import LLM, OpenAI
 
-# from app.services.chroma_services import embedding
-from app.services.vector_database_service import get_vector_database
 from app.services.llm_response_service import LLMResponseService, get_llm_response_service
 
 import app.schemas as schemas
@@ -19,48 +16,43 @@ async def generate_chat_response(
     """
     Fornisce una risposta a una domanda utilizzando il contesto rilevante.
 
-    *Args*:
-        question (schemas.Question): La domanda e lo storico dei messaggi.
-        chat_service: Servizio di chat per generare risposte.
+    ### Args:
+        * **question (schemas.Question)**: La domanda e lo storico dei messaggi.
 
-    *Returns*:
-        La risposta generata dal modello LLM.
+    ### Returns:
+        * **response**: La risposta generata dal modello LLM.
 
-    *Raises*:
-        HTTPException: Se non viene fornita una domanda valida.
+    ### Raises:
+        * **HTTPException.404_NOT_FOUND**: Se non viene trovato alcun contesto rilevante.
+        * **HTTPException.400_BAD_REQUEST**: Se non viene fornita alcuna domanda.
+        * **HTTPException.500_INTERNAL_SERVER_ERROR**: Se si verifica un errore interno del server.
     """
     if not question.question or question.question.strip() == "":
         raise HTTPException(status_code=400, detail="Nessuna domanda fornita")
-        
+
     return llm_response_service.generate_llm_response(question)
 
 
 @router.post("/chat_name")
 async def generate_chat_name(
-    context: schemas.Context
+    context: schemas.Context, llm_response_service: LLMResponseService = Depends(get_llm_response_service)
 ):
-    """ "
-    Genera un nome per una chat.
+    """
+    Genera un nome per la chat in base al contesto fornito.
+
+    ### Args:
+        * **context (schemas.Context)**: Il contesto della chat.
+    
+    ### Returns:
+        * **response**: Il nome generato per la chat.
 
-    *Args*:
-        context (schemas.Context): Il contesto della chat.
-    *Returns*:
-        str: Il nome generato per la chat.
-    *Raises*:
-        HTTPException: Se non viene fornito un contesto valido.
+    ### Raises:
+        * **HTTPException.400_BAD_REQUEST**: Se non viene fornito alcun contesto.
+        * **HTTPException.500_INTERNAL_SERVER_ERROR**: Se si verifica un errore interno del server.
     """
     if not context.context:
         raise HTTPException(status_code=400, detail="Nessun contesto fornito")
 
-    llm_response_service = get_llm_response_service() 
     return llm_response_service.generate_llm_chat_name(
         context.context
-    )
-
-
-@router.get("/ping")
-async def ping():
-    import requests
-
-    ris = requests.get("https://www.google.com")
-    return {"status": "ok", "message": ris.text}
+    )