Switching from llama to qwen 2.5

chatbot.py

@@ -1,75 +1,69 @@
 import streamlit as st
-from groq import Groq
-from langchain_groq import ChatGroq
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.output_parsers import StrOutputParser
 from html import escape
 import edge_tts
 import asyncio
 import os
 import uuid
+from openai import OpenAI
 
-GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+# Set your OpenRouter API key as env var OPENROUTER_API_KEY
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
 
 class CodeAssistantBot:
     def __init__(self):
-        self.client = Groq(api_key=GROQ_API_KEY)
-        self.model = ChatGroq(model="llama-3.3-70b-versatile", temperature=0.6)
-        self.analysis_prompt = ChatPromptTemplate.from_messages([
-            ("system",
-             "You are a skilled coding assistant. Use the following context and user input to help."
-             " Refer to previous summary and recent interactions to make answers accurate."
-             " Keep your response short, relevant, and conversational."),
-            ("user",
-             "Code: {code}\nInput: {input}\nOutput: {output}\nError: {error}\n"
-             "Summary: {summary}\nRecent: {recent}\nQuestion: {question}")
-        ])
-        self.summary_prompt = ChatPromptTemplate.from_messages([
-            ("system", "Summarize key technical points from the conversation so far."),
-            ("user", "Conversation: {conversation}")
-        ])
-        self.voice_prompt = ChatPromptTemplate.from_messages([
-            ("system",
-             "You are a friendly narrator voice bot. Given a technical answer and its context,"
-             " explain it aloud like you're helping someone understand the topic clearly and confidently."
-             " Keep your response conversational and short not too long, but not over short."),
-            ("user",
-             "Code: {code}\nInput: {input}\nOutput: {output}\nError: {error}\n"
-             "Conversation so far: {summary}\nAnswer to explain: {answer}")
-        ])
-
-    def analyze_code(self, code, input, output, error, question, summary="", history=None):
-        parser = StrOutputParser()
+        if not OPENROUTER_API_KEY:
+            raise ValueError("Set your OPENROUTER_API_KEY environment variable!")
+        self.client = OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=OPENROUTER_API_KEY,
+        )
+        self.model_name = "qwen/qwen-2.5-72b-instruct:free"
+
+    def analyze_code(self, code, input_, output, error, question, summary="", history=None):
         recent = "\n".join([f"User: {q}\nBot: {a}" for q, a in (history or [])[-4:]])
-        chain = self.analysis_prompt | self.model | parser
-        return chain.invoke({
-            'code': code,
-            'input': input,
-            'output': output,
-            'error': error,
-            'summary': summary,
-            'recent': recent,
-            'question': question
-        })
-
-    def narrate_response(self, code, input, output, error, answer, summary=""):
-        parser = StrOutputParser()
-        narration_chain = self.voice_prompt | self.model | parser
-        return narration_chain.invoke({
-            'code': code,
-            'input': input,
-            'output': output,
-            'error': error,
-            'summary': summary,
-            'answer': answer
-        })
+        prompt_text = (
+            "You are a skilled coding assistant. Use the following context and user input to help.\n"
+            "Refer to previous summary and recent interactions to make answers accurate.\n"
+            "Keep your response short, relevant, and conversational.\n\n"
+            f"Code: {code}\nInput: {input_}\nOutput: {output}\nError: {error}\n"
+            f"Summary: {summary}\nRecent: {recent}\nQuestion: {question}"
+        )
+
+        response = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=[
+                {"role": "system", "content": "You are a skilled coding assistant."},
+                {"role": "user", "content": prompt_text},
+            ],
+            temperature=0.6,
+        )
+        return response.choices[0].message.content
+
+    def narrate_response(self, code, input_, output, error, answer, summary=""):
+        prompt_text = (
+            "You are a friendly narrator voice bot. Given a technical answer and its context, "
+            "explain it aloud like you're helping someone understand the topic clearly and confidently. "
+            "Keep your response conversational and short, not too long, but not too short.\n\n"
+            f"Code: {code}\nInput: {input_}\nOutput: {output}\nError: {error}\n"
+            f"Conversation so far: {summary}\nAnswer to explain: {answer}"
+        )
+
+        response = self.client.chat.completions.create(
+            model=self.model_name,
+            messages=[
+                {"role": "system", "content": "You are a friendly narrator."},
+                {"role": "user", "content": prompt_text},
+            ],
+            temperature=0.6,
+        )
+        return response.choices[0].message.content
 
 async def text_to_speech(text, filename):
     voice = "fr-FR-VivienneMultilingualNeural"
     communicate = edge_tts.Communicate(text, voice)
     await communicate.save(filename)
 
-def render_chatbot(code, input, output, error):
+def render_chatbot(code, input_, output, error):
     st.markdown("""
     <style>
     .chat-container {
@@ -114,15 +108,26 @@ def render_chatbot(code, input, output, error):
         bot = CodeAssistantBot()
         history = st.session_state.conversation[-4:]
         summary = st.session_state.chat_summary
-        response = bot.analyze_code(code, input, output, error, question, summary, history)
+        response = bot.analyze_code(code, input_, output, error, question, summary, history)
         st.session_state.conversation.append((question, response))
         st.session_state.chat_display_count = 5
         if len(st.session_state.conversation) >= 3:
             try:
                 full_chat = "\n".join([f"User: {q}\nBot: {a}" for q, a in st.session_state.conversation[-10:]])
-                summarizer = bot.summary_prompt | bot.model | StrOutputParser()
-                st.session_state.chat_summary = summarizer.invoke({'conversation': full_chat})
-            except:
+                # For summary, you can just call analyze_code with a summarization prompt or implement separately
+                summary_prompt = (
+                    "Summarize key technical points from the conversation so far.\n\n" + full_chat
+                )
+                summary_response = bot.client.chat.completions.create(
+                    model=bot.model_name,
+                    messages=[
+                        {"role": "system", "content": "Summarize key technical points from the conversation."},
+                        {"role": "user", "content": summary_prompt},
+                    ],
+                    temperature=0.3,
+                )
+                st.session_state.chat_summary = summary_response.choices[0].message.content
+            except Exception:
                 pass
 
     total = len(st.session_state.conversation)
@@ -149,7 +154,6 @@ def render_chatbot(code, input, output, error):
         formatted = format_response(a)
         st.markdown(f'<div class="chat-message bot-message">{formatted}</div>', unsafe_allow_html=True)
 
-        # Check if already narrated
         audio_file = st.session_state.narrated_audio.get((q, a))
 
         if not audio_file:
@@ -157,7 +161,7 @@ def render_chatbot(code, input, output, error):
                 status_placeholder = st.empty()
                 status_placeholder.info("🧠 Generating narration...")
                 bot = CodeAssistantBot()
-                narration = bot.narrate_response(code, input, output, error, a, st.session_state.chat_summary)
+                narration = bot.narrate_response(code, input_, output, error, a, st.session_state.chat_summary)
                 status_placeholder.info("🎙️ Converting to audio...")
                 audio_file = f"audio_{uuid.uuid4().hex}.mp3"
                 asyncio.run(text_to_speech(narration, audio_file))
@@ -169,7 +173,7 @@ def render_chatbot(code, input, output, error):
 
     if start > 0 and st.button("🔽 Show more"):
         st.session_state.chat_display_count += 5
-        st.rerun()
+        st.experimental_rerun()
 
     st.markdown("""
     <script>