Merge branch '236-langchain-mcp-export' of https://github.com/oracle-samples/ai-optimizer into 236-langchain-mcp-export

Author: corradodebari

.github/workflows/pytest.yml

@@ -50,7 +50,7 @@ jobs:
         run: |
           cd src/
           python -m pip install --upgrade pip wheel setuptools
-          pip install torch==2.7.1+cpu -f https://download.pytorch.org/whl/cpu/torch
+          pip install torch==2.8.0+cpu -f https://download.pytorch.org/whl/cpu/torch
           pip install -e ".[all-test]"
 
       - name: Run All Tests

docs/content/client/configuration/model_config.md

@@ -89,14 +89,14 @@ To use OCI GenAI, the {{< short_app_ref >}} must be configured for [OCI access](
 >[!code]Skip the GUI!
 >You can set the following environment variables to automatically enable OCI GenAI models:
 >```shell
->export OCI_GENAI_SERVICE_ENDPOINT=<OCI GenAI Service Endpoint>
+>export OCI_GENAI_REGION=<OCI GenAI Service Region>
 >export OCI_GENAI_COMPARTMENT_ID=<OCI Compartment OCID of the OCI GenAI Service>
 >```
 >
 >Alternatively, you can specify the following in the `~/.oci/config` configfile under the appropriate OCI profile:
 >```shell
->service_endpoint=<OCI GenAI Service Endpoint>
->compartment_id=<OCI Compartment OCID of the OCI GenAI Service>
+>genai_compartment_id=<OCI Compartment OCID of the OCI GenAI Service>
+>genai_region=<OCI GenAI Region>
 >```
 
 {{% /tab %}}

docs/content/client/configuration/oci_config.md

@@ -42,8 +42,8 @@ Depending on the runtime environment, either [Bare Metal](#bare-metal) or [Conta
 
 In addition to the standard configuration file, two additional entries are required to enable OCI GenAI Services:
 
-- **service_endpoint**: the URL endpoint for the OCI GenAI Service
-- **compartment_id**: the compartment OCID of the OCI GenAI Service
+- **genai_region**: the Region for the OCI GenAI Service
+- **genai_compartment_id**: the Compartment OCID of the OCI GenAI Service
 
 #### Bare Metal
 

opentofu/modules/vm/templates/cloudinit-compute.tpl

@@ -65,7 +65,7 @@ write_files:
       python3.11 -m venv .venv
       source .venv/bin/activate
       pip3.11 install --upgrade pip wheel setuptools
-      pip3.11 install torch==2.7.1+cpu -f https://download.pytorch.org/whl/cpu/torch
+      pip3.11 install torch==2.8.0+cpu -f https://download.pytorch.org/whl/cpu/torch
       pip3.11 install -e ".[all]" --quiet --no-input &
       INSTALL_PID=$!
 

src/Dockerfile

@@ -24,7 +24,7 @@ RUN for dir in server client common; do \
 COPY pyproject.toml /opt/package/pyproject.toml
 # Use the virtual environment for pip installations
 RUN /opt/.venv/bin/pip install --upgrade pip wheel setuptools && \
-    /opt/.venv/bin/pip install torch==2.7.1+cpu -f https://download.pytorch.org/whl/cpu/torch && \
+    /opt/.venv/bin/pip install torch==2.8.0+cpu -f https://download.pytorch.org/whl/cpu/torch && \
     /opt/.venv/bin/pip install --no-cache-dir "/opt/package[all]"
 
 ##################################################

src/client/content/config/models.py

@@ -30,6 +30,19 @@
 ###################################
 # Functions
 ###################################
+def clear_client_models(model_id: str) -> None:
+    """Clear selected models from client settings if modified"""
+    model_keys = [
+        ("ll_model", "model"),
+        ("testbed", "judge_model"),
+        ("testbed", "qa_ll_model"),
+        ("testbed", "qa_embed_model"),
+    ]
+    for section, key in model_keys:
+        if state.client_settings[section][key] == model_id:
+            state.client_settings[section][key] = None
+
+
 def get_models(force: bool = False) -> None:
     """Get Models from API Server"""
     if force or "model_configs" not in state or not state.model_configs:
@@ -58,6 +71,9 @@ def patch_model(model: dict) -> None:
     """Update Model Configuration for either Language Models or Embed Models"""
     _ = api_call.patch(endpoint=f"v1/models/{model['id']}", payload={"json": model})
     st.success(f"Model updated: {model['id']}")
+    # If updated model is the set model and not enabled: unset the user settings
+    if not model["enabled"]:
+        clear_client_models(model["id"])
 
 
 def delete_model(model_id: str) -> None:
@@ -66,8 +82,7 @@ def delete_model(model_id: str) -> None:
     st.success(f"Model deleted: {model_id}")
     sleep(1)
     # If deleted model is the set model; unset the user settings
-    if state.client_settings["ll_model"]["model"] == model_id:
-        state.client_settings["ll_model"]["model"] = None
+    clear_client_models(model_id)
 
 
 @st.dialog("Model Configuration", width="large")
@@ -93,6 +108,7 @@ def edit_model(model_type: str, action: Literal["add", "edit"], model_id: str =
         )
         api_values = get_model_apis(model_type)
         api_index = next((i for i, item in enumerate(api_values) if item == model["api"]), None)
+        disable_for_oci = model["api"] in ["ChatOCIGenAI", "OCIGenAIEmbeddings"]
         model["api"] = st.selectbox(
             "API (Required):",
             help=help_text.help_dict["model_api"],
@@ -107,13 +123,15 @@ def edit_model(model_type: str, action: Literal["add", "edit"], model_id: str =
             help=help_text.help_dict["model_api_url"],
             key="add_model_api_url",
             value=model.get("url", ""),
+            disabled=disable_for_oci
         )
         model["api_key"] = st.text_input(
             "API Key:",
             help=help_text.help_dict["model_api_key"],
             key="add_model_api_key",
             type="password",
             value=model.get("api_key", ""),
+            disabled=disable_for_oci
         )
         if model_type == "ll":
             model["context_length"] = st.number_input(
@@ -186,7 +204,7 @@ def edit_model(model_type: str, action: Literal["add", "edit"], model_id: str =
 
 def render_model_rows(model_type):
     """Render rows of the models"""
-    data_col_widths = [0.05, 0.25, 0.2, 0.28, 0.12]
+    data_col_widths = [0.07, 0.23, 0.2, 0.28, 0.12]
     table_col_format = st.columns(data_col_widths, vertical_alignment="center")
     col1, col2, col3, col4, col5 = table_col_format
     col1.markdown("​", help="Active", unsafe_allow_html=True)
@@ -198,7 +216,7 @@ def render_model_rows(model_type):
         model_id = model["id"]
         col1.text_input(
             "Enabled",
-            value="✅" if model["enabled"] else "⚪",
+            value=st_common.bool_to_emoji(model["enabled"]),
             key=f"{model_type}_{model_id}_enabled",
             label_visibility="collapsed",
             disabled=True,

src/client/content/config/oci.py

@@ -8,7 +8,7 @@
 # spell-checker:ignore streamlit, ocid, selectbox, genai, oraclecloud
 
 import inspect
-import re
+import pandas as pd
 
 import streamlit as st
 from streamlit import session_state as state
@@ -36,7 +36,21 @@ def get_oci(force: bool = False) -> None:
             state.oci_configs = {}
 
 
-def patch_oci(auth_profile: str, supplied: dict, namespace: str) -> bool:
+def get_genai_models() -> list[dict]:
+    """Get Subscribed OCI Regions"""
+    endpoint = f"v1/oci/genai/{state.client_settings['oci']['auth_profile']}"
+    genai_models = api_call.get(endpoint=endpoint)
+    return genai_models
+
+
+def create_genai_models() -> list[dict]:
+    """Create OCI GenAI Models"""
+    endpoint = f"v1/oci/genai/{state.client_settings['oci']['auth_profile']}"
+    genai_models = api_call.post(endpoint=endpoint)
+    return genai_models
+
+
+def patch_oci(auth_profile: str, supplied: dict, namespace: str, toast: bool = True) -> bool:
     """Update OCI"""
     rerun = False
     # Check if the OIC configuration is changed, or no namespace
@@ -49,19 +63,15 @@ def patch_oci(auth_profile: str, supplied: dict, namespace: str) -> bool:
                 supplied["authentication"] = "security_token"
 
             with st.spinner(text="Updating OCI Profile...", show_time=True):
-                _ = api_call.patch(
-                    endpoint=f"v1/oci/{auth_profile}",
-                    payload={"json": supplied},
-                )
+                _ = api_call.patch(endpoint=f"v1/oci/{auth_profile}", payload={"json": supplied}, toast=toast)
             logger.info("OCI Profile updated: %s", auth_profile)
         except api_call.ApiError as ex:
             logger.error("OCI Update failed: %s", ex)
             state.oci_error = ex
         st_common.clear_state_key("oci_configs")
-        if supplied.get("service_endpoint"):
-            st_common.clear_state_key("model_configs")
     else:
-        st.toast("No Changes Detected.", icon="ℹ️")
+        if toast:
+            st.toast("No Changes Detected.", icon="ℹ️")
 
     return rerun
 
@@ -155,31 +165,54 @@ def main() -> None:
         OCI Authentication must be configured above.
         """)
     with st.container(border=True):
-        supplied["compartment_id"] = st.text_input(
+        if "genai_models" not in state:
+            state.genai_models = []
+        supplied["genai_compartment_id"] = st.text_input(
             "OCI GenAI Compartment OCID:",
-            value=oci_lookup[selected_oci_auth_profile]["compartment_id"],
+            value=oci_lookup[selected_oci_auth_profile]["genai_compartment_id"],
             placeholder="Compartment OCID for GenAI Services",
             key="oci_genai_compartment_id",
             disabled=not namespace,
         )
-        match = re.search(
-            r"\.([a-zA-Z\-0-9]+)\.oci\.oraclecloud\.com", oci_lookup[selected_oci_auth_profile]["service_endpoint"]
-        )
-        supplied["service_endpoint"] = match.group(1) if match else None
-        supplied["service_endpoint"] = st.text_input(
-            "OCI GenAI Region:",
-            value=oci_lookup[selected_oci_auth_profile]["service_endpoint"],
-            help="Region of GenAI Service",
-            key="oci_genai_region",
-            disabled=not namespace,
-        )
-
-        if st.button("Save OCI GenAI", key="save_oci_genai", disabled=not namespace):
-            if not (supplied["compartment_id"] and supplied["service_endpoint"]):
-                st.error("All fields are required.", icon="🛑")
+        if st.button("Check for OCI GenAI Models", key="check_oci_genai", disabled=not namespace):
+            if not supplied["genai_compartment_id"]:
+                st.error("OCI GenAI Compartment OCID is required.", icon="🛑")
                 st.stop()
-            if patch_oci(selected_oci_auth_profile, supplied, namespace):
-                st.rerun()
+            with st.spinner("Looking for OCI GenAI Models... please be patient.", show_time=True):
+                patch_oci(selected_oci_auth_profile, supplied, namespace, toast=False)
+                state.genai_models = get_genai_models()
+        if state.genai_models:
+            regions = list({item["region"] for item in state.genai_models if "region" in item})
+            supplied["genai_region"] = st.selectbox(
+                "Region:",
+                regions,
+                key="selected_genai_region",
+            )
+            filtered_models = [
+                m
+                for m in state.genai_models
+                if m["region"] == supplied["genai_region"]
+                and ("CHAT" in m["capabilities"] or "TEXT_EMBEDDINGS" in m["capabilities"])
+            ]
+            table_data = []
+            for m in filtered_models:
+                table_data.append(
+                    {
+                        "Model Name": m["model_name"],
+                        "Large Language": st_common.bool_to_emoji("CHAT" in m["capabilities"]),
+                        "Embedding": st_common.bool_to_emoji("TEXT_EMBEDDINGS" in m["capabilities"]),
+                    }
+                )
+
+            # Convert to DataFrame and display
+            df = pd.DataFrame(table_data)
+            st.dataframe(df, hide_index=True)
+            if st.button("Enable Region Models", key="enable_oci_region_models", type="primary"):
+                with st.spinner("Enabling OCI GenAI Models... please be patient.", show_time=True):
+                    patch_oci(selected_oci_auth_profile, supplied, namespace, toast=False)
+                    _ = create_genai_models()
+                    st_common.clear_state_key("model_configs")
+                st.success("Oracle GenAI models - Enabled.", icon="✅")
 
 
 if __name__ == "__main__" or "page.py" in inspect.stack()[1].filename:

src/client/content/config/settings.py

@@ -139,9 +139,9 @@ def apply_uploaded_settings(uploaded):
         logger.error("%s Settings Update failed: %s", state.client_settings["client"], ex)
 
 
-def spring_ai_conf_check(ll_model, embed_model) -> str:
+def spring_ai_conf_check(ll_model: dict, embed_model: dict) -> str:
     """Check if configuration is valid for SpringAI package"""
-    if ll_model is None or embed_model is None:
+    if not ll_model or not embed_model:
         return "hybrid"
 
     ll_api = ll_model["api"]
@@ -317,18 +317,24 @@ def main():
     st.header("Export source code templates", divider="red")
     # Merge the User Settings into the Model Config
     model_lookup = st_common.state_configs_lookup("model_configs", "id")
-    ll_config = model_lookup[state.client_settings["ll_model"]["model"]] | state.client_settings["ll_model"]
-    embed_config = (
-        model_lookup[state.client_settings["vector_search"]["model"]] | state.client_settings["vector_search"]
-    )
+    try:
+        ll_config = model_lookup[state.client_settings["ll_model"]["model"]] | state.client_settings["ll_model"]
+    except KeyError:
+        ll_config = {}
+    try:
+        embed_config = (
+            model_lookup[state.client_settings["vector_search"]["model"]] | state.client_settings["vector_search"]
+        )
+    except KeyError:
+        embed_config = {}
     spring_ai_conf = spring_ai_conf_check(ll_config, embed_config)
 
     if spring_ai_conf == "hybrid":
         st.markdown(f"""
             The current configuration combination of embedding and language models
             is currently **not supported** for SpringAI.
-            - Language Model:  **{ll_config["model"]}**
-            - Embedding Model: **{embed_config["model"]}**
+            - Language Model:  **{ll_config.get("model", "Unset")}**
+            - Embedding Model: **{embed_config.get("model", "Unset")}**
         """)
     else:
         col_left, col_centre, _ = st.columns([3, 4, 3])

src/client/content/testbed.py

@@ -81,13 +81,14 @@ def create_gauge(value):
     # Get the Report
     if eid:
         report = api_call.get(endpoint="v1/testbed/evaluation", params={"eid": eid})
-
     # Settings
     st.subheader("Evaluation Settings")
     ll_settings = pd.DataFrame(report["settings"]["ll_model"], index=[0])
-    ll_settings.drop(["streaming", "chat_history"], axis=1, inplace=True)
+    ll_settings.drop(["streaming", "chat_history", "context_length"], axis=1, inplace=True)
     ll_settings_reversed = ll_settings.iloc[:, ::-1]
     st.dataframe(ll_settings_reversed, hide_index=True)
+    if report["settings"]["testbed"]["judge_model"]:
+        st.markdown(f"**Judge Model**: {report['settings']['testbed']['judge_model']}")
     if report["settings"]["vector_search"]["enabled"]:
         st.subheader("Vector Search Settings")
         st.markdown(f"""**Database**: {report["settings"]["database"]["alias"]};
@@ -364,18 +365,29 @@ def main():
             max_value=100,
             value=2,
         )
+        if state.client_settings["testbed"].get("qa_ll_model") is None:
+            state.client_settings["testbed"]["qa_ll_model"] = available_embed_models[0]
+        selected_qa_ll_model = state.client_settings["testbed"]["qa_ll_model"]
+        qa_ll_model_idx = available_embed_models.index(selected_qa_ll_model)
         test_gen_llm = col_center.selectbox(
             "Q&A Language Model:",
             key="selected_test_gen_llm",
             options=available_ll_models,
-            index=0,
+            index=qa_ll_model_idx,
+            on_change=st_common.update_client_settings("testbed"),
             help="Don't see your model? Unfortunately it is not currently supported by the testing framework.",
         )
+
+        if state.client_settings["testbed"].get("qa_embed_model") is None:
+            state.client_settings["testbed"]["qa_embed_model"] = available_embed_models[0]
+        selected_qa_embed_model = state.client_settings["testbed"]["qa_embed_model"]
+        qa_embed_model_idx = available_embed_models.index(selected_qa_embed_model)
         test_gen_embed = col_right.selectbox(
             "Q&A Embedding Model:",
             key="selected_test_gen_embed",
             options=available_embed_models,
-            index=0,
+            index=qa_embed_model_idx,
+            on_change=st_common.update_client_settings("testbed"),
             help="Don't see your model? Unfortunately it is not currently supported by the testing framework.",
         )
         api_params = {
@@ -396,7 +408,6 @@ def main():
 
     # Load TestSets (and Evaluations if from DB)
     if col_left.button(button_text, key="load_tests", use_container_width=True, disabled=state.running):
-        placeholder = st.empty()
         with st.spinner("Processing Q&A... please be patient.", show_time=True):
             if testset_source != "Database":
                 api_params["name"] = (state.testbed["testset_name"],)
@@ -521,12 +532,17 @@ def main():
         st_common.vector_search_sidebar()
         st.write("Choose a model to judge the correctness of the chatbot answer, then start evaluation.")
         col_left, col_center, _ = st.columns([3, 3, 4])
+        if state.client_settings["testbed"].get("judge_model") is None:
+            state.client_settings["testbed"]["judge_model"] = available_ll_models[0]
+        selected_judge = state.client_settings["testbed"]["judge_model"]
+        judge_idx = available_ll_models.index(selected_judge)
         col_left.selectbox(
             "Judge Language Model:",
-            key="selected_evaluate_judge",
+            key="selected_testbed_judge_model",
             options=available_ll_models,
-            index=0,
+            index=judge_idx,
             label_visibility="collapsed",
+            on_change=st_common.update_client_settings("testbed"),
         )
         if col_center.button(
             "Start Evaluation",
@@ -539,7 +555,7 @@ def main():
                 st_common.clear_state_key("testbed_evaluations")
                 st_common.patch_settings()
                 endpoint = "v1/testbed/evaluate"
-                api_params = {"tid": state.testbed["testset_id"], "judge": state.selected_evaluate_judge}
+                api_params = {"tid": state.testbed["testset_id"], "judge": state.selected_testbed_judge_model}
                 evaluate = api_call.post(endpoint=endpoint, params=api_params, timeout=1200)
             st.success("Evaluation Complete!", icon="✅")