Update private_gpt/launcher.py

private_gpt/launcher.py

@@ -2,10 +2,11 @@
 import logging
 from typing import Any
 
-from fastapi import Depends, FastAPI, Request
+from fastapi import Depends, FastAPI, Request, status, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.openapi.utils import get_openapi
 from injector import Injector
+from fastapi import APIRouter
 
 from private_gpt.paths import docs_path
 from private_gpt.server.chat.chat_router import chat_router
@@ -14,7 +15,21 @@ from private_gpt.server.completions.completions_router import completions_router
 from private_gpt.server.embeddings.embeddings_router import embeddings_router
 from private_gpt.server.health.health_router import health_router
 from private_gpt.server.ingest.ingest_router import ingest_router
+from private_gpt.server.utils import authentication
 from private_gpt.settings.settings import Settings
+from private_gpt.components.llm.llm_component import LLMComponent
+
+#databse for user authentication integration
+from private_gpt.server.utils import models 
+#from private_gpt.server.utils.database import engine, SessionLocal
+from typing import Annotated
+from sqlalchemy.orm import Session
+from private_gpt.server.utils.authentication import get_current_user
+
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2AuthorizationCodeBearer
+
+
 
 logger = logging.getLogger(__name__)
 
@@ -66,21 +81,49 @@ def create_app(root_injector: Injector) -> FastAPI:
             request.state.injector = root_injector
 
         app = FastAPI(dependencies=[Depends(bind_injector_to_request)])
+        
+
+        model_router = APIRouter(prefix ='/v1',dependencies=[Depends(get_current_user)])
+
+        @model_router.post("/switch_model")
+        async def switch_model(
+            new_model: str, current_user: dict = Depends(get_current_user)
+        ):
+            # Check if the user has the "admin" role
+            if "admin" not in current_user.get("role", []):
+                raise HTTPException(
+                    status_code=status.HTTP_403_FORBIDDEN,
+                    detail="You are not an admin and cannot use this API.",
+                )
+
+            #logic to switch the LLM model based on the user's request
+            
+            llm_component = root_injector.get(LLMComponent)
+            llm_component.switch_model(new_model, settings=settings)
+
+            return {"message": f"Model switched to {new_model}"}
+
+        # @model_router.post("/switch_model")
+        # async def switch_model(new_model: str):
+        #     # Implement logic to switch the LLM model based on the user's request
+        #     # Example: Change the LLM model in LLMComponent based on the new_model parameter
+        #     llm_component = root_injector.get(LLMComponent)
+        #     llm_component.switch_model(new_model, settings=settings)
+
+        #     return {"message": f"Model switched to {new_model}"}
+
 
         def custom_openapi() -> dict[str, Any]:
             if app.openapi_schema:
                 return app.openapi_schema
             openapi_schema = get_openapi(
-                title="PrivateGPT",
+                title="Invenxion-Chatbot",
                 description=description,
                 version="0.1.0",
-                summary="PrivateGPT is a production-ready AI project that allows you to "
+                summary="This is a production-ready AI project that allows you to "
                 "ask questions to your documents using the power of Large Language "
                 "Models (LLMs), even in scenarios without Internet connection. "
                 "100% private, no data leaves your execution environment at any point.",
-                contact={
-                    "url": "https://github.com/imartinez/privateGPT",
-                },
                 license_info={
                     "name": "Apache 2.0",
                     "url": "https://www.apache.org/licenses/LICENSE-2.0.html",
@@ -99,16 +142,34 @@ def create_app(root_injector: Injector) -> FastAPI:
 
         app.openapi = custom_openapi  # type: ignore[method-assign]
 
+        #models.Base.metadata.create_all(bind=engine)
+
+        # def get_db():
+        #     db = SessionLocal()
+        #     try:
+        #         yield db
+        #     finally:
+        #         db.close()
+
+        #db_dependency = Annotated[Session, Depends(get_db)]
+        #user_dependency = Annotated[dict, Depends(get_current_user)]
+
+        @app.get("/v1/", status_code=status.HTTP_200_OK)
+        async def user(current_user: dict = Depends(get_current_user)):
+            if current_user is None:
+                raise HTTPException(status_code=401, detail="Authentication Failed")
+            return {"User": current_user}
+
+        
+        app.include_router(authentication.router)
+
         app.include_router(completions_router)
         app.include_router(chat_router)
         app.include_router(chunks_router)
         app.include_router(ingest_router)
         app.include_router(embeddings_router)
         app.include_router(health_router)
-
-        @app.get("/")
-        async def root():
-            return {"message": "Chatbot API"}
+        app.include_router(model_router)
 
         settings = root_injector.get(Settings)
         if settings.server.cors.enabled:
@@ -121,7 +182,6 @@ def create_app(root_injector: Injector) -> FastAPI:
                 allow_methods=settings.server.cors.allow_methods,
                 allow_headers=settings.server.cors.allow_headers,
             )
-            
 
         if settings.ui.enabled:
             logger.debug("Importing the UI module")
@@ -130,6 +190,4 @@ def create_app(root_injector: Injector) -> FastAPI:
             ui = root_injector.get(PrivateGptUi)
             ui.mount_in_app(app, settings.ui.path)
 
-
-
         return app