feat: BMDB integration, system prompt split, LLM speed-ups, dual-DB UI

backend/app/controllers/bmdb_controller.py

@@ -0,0 +1,54 @@
+import httpx
+from typing import List
+from fastapi import HTTPException, Response
+from app.schemas.bmdb_schema import BMDBRequestParams
+from app.services.databases_service import (
+    get_xml_file,
+    fetch_bmdb_models,
+    get_bmdb_model_info,
+)
+
+
+async def get_bmdb_models_controller(params: BMDBRequestParams) -> dict:
+    """
+    Controller function to retrieve biomodels based on filters and sorting.
+    Raises:
+        HTTPException: If the BMDB API request fails.
+    """
+    try:
+        biomodels = await fetch_bmdb_models(params)
+        return biomodels
+    except httpx.HTTPStatusError as e:
+        raise HTTPException(
+            status_code=e.response.status_code, detail="Error fetching biomodels."
+        )
+    except httpx.RequestError as e:
+        raise HTTPException(
+            status_code=500, detail="Error communicating with BMDB API."
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def get_xml_controller(bmdbID: str, truncate: bool = False) -> str:
+    """
+    Controller function to fetch the contents of the XML file for a bmdb biomodel.
+    Raises:
+        HTTPException: If the URL cannot be generated.
+    """
+    try:
+        return await get_xml_file(bmdbID, truncate)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail="Error fetching XML file.")
+
+
+async def get_bmdb_model_info_controller(bmdbID: str) -> dict:
+    """
+    Controller function to fetch information about a specific BMDB model.
+    Raises:
+        HTTPException: If the URL cannot be generated.
+    """
+    try:
+        return await get_bmdb_model_info(bmdbID)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail="Error fetching BMDB model info.")

backend/app/controllers/llms_controller.py

@@ -7,7 +7,7 @@
 )
 
 
-async def get_llm_response(conversation_history: list[dict]) -> tuple[str, list]:
+async def get_llm_response(conversation_history: list[dict], database: str) -> tuple[str, list]:
     """
     Controller function to interact with the LLM service.
     Args:
@@ -16,8 +16,9 @@ async def get_llm_response(conversation_history: list[dict]) -> tuple[str, list]
         tuple[str, list]: A tuple containing the final response and bmkeys list.
     """
     try:
-        result, bmkeys = await get_response_with_tools(conversation_history)
-        return result, bmkeys
+        print("DEBUG20: BMDB POST: get_llm_response")
+        result, bmkeys, tool_summary = await get_response_with_tools(conversation_history, database)
+        return result, bmkeys, tool_summary
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
 

backend/app/controllers/vcelldb_controller.py

@@ -2,7 +2,7 @@
 from typing import List
 from fastapi import HTTPException, Response
 from app.schemas.vcelldb_schema import BiomodelRequestParams, SimulationRequestParams
-from app.services.vcelldb_service import (
+from app.services.databases_service import (
     fetch_biomodels,
     fetch_simulation_details,
     get_vcml_file,
@@ -21,7 +21,9 @@ async def get_biomodels_controller(params: BiomodelRequestParams) -> dict:
         HTTPException: If the VCell API request fails.
     """
     try:
+        print("About to call fetch_biomodels()")
         biomodels = await fetch_biomodels(params)
+        print("fetch_biomodels() completed successfully")
         return biomodels
     except httpx.HTTPStatusError as e:
         raise HTTPException(
@@ -142,7 +144,9 @@ async def get_publications_controller() -> List[dict]:
         HTTPException: If the VCell API request fails.
     """
     try:
+        print("About to call fetch_publications()")
         publications = await fetch_publications()
+        print("fetch_publications() completed successfully")
         return publications
     except httpx.HTTPStatusError as e:
         raise HTTPException(

backend/app/core/config.py

@@ -1,4 +1,4 @@
-from pydantic_settings import BaseSettings
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
 class Settings(BaseSettings):
@@ -24,4 +24,10 @@ class Settings(BaseSettings):
     LANGFUSE_PUBLIC_KEY: str
     LANGFUSE_HOST: str
 
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
 settings = Settings()

backend/app/main.py

@@ -14,6 +14,7 @@
 from app.routes.llms_router import router as llms_router
 from app.routes.qdrant_router import router as qdrant_router
 from app.routes.knowledge_base_router import router as knowledge_base_router
+from app.routes.bmdb_router import router as bmdb_router
 
 ascii_art = """
 ╔════════════════════════════════════════════════════════════════════════════════════╗
@@ -54,6 +55,7 @@ async def startup_event():
 # Including the routers
 app.include_router(knowledge_base_router, tags=["Knowledge Base"], prefix="/kb")
 app.include_router(llms_router, tags=["LLM with Tool Calling"])
+app.include_router(bmdb_router, tags=["BMDB API Wrapper"])
 app.include_router(vcelldb_router, tags=["VCellDB API Wrapper"])
 app.include_router(qdrant_router, tags=["Qdrant Vector DB"], prefix="/qdrant")
 

backend/app/routes/bmdb_router.py

@@ -0,0 +1,42 @@
+from fastapi import APIRouter, Depends, HTTPException
+from app.schemas.bmdb_schema import BMDBRequestParams
+from app.controllers.bmdb_controller import (
+    get_bmdb_models_controller,
+    get_xml_controller,
+    get_bmdb_model_info_controller,
+)
+
+router = APIRouter()
+
+
+@router.get("/search", response_model=dict)
+async def get_biomodels(params: BMDBRequestParams = Depends()):
+    """
+    Endpoint to retrieve bmdb models based on provided parameters.
+    """
+    try:
+        return await get_bmdb_models_controller(params)
+    except HTTPException as e:
+        raise e
+
+
+@router.get("/get-xml", response_model=str)
+async def get_xml(bmdbID: str, truncate: bool = False):
+    """
+    Endpoint to get XML file contents for a given biomodel.
+    """
+    try:
+        return await get_xml_controller(bmdbID, truncate)
+    except HTTPException as e:
+        raise e
+
+
+@router.get("/model-info", response_model=dict)
+async def get_model_info(bmdbID: str):
+    """
+    Endpoint to get information about a specific BMDB model.
+    """
+    try:
+        return await get_bmdb_model_info_controller(bmdbID)
+    except HTTPException as e:
+        raise e

backend/app/routes/llms_router.py

@@ -1,4 +1,10 @@
-from fastapi import APIRouter
+from multiprocessing import process
+from fastapi import APIRouter, Depends, HTTPException, Response
+from typing import List
+from app.schemas.bmdb_schema import BMDBRequestParams
+from app.schemas.vcelldb_schema import BiomodelRequestParams
+import httpx
+import requests
 from app.controllers.llms_controller import (
     get_llm_response,
     analyse_biomodel_controller,
@@ -8,20 +14,40 @@
 
 router = APIRouter()
 
+# For BioModelsDB search using BioModelsDB API 
+@router.post("/bmdb-search")
+async def search_llm(conversation_history: dict):
+    """
+    Endpoint to query the LLM and execute the necessary tools.
+    Args:
+        conversation_history (dict): The conversation history containing user prompts and responses.
+        database (str): The database to query - bmdb in this case.
+    Returns:
+        dict: The final response after processing the prompt with the tools.
+    """
+
+    print("DEBUG20: BMDB POST: ROUTER")
+    result, bmdbkeys, tool_summary = await get_llm_response(
+        conversation_history.get("conversation_history", []), database="bmdb"
+    )
+    return {"response": result, "bmkeys": bmdbkeys, "tool_summary": tool_summary}
+
+
 
 @router.post("/query")
 async def query_llm(conversation_history: dict):
     """
     Endpoint to query the LLM and execute the necessary tools.
     Args:
         conversation_history (dict): The conversation history containing user prompts and responses.
+        database (str): The database to query - vcdb in this case.
     Returns:
         dict: The final response after processing the prompt with the tools.
     """
-    result, bmkeys = await get_llm_response(
-        conversation_history.get("conversation_history", [])
+    result, bmkeys, tool_summary = await get_llm_response(
+        conversation_history.get("conversation_history", []), database="vcdb"
     )
-    return {"response": result, "bmkeys": bmkeys}
+    return {"response": result, "bmkeys": bmkeys, "tool_summary": tool_summary}
 
 
 @router.post("/analyse/{biomodel_id}")

backend/app/schemas/bmdb_schema.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel
+from typing import Optional
+from datetime import date
+from enum import Enum
+
+
+class CategoryEnum(str, Enum):
+    all = "all"
+    public = "public"
+    shared = "shared"
+    tutorials = "tutorial"
+    educational = "educational"
+
+
+class OrderByEnum(str, Enum):
+    date_desc = "date_desc"
+    date_asc = "date_asc"
+    name_desc = "name_desc"
+    name_asc = "name_asc"
+
+
+# Biomodel Request Parameters schema
+class BMDBRequestParams(BaseModel, use_enum_values=True):
+    bmName: Optional[str] = ""  # Name of the biomodel to search for
+    bmId: Optional[str] = ""  # Biomodel ID

backend/app/schemas/vcelldb_schema.py

@@ -33,7 +33,6 @@ class BiomodelRequestParams(BaseModel, use_enum_values=True):
         OrderByEnum.date_desc
     )  # Order of results (default is "date_desc")
 
-
 class SimulationRequestParams(BaseModel):
     bmId: str  # Biomodel ID for which simulations will be fetched
     simId: str  # Simulation ID to fetch specific simulation details