MCP implemented successfully

Author: Ishuin

src/client/content/chatbot.py

@@ -2,27 +2,23 @@
 Copyright (c) 2024, 2025, Oracle and/or its affiliates.
 Licensed under the Universal Permissive License v1.0 as shown at http://oss.oracle.com/licenses/upl.
 
-Session States Set:
-- user_client: Stores the Client
+This file merges the Streamlit Chatbot GUI with the MCPClient for a complete,
+runnable example demonstrating their integration.
 """
-
-# spell-checker:ignore streamlit, oraclevs, selectai
+# spell-checker:ignore streamlit, oraclevs, selectai, langgraph, prebuilt
 import asyncio
 import inspect
-import json
 import base64
 
 import streamlit as st
 from streamlit import session_state as state
 
-from client.content.config.models import get_models
-
-import client.utils.st_common as st_common
 import client.utils.api_call as api_call
-
+import client.utils.st_common as st_common
+from client.content.config.models import get_models
 from client.utils.st_footer import render_chat_footer
-import client.utils.client as client
 import common.logging_config as logging_config
+from client.mcp.client import MCPClient
 
 logger = logging_config.logging.getLogger("client.content.chatbot")
 
@@ -82,89 +78,106 @@ async def main() -> None:
     # Stop when sidebar configurations not set
     if not state.enable_client:
         st.stop()
-
-    #########################################################################
-    # Chatty-Bot Centre
-    #########################################################################
-    # Establish the Client
-    if "user_client" not in state:
-        state.user_client = client.Client(
-            server=state.server,
-            settings=state.client_settings,
-            timeout=1200,
-        )
-    user_client: client.Client = state.user_client
-
-    history = await user_client.get_history()
-    st.chat_message("ai").write("Hello, how can I help you?")
-    vector_search_refs = []
-    for message in history or []:
-        if not message["content"]:
-            continue
-        if message["role"] == "tool" and message["name"] == "oraclevs_tool":
-            vector_search_refs = json.loads(message["content"])
-        if message["role"] in ("ai", "assistant"):
-            with st.chat_message("ai"):
-                st.markdown(message["content"])
-                if vector_search_refs:
-                    show_vector_search_refs(vector_search_refs)
-                    vector_search_refs = []
-        elif message["role"] in ("human", "user"):
-            with st.chat_message("human"):
-                content = message["content"]
-                if isinstance(content, list):
-                    for part in content:
-                        if part["type"] == "text":
-                            st.write(part["text"])
-                        elif part["type"] == "image_url" and part["image_url"]["url"].startswith("data:image"):
-                            st.image(part["image_url"]["url"])
-                else:
-                    st.write(content)
-
+    image_url = None
+    # --- Chatty-Bot Centre ---
+    # Get the model ID for the current client settings
+    model_id = state.client_settings.get('ll_model', {}).get('model')
+    
+    # Prepare client settings for MCP client
+    client_settings = state.client_settings.copy()
+    if model_id:
+        # Get the model configuration to retrieve the API key
+        ll_models_enabled = st_common.enabled_models_lookup("ll")
+        if model_id in ll_models_enabled and 'api_key' in ll_models_enabled[model_id]:
+            client_settings['ll_model']['api_key'] = ll_models_enabled[model_id]['api_key']
+
+    # Initialize chat history in session state if it doesn't exist.
+    if "messages" not in state:
+        state.messages = []
+
+    st.chat_message("ai").write("Hello, how can I help you? (Now powered by MCPClient)")
+
+    # Display a read-only view of the chat history from the session state.
+    for message in state.messages:
+        role = message["role"]
+        # Standardize roles for display purposes
+        if role in ("human", "user"):
+            display_role = "human"
+        elif role in ("ai", "assistant"):
+            display_role = "assistant"
+        else: # e.g. tool, system
+            continue # Don't display tool or system messages directly
+        
+        with st.chat_message(display_role):
+            content = message.get("content")
+            if isinstance(content, list): # Handle multimodal content
+                for part in content:
+                    if part.get("type") == "text":
+                        st.write(part["text"])
+                    elif part.get("type") == "image_url" and part["image_url"]["url"].startswith("data:image"):
+                        st.image(part["image_url"]["url"])
+            else:
+                st.write(content)
+                
+    # Render the chat input footer
     sys_prompt = state.client_settings["prompts"]["sys"]
     render_chat_footer()
-    if human_request := st.chat_input(
+    
+    # Handle new user input
+    if prompt := st.chat_input(
         f"Ask your question here... (current prompt: {sys_prompt})",
+        key=f"chat_input_{len(state.messages)}", # Add a dynamic key
         accept_file=True,
         file_type=["jpg", "jpeg", "png"],
     ):
-        st.chat_message("human").write(human_request.text)
-        file_b64 = None
-        if human_request["files"]:
-            file = human_request["files"][0]
+        # Construct the user's message, potentially with an image
+        user_content = [{"type": "text", "text": prompt.text}]
+        if prompt.files:
+            file = prompt.files[0]
             file_bytes = file.read()
             file_b64 = base64.b64encode(file_bytes).decode("utf-8")
+            image_url = f"data:image/jpeg;base64,{file_b64}"
+            user_content.append({"type": "image_url", "image_url": {"url": image_url}})
+        
+        # Add user message to state and display it
+        state.messages.append({"role": "user", "content": user_content})  # type: ignore
+        with st.chat_message("human"):
+            st.write(prompt.text)
+            if image_url:
+                st.image(image_url)
+
+        # --- CORE LOGIC: Call MCPClient.invoke ---
         try:
-            message_placeholder = st.chat_message("ai").empty()
-            full_answer = ""
-            async for chunk in user_client.stream(message=human_request.text, image_b64=file_b64):
-                full_answer += chunk
-                message_placeholder.markdown(full_answer)
-            # Stream until we hit the end then refresh to replace with history
-            st.rerun()
-        except Exception:
-            logger.error("Exception:", exc_info=1)
-            st.chat_message("ai").write(
-                """
-                I'm sorry, something's gone wrong.  Please try again.
-                If the problem persists, please raise an issue.
-                """
-            )
-            if st.button("Retry", key="reload_chatbot"):
-                st_common.clear_state_key("user_client")
+            with st.chat_message("ai"):
+                with st.spinner("Thinking..."):
+                    # FIX: Create, use, and automatically clean up the MCPClient in a single block.
+                    # This is the core of the solution to the RuntimeError.
+                    async with MCPClient(client_settings=client_settings) as mcp_client:
+                        final_answer, new_history = await mcp_client.invoke(message_history=state.messages)
+                        
+                        # The invoke method's final_answer is now the source of truth for display
+                        st.markdown(final_answer)
+                        
+                        # Update the session state with the full history from the MCP client
+                        state.messages = new_history
+
+        except Exception as e:
+            logger.error("Exception during invoke call:", exc_info=True)
+            st.error(f"An error occurred: {e}")
+            # Check if it's the event loop closed error or MCP session closed and offer a retry
+            if "Event loop closed" in str(e) or "MCP session" in str(e):
+                st.info("The connection was reset. Please try sending your message again.")
+            if st.button("Retry", key="reload_chatbot_error"):
                 st.rerun()
+        
+        # Rerun to clear the input box and reflect the latest state
+        st.rerun()
 
 
-if __name__ == "__main__" or "page.py" in inspect.stack()[1].filename:
+if __name__ == "__main__" or ("page" in inspect.stack()[1].filename if inspect.stack() else False):
     try:
         asyncio.run(main())
-    except ValueError as ex:
-        logger.exception("Bug detected: %s", ex)
-        st.error("It looks like you found a bug; please open an issue", icon="🛑")
+    except Exception as ex:
+        logger.exception("A critical error occurred: %s", ex)
+        st.error(f"A critical error occurred: {ex}", icon="🛑")
         st.stop()
-    except IndexError as ex:
-        logger.exception("Unable to contact the server: %s", ex)
-        st.error("Unable to contact the server, is it running?", icon="🚨")
-        if st.button("Retry", key="reload_chatbot"):
-            st_common.clear_state_key("user_client")
-            st.rerun()

src/client/content/config/mcp_servers.py

@@ -0,0 +1,24 @@
+import inspect
+
+from client.mcp.frontend import display_commands_tab, display_ide_tab, get_fastapi_base_url, get_server_capabilities
+
+import streamlit as st
+
+def main():
+    fastapi_base_url = get_fastapi_base_url()
+    tools, resources, prompts = get_server_capabilities(fastapi_base_url)
+    if "chat_history" not in st.session_state:
+        st.session_state.chat_history = []
+    ide, commands = st.tabs(["🛠️ IDE", "📚 Available Commands"])
+
+    with ide:
+        # Display the IDE tab using the original AI Optimizer logic.
+        display_ide_tab()
+    with commands:
+        # Display the commands tab using the original AI Optimizer logic.
+        display_commands_tab(tools, resources, prompts)
+
+
+
+if __name__ == "__main__" or "page.py" in inspect.stack()[1].filename:
+    main()

src/client/content/config/settings.py

@@ -37,15 +37,32 @@
 #############################################################################
 def get_settings(include_sensitive: bool = False):
     """Get Server-Side Settings"""
-    settings = api_call.get(
-        endpoint="v1/settings",
-        params={
-            "client": state.client_settings["client"],
-            "full_config": True,
-            "incl_sensitive": include_sensitive,
-        },
-    )
-    return settings
+    try:
+        settings = api_call.get(
+            endpoint="v1/settings",
+            params={
+                "client": state.client_settings["client"],
+                "full_config": True,
+                "incl_sensitive": include_sensitive,
+            },
+        )
+        return settings
+    except api_call.ApiError as e:
+        if "not found" in str(e):
+            # If client settings not found, create them
+            logger.info("Client settings not found, creating new ones")
+            api_call.post(endpoint="v1/settings", params={"client": state.client_settings["client"]})
+            settings = api_call.get(
+                endpoint="v1/settings",
+                params={
+                    "client": state.client_settings["client"],
+                    "full_config": True,
+                    "incl_sensitive": include_sensitive,
+                },
+            )
+            return settings
+        else:
+            raise
 
 def save_settings(settings):
     """Save Settings after changing client"""