♻️ Refactor: set model as optional parameter for chatbot class and modify the _generate_chatbot_content function to handle both Olla-style and standard API chatbots

Also, fix bug in the _format_text function to recognize caption type

Author: sayalaruano

src/vuegen/config_manager.py

@@ -599,7 +599,7 @@ def _create_chatbot_component(self, component_data: dict) -> r.ChatBot:
             title=component_data["title"],
             logger=self.logger,
             api_url=component_data["api_url"],
-            model=component_data["model"],
+            model=component_data.get("model"),
             caption=component_data.get("caption"),
             headers=component_data.get("headers"),
             params=component_data.get("params"),

src/vuegen/report.py

@@ -586,15 +586,14 @@ def make_api_request(self, dynamic_request_body: Optional[dict] = None) -> Optio
             self.logger.info(f"Making {self.method} request to API: {self.api_url}")
             self.logger.debug(f"Headers: {self.headers}")
             self.logger.debug(f"Params: {self.params}")
-            self.logger.debug(f"Request Body: {request_body_to_send}")
 
             response = requests.request(
                 self.method,
                 self.api_url,
                 headers=self.headers,
                 params=self.params,
                 # Validate the request body based on the method
-                json=request_body_to_send if self.method in ["POST", "PUT", "PATCH"] and request_body_to_send else None
+                json=request_body_to_send if self.method in ["POST", "PUT", "PATCH"] and request_body_to_send else None,
             )
             response.raise_for_status()
             self.logger.info(
@@ -603,17 +602,6 @@ def make_api_request(self, dynamic_request_body: Optional[dict] = None) -> Optio
             return response.json()
         except requests.exceptions.RequestException as e:
             self.logger.error(f"API request failed: {e}")
-            # Attempt to get error details from response body if possible
-            try:
-                error_details = e.response.json() if e.response else str(e)
-                self.logger.error(f"Error details: {error_details}")
-            except json.JSONDecodeError:
-                error_details = e.response.text if e.response else str(e)
-                self.logger.error(f"Error details (non-JSON): {error_details}")
-            return None
-        except json.JSONDecodeError as e:
-            self.logger.error(f"Failed to decode JSON response: {e}")
-            self.logger.error(f"Response text: {response.text}")
             return None
 
 
@@ -624,10 +612,10 @@ class ChatBot(Component):
 
     Attributes
     ----------
-    model : str
-        The language model to use for the chatbot.
     api_call : APICall
         An instance of the APICall class used to interact with the API for fetching chatbot responses.
+    model : Optional[str]
+        The language model to use for the chatbot (default is None).
     headers : Optional[dict]
         Headers to include in the API request (default is None).
     params : Optional[dict]
@@ -639,8 +627,8 @@ def __init__(
         title: str,
         logger: logging.Logger,
         api_url: str,
-        model: str,
         caption: str = None,
+        model: Optional[str] = None,
         headers: Optional[dict] = None,
         params: Optional[dict] = None,
     ):
@@ -659,8 +647,6 @@ def __init__(
             caption=None,
             headers=headers,
             params=params,
-            # Default request_body is empty, it will be set dynamically
-            request_body=None
         )
 
 

src/vuegen/streamlit_reportview.py

@@ -256,7 +256,7 @@ def _format_text(
         """
         if type == "header":
             tag = f"h{level}"
-        elif type == "paragraph":
+        elif type == "paragraph" or type == "caption":
             tag = "p"
 
         return f"""st.markdown('''<{tag} style='text-align: {text_align}; color: {color};'>{text}</{tag}>''', unsafe_allow_html=True)"""
@@ -417,6 +417,9 @@ def _generate_subsection(
         subsection_content = []
         subsection_imports = []
 
+        # Track if there's a Chatbot component in this subsection
+        has_chatbot = False
+
         # Add subsection header and description
         subsection_content.append(
             self._format_text(
@@ -451,15 +454,17 @@ def _generate_subsection(
             elif component.component_type == r.ComponentType.APICALL:
                 subsection_content.extend(self._generate_apicall_content(component))
             elif component.component_type == r.ComponentType.CHATBOT:
+                has_chatbot = True
                 subsection_content.extend(self._generate_chatbot_content(component))
             else:
                 self.report.logger.warning(
                     f"Unsupported component type '{component.component_type}' in subsection: {subsection.title}"
                 )
 
-        # Define the footer variable and add it to the home page content
-        subsection_content.append("footer = '''" + generate_footer() + "'''\n")
-        subsection_content.append("st.markdown(footer, unsafe_allow_html=True)\n")
+        if not has_chatbot:
+            # Define the footer variable and add it to the home page content
+            subsection_content.append("footer = '''" + generate_footer() + "'''\n")
+            subsection_content.append("st.markdown(footer, unsafe_allow_html=True)\n")
 
         self.report.logger.info(
             f"Generated content and imports for subsection: '{subsection.title}'"
@@ -854,122 +859,69 @@ def _generate_apicall_content(self, apicall) -> List[str]:
             f"Successfully generated content for APICall '{apicall.title}' using method '{apicall.method}'"
         )
         return apicall_content
-    
+        
     def _generate_chatbot_content(self, chatbot) -> List[str]:
         """
-        Generate content for a ChatBot component with exact API requirements.
+        Generate content for a ChatBot component, supporting both standard and Ollama-style APIs.
+
+        Parameters
+        ----------
+        chatbot : ChatBot
+            The ChatBot component to generate content for.
+
+        Returns
+        -------
+        list : List[str]
+            The list of content lines for the ChatBot.
         """
         chatbot_content = []
 
-        # Add title
+        # Add chatbot title as header
         chatbot_content.append(
             self._format_text(
                 text=chatbot.title, type="header", level=4, color="#2b8cbe"
             )
         )
 
-        # Chatbot logic with exact API requirements
-        chatbot_content.append(
-            f"""
-def generate_query(prompt):
-    try:
-        response = requests.post(
-            "{chatbot.api_call.api_url}",
-            json={{"prompt": prompt}},  # Only send the prompt as required
-            headers={chatbot.api_call.headers}
-        )
-        response.raise_for_status()
-        return response.json()
-    except requests.exceptions.RequestException as e:
-        st.error(f"API request failed: {{str(e)}}")
-        if hasattr(e, 'response') and e.response:
-            try:
-                error_details = e.response.json()
-                st.error(f"Error details: {{error_details}}")
-            except ValueError:
-                st.error(f"Response text: {{e.response.text}}")
-        return None
-
-# Chatbot interaction
+         # --- Shared code blocks (as strings) ---
+        init_messages_block = """
+# Init session state
 if 'messages' not in st.session_state:
     st.session_state['messages'] = []
+    """
 
+        render_messages_block = """
 # Display chat history
 for message in st.session_state['messages']:
     with st.chat_message(message['role']):
-        if isinstance(message['content'], dict):
-            st.markdown(message['content'].get('text', ''), unsafe_allow_html=True)
-            if 'links' in message['content']:
+        content = message['content']
+        if isinstance(content, dict):
+            st.markdown(content.get('text', ''), unsafe_allow_html=True)
+            if 'links' in content:
                 st.markdown("**Sources:**")
-                for link in message['content']['links']:
-                    st.markdown(f"- [{{link}}]({{link}})")
-            if 'subgraph_pyvis' in message['content']:
-                st.components.v1.html(message['content']['subgraph_pyvis'], height=600)
+                for link in content['links']:
+                    st.markdown(f"- [{link}]({link})")
+            if 'subgraph_pyvis' in content:
+                st.components.v1.html(content['subgraph_pyvis'], height=600)
         else:
-            st.write(message['content'])
+            st.write(content)
+    """
 
-# Handle user input
+        handle_prompt_block = """
+# Capture and append new user prompt
 if prompt := st.chat_input("Enter your prompt here:"):
-    st.session_state.messages.append({{"role": "user", "content": prompt}})
+    st.session_state.messages.append({"role": "user", "content": prompt})
     with st.chat_message("user"):
         st.write(prompt)
-    
-    with st.spinner('Generating answer...'):
-        response = generate_query(prompt)
-        
-        if response:
-            st.session_state.messages.append({{
-                "role": "assistant",
-                "content": response
-            }})
-            with st.chat_message("assistant"):
-                st.markdown(response.get('text', ''), unsafe_allow_html=True)
-                if 'links' in response:
-                    st.markdown("**Sources:**")
-                    for link in response['links']:
-                        st.markdown(f"- [{{link}}]({{link}})")
-                if 'subgraph_pyvis' in response:
-                    st.components.v1.html(response['subgraph_pyvis'], height=600)
-        else:
-            st.error("Failed to get response from API")
     """
-        )
 
-        if chatbot.caption:
+        if chatbot.model:
+            # --- Ollama-style streaming chatbot ---
             chatbot_content.append(
-                self._format_text(
-                    text=chatbot.caption, type="caption", text_align="left"
-                )
-            )
-
-        return chatbot_content
+                f"""
+{init_messages_block}
 
-    def _generate_ollama_chatbot_content(self, chatbot) -> List[str]:
-        """
-        Generate content for a ChatBot component.
-
-        Parameters
-        ----------
-        chatbot : ChatBot
-            The ChatBot component to generate content for.
-
-        Returns
-        -------
-        list : List[str]
-            The list of content lines for the ChatBot.
-        """
-        chatbot_content = []
-
-        # Add title
-        chatbot_content.append(
-            self._format_text(
-                text=chatbot.title, type="header", level=4, color="#2b8cbe"
-            )
-        )
-
-        # Chatbot logic for embedding in the web application
-        chatbot_content.append(
-            f"""
+# Function to send prompt to Ollama API
 def generate_query(messages):
     response = requests.post(
         "{chatbot.api_call.api_url}",
@@ -978,6 +930,7 @@ def generate_query(messages):
     response.raise_for_status()
     return response               
 
+# Parse streaming response from Ollama
 def parse_api_response(response):
     try:
         output = ""
@@ -991,53 +944,89 @@ def parse_api_response(response):
     except Exception as e:
         return {{"role": "assistant", "content": f"Error while processing API response: {{str(e)}}"}}
 
+# Simulated typing effect for responses
 def response_generator(msg_content):
     for word in msg_content.split():
         yield word + " "
         time.sleep(0.1)
     yield "\\n"
 
-# Chatbot interaction in the app
-if 'messages' not in st.session_state:
-    st.session_state['messages'] = []
+{render_messages_block}
 
-# Display chat history
-for message in st.session_state['messages']:
-    with st.chat_message(message['role']):
-        st.write(message['content'])
+{handle_prompt_block}
 
-# Handle new input from the user
-if prompt := st.chat_input("Enter your prompt here:"):
-    # Add user's question to the session state                           
-    st.session_state.messages.append({{"role": "user", "content": prompt}})
-    with st.chat_message("user"):
-        st.write(prompt)
-    
     # Retrieve question and generate answer
     combined = "\\n".join(msg["content"] for msg in st.session_state.messages if msg["role"] == "user")
     messages = [{{"role": "user", "content": combined}}]
     with st.spinner('Generating answer...'):                       
         response = generate_query(messages)
         parsed_response = parse_api_response(response)
-                               
+    
     # Add the assistant's response to the session state and display it
     st.session_state.messages.append(parsed_response)
     with st.chat_message("assistant"):
         st.write_stream(response_generator(parsed_response["content"]))
-    """
+                """
+            )
+        else:
+            # --- Standard (non-streaming) API chatbot ---
+            chatbot_content.append(
+                f"""
+{init_messages_block}
+
+# Function to send prompt to standard API
+def generate_query(prompt):
+    try:
+        response = requests.post(
+            "{chatbot.api_call.api_url}",
+            json={{"prompt": prompt}},
+            headers={chatbot.api_call.headers}
         )
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        st.error(f"API request failed: {{str(e)}}")
+        if hasattr(e, 'response') and e.response:
+            try:
+                error_details = e.response.json()
+                st.error(f"Error details: {{error_details}}")
+            except ValueError:
+                st.error(f"Response text: {{e.response.text}}")
+        return None
+
+{render_messages_block}
+
+{handle_prompt_block}
+
+    with st.spinner('Generating answer...'):
+        response = generate_query(prompt)
+
+        if response:
+            # Append and display assistant response
+            st.session_state.messages.append({{
+                "role": "assistant",
+                "content": response
+            }})
+            with st.chat_message("assistant"):
+                st.markdown(response.get('text', ''), unsafe_allow_html=True)
+                if 'links' in response:
+                    st.markdown("**Sources:**")
+                    for link in response['links']:
+                        st.markdown(f"- [{{link}}]({{link}})")
+                if 'subgraph_pyvis' in response:
+                    st.components.v1.html(response['subgraph_pyvis'], height=600)
+        else:
+            st.error("Failed to get response from API")
+                """
+            )
 
-        # Add caption if available
         if chatbot.caption:
             chatbot_content.append(
                 self._format_text(
                     text=chatbot.caption, type="caption", text_align="left"
                 )
             )
 
-        self.report.logger.info(
-            f"Successfully generated content for ChatBot: '{chatbot.title}'"
-        )
         return chatbot_content
 
     def _generate_component_imports(self, component: r.Component) -> List[str]: