Upload 13 files

app.py

@@ -0,0 +1,63 @@
+import streamlit as st
+
+if "login_state" not in st.session_state:
+    st.session_state.login_state = False
+if "api" not in st.session_state:
+    st.session_state.api = ""
+
+def main():
+    if not st.session_state.login_state:
+        from note import regester, notes
+
+        st.subheader("Interact with AI models through SiliconFlow API key", anchor=False)
+
+        st.markdown(regester, unsafe_allow_html=True)
+
+        api_key = st.text_input("API KEY", st.session_state.api, key="api_key", type="password", placeholder="sk-...")
+        st.session_state.api = api_key
+        submit_btn = st.button("Submit", key="submit_btn", type="primary", disabled=not api_key)
+
+        st.markdown("---")
+
+        with st.container(border=True, key="note_container"):
+            st.markdown(notes, unsafe_allow_html=True)
+        
+        if submit_btn and st.session_state.api:
+            st.session_state.login_state = True
+            st.rerun()
+        elif submit_btn and not st.session_state.api:
+            st.error("Please enter your SiliconFlow API key!")
+    else:
+        siliconflow()
+
+def siliconflow():
+    function_list = ["General Chat", "Visual Chat", "Reasoning Chat", "Image Generation", "Audio to Text"]
+    function_item = st.sidebar.selectbox("Function", function_list, index=0, key="func_")
+
+    st.subheader(function_item, anchor=False)
+
+    if function_item == "General Chat":
+        from general_chat import generalChat
+        generalChat(api_key=st.session_state.api)
+    elif function_item == "Visual Chat":
+        from visual_chat import visualChat
+        visualChat(api_key=st.session_state.api)
+    elif function_item == "Reasoning Chat":
+        from reasoning_chat import reasoningChat
+        reasoningChat(api_key=st.session_state.api)
+    elif function_item == "Image Generation":
+        from image_generation import imageGeneration
+        imageGeneration(api_key=st.session_state.api)
+    elif function_item == "Audio to Text":
+        from audio_text import audioText
+        audioText(api_key=st.session_state.api)
+    
+    st.sidebar.markdown("---")
+
+    if st.sidebar.button("Log Out", key="logout_btn"):
+        st.session_state.login_state = False
+        st.session_state.api = ""
+        st.rerun()
+
+if __name__ == "__main__":
+    main()

audio_text.py

@@ -0,0 +1,69 @@
+from openai import OpenAI
+import streamlit as st
+
+def audio_transcription(api_key, audio_file):
+    api_key = api_key
+    base_url = "https://api.siliconflow.cn/v1"
+    client = OpenAI(api_key=api_key, base_url=base_url)
+
+    transcription = client.audio.transcriptions.create(
+        model="FunAudioLLM/SenseVoiceSmall",
+        file=audio_file
+    )
+
+    return transcription
+
+def audioText(api_key: str):
+    if "uploaded_audio" not in st.session_state:
+        st.session_state.uploaded_audio = None
+    if "input_audio" not in st.session_state:
+        st.session_state.input_audio = None
+    
+    if st.session_state.uploaded_audio == None and st.session_state.input_audio == None:
+        disable = True
+    elif st.session_state.uploaded_audio != None and st.session_state.input_audio == None:
+        disable = False
+    elif st.session_state.uploaded_audio == None and st.session_state.input_audio != None:
+        disable = False
+    
+    audio_uploader = st.file_uploader("Upload an Audio", type=["MP3", "WAV"], key="audio_uploader", disabled=st.session_state.input_audio!=None)
+    if audio_uploader is not None:
+        st.session_state.uploaded_audio = audio_uploader
+    elif audio_uploader is None:
+        st.session_state.uploaded_audio = None
+    audio_input = st.audio_input("Record an Audio", key="audio_input", disabled=st.session_state.uploaded_audio!=None)
+    if audio_input is not None:
+        st.session_state.input_audio = audio_input
+    elif audio_input is None:
+        st.session_state.input_audio = None
+    
+    transcript_btn = st.button("Transcript", "transcript_btn", type="primary", disabled=disable)
+
+    transcription_str = ""
+
+    if transcript_btn:
+        if st.session_state.uploaded_audio is not None and st.session_state.input_audio is None:
+            try:
+                with st.spinner("Processing..."):
+                    transcription = audio_transcription(api_key, st.session_state.uploaded_audio)
+                if transcription:
+                    transcription_str = transcription.text
+            except Exception as e:
+                st.error(f"Error occured: {e}")
+        elif st.session_state.uploaded_audio is None and st.session_state.input_audio is not None:
+            try:
+                with st.spinner("Processing..."):
+                    transcription = audio_transcription(api_key, st.session_state.input_audio)
+                if transcription:
+                    transcription_str = transcription.text
+            except Exception as e:
+                st.error(f"Error occured: {e}")
+        elif st.session_state.uploaded_audio is None and st.session_state.input_audio is None:
+            st.info("Please upload an audio or record an audio!")
+    
+    if transcription_str:
+        with st.container(border=True, key="trans_container"):
+            st.markdown(transcription_str)
+
+if __name__ == "__main__":
+    audioText("sk-hvnjkojhpyitxfeqwdpynrsacitcvqffprrrzzgrwytpebrf")

chat.py

@@ -0,0 +1,27 @@
+from openai import OpenAI
+
+def chat_completion(
+    api_key: str,
+    model: str,
+    messages: list,
+    tokens: int,
+    temp: float,
+    topp: float,
+    freq: float,
+    pres: float,
+    stop: list):
+    api_key = api_key
+    base_url = "https://api.siliconflow.cn/v1"
+    client = OpenAI(api_key=api_key, base_url=base_url)
+    response = client.chat.completions.create(
+        model=model,
+        messages=messages,
+        max_tokens=tokens,
+        temperature=temp,
+        top_p=topp,
+        frequency_penalty=freq,
+        presence_penalty=pres,
+        stop=stop,
+        stream=True
+    )
+    return response

general_chat.py

@@ -0,0 +1,107 @@
+import streamlit as st
+
+from session_state import set_session_state
+from chat import chat_completion
+from template import general_default_prompt
+from model_config import text_model
+
+def generalChat(api_key: str):
+    set_session_state("general", general_default_prompt, 4096, 0.70)
+    
+    if st.session_state.general_msg == []:
+        disable = True
+    elif st.session_state.general_msg != []:
+        disable = False
+    
+    with st.sidebar:
+        clear_btn = st.button("Clear", "clear_", type="primary", use_container_width=True, disabled=disable)
+        undo_btn = st.button("Undo", "undo_", use_container_width=True, disabled=disable)
+        retry_btn = st.button("Retry", "retry_", use_container_width=True, disabled=disable)
+
+        model_list = text_model(api_key)
+        model = st.selectbox("Model", model_list, index=0, key="gen_model", disabled=not disable)
+
+        system_prompt = st.text_area("System Prompt", st.session_state.general_sys, key="gen_sys", disabled=not disable)
+
+        with st.expander("Advanced Setting"):
+            tokens: int = st.slider("Max Tokens", 1, 4096, st.session_state.general_tokens, 1, key="gen_tokens", disabled=not disable)
+            temp: float = st.slider("Temperature", 0.00, 2.00, st.session_state.general_temp, 0.01, key="gen_temp", disabled=not disable)
+            topp: float = st.slider("Top P", 0.01, 1.00, st.session_state.general_topp, 0.01, key="gen_topp", disabled=not disable)
+            freq: float = st.slider("Frequency Penalty", -2.00, 2.00, st.session_state.general_freq, 0.01, key="gen_freq", disabled=not disable)
+            pres: float = st.slider("Presence Penalty", -2.00, 2.00, st.session_state.general_pres, 0.01, key="gen_pres", disabled=not disable)
+            if st.toggle("Set stop", key="gen_stop_toggle", disabled=not disable):
+                st.session_state.general_stop = []
+                stop_str = st.text_input("Stop", st.session_state.general_stop_str, key="gen_stop_str", disabled=not disable)
+                st.session_state.general_stop_str = stop_str
+                submit_stop = st.button("Submit", "gen_submit_stop", disabled=not disable)
+                if submit_stop and stop_str:
+                    st.session_state.general_stop.append(st.session_state.general_stop_str)
+                    st.session_state.general_stop_str = ""
+                    st.rerun()
+                if st.session_state.general_stop:
+                    for stop_str in st.session_state.general_stop:
+                        st.markdown(f"`{stop_str}`")
+            
+        st.session_state.general_sys = system_prompt
+        st.session_state.general_tokens = tokens
+        st.session_state.general_temp = temp
+        st.session_state.general_topp = topp
+        st.session_state.general_freq = freq
+        st.session_state.general_pres = pres
+    
+    for i in st.session_state.general_cache:
+        with st.chat_message(i["role"]):
+            st.markdown(i["content"])
+
+    if query := st.chat_input("Say something...", key="gen_query", disabled=model==""):
+        with st.chat_message("user"):
+            st.markdown(query)
+        st.session_state.general_msg.append({"role": "user", "content": query})
+        messages = [{"role": "system", "content": system_prompt}] + st.session_state.general_msg
+        with st.chat_message("assistant"):
+            try:
+                response = chat_completion(api_key, model, messages, tokens, temp, topp, freq, pres, st.session_state.general_stop)
+                result = st.write_stream(chunk.choices[0].delta.content for chunk in response if chunk.choices[0].delta.content is not None)
+                st.session_state.general_msg.append({"role": "assistant", "content": result})
+            except Exception as e:
+                st.error(f"Error occured: {e}")
+        st.session_state.general_cache = st.session_state.general_msg
+        st.rerun()
+
+    if clear_btn:
+        st.session_state.general_sys = general_default_prompt
+        st.session_state.general_tokens = 4096
+        st.session_state.general_temp = 0.70
+        st.session_state.general_topp = 0.70
+        st.session_state.general_freq = 0.00
+        st.session_state.general_pres = 0.00
+        st.session_state.general_stop = None
+        st.session_state.general_msg = []
+        st.session_state.general_cache = []
+        st.rerun()
+
+    if undo_btn:
+        del st.session_state.general_msg[-1]
+        del st.session_state.general_cache[-1]
+        st.rerun()
+
+    if retry_btn:
+        st.session_state.general_msg.pop()
+        st.session_state.general_cache = []
+        st.session_state.general_retry = True
+        st.rerun()
+    if st.session_state.general_retry:
+        for i in st.session_state.general_msg:
+            with st.chat_message(i["role"]):
+                st.markdown(i["content"])
+        messages = [{"role": "system", "content": system_prompt}] + st.session_state.general_msg
+        with st.chat_message("assistant"):
+            try:
+                response = chat_completion(api_key, model, messages, tokens, temp, topp, freq, pres, st.session_state.general_stop)
+                result = st.write_stream(chunk.choices[0].delta.content for chunk in response if chunk.choices[0].delta.content is not None)
+                st.session_state.general_msg.append({"role": "assistant", "content": result})
+            except Exception as e:
+                st.error(f"Error occured: {e}")
+        st.session_state.general_cache = st.session_state.general_msg
+        st.session_state.general_retry = False
+        st.rerun()

image_generation.py

@@ -0,0 +1,192 @@
+import streamlit as st
+import requests
+
+from model_config import image_model_list
+
+url = "https://api.siliconflow.cn/v1/images/generations"
+
+flux_image_size = [
+    "1024x1024",
+    "960x1280",
+    "768x1024",
+    "720x1440",
+    "720x1280",
+    "others"
+]
+
+sd_image_size = [
+    "1024x1024",
+    "512x1024",
+    "768x512",
+    "768x512",
+    "1024x576",
+    "576x1024"
+]
+
+def flux_image_generator(api_key: str, prompt: str, image_size: str, seed: int, step: int, prompt_enhancement: bool):
+    if seed is not None:
+        payload = {
+            "model": "black-forest-labs/FLUX.1-dev",
+            "prompt": prompt,
+            "image_size": image_size,
+            "seed": seed,
+            "num_inference_steps": step,
+            "prompt_enhancement": prompt_enhancement
+        }
+    elif seed is None:
+        payload = {
+            "model": "black-forest-labs/FLUX.1-dev",
+            "prompt": prompt,
+            "image_size": image_size,
+            "num_inference_steps": step,
+            "prompt_enhancement": prompt_enhancement
+        }
+    
+    headers = {
+    "Authorization": f"Bearer {api_key}",
+    "Content-Type": "application/json"
+    }
+
+    response = requests.request("POST", url, json=payload, headers=headers)
+    if response.status_code == 200:
+        response_object = response.json()
+        response_data = response_object["images"]
+        response_url = response_data[0]["url"]
+        return response_url
+
+def sd_image_generator(api_key: str, prompt: str, negative_prompt: str, image_size: str, seed: int, step: int, guidance_scale: int, prompt_enhancement: bool):
+    if seed is not None:
+        payload = {
+            "model": "stabilityai/stable-diffusion-3-5-large",
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "image_size": image_size,
+            "batch_size": 1,
+            "seed": seed,
+            "num_inference_steps": step,
+            "guidance_scale": guidance_scale,
+            "prompt_enhancement": prompt_enhancement
+        }
+    else:
+        payload = {
+            "model": "stabilityai/stable-diffusion-3-5-large",
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "image_size": image_size,
+            "batch_size": 1,
+            "num_inference_steps": step,
+            "guidance_scale": guidance_scale,
+            "prompt_enhancement": prompt_enhancement
+        }
+    
+    headers = {
+    "Authorization": f"Bearer {api_key}",
+    "Content-Type": "application/json"
+    }
+
+    response = requests.request("POST", url, json=payload, headers=headers)
+    if response.status_code == 200:
+        response_object = response.json()
+        response_data = response_object["images"]
+        response_url = response_data[0]["url"]
+        return response_url
+
+def imageGeneration(api_key: str):
+    if "image_url" not in st.session_state:
+        st.session_state.image_url = ""
+    if "generate_state" not in st.session_state:
+        st.session_state.generate_state = False
+
+    with st.sidebar:
+        reset_btn = st.button("Reset", "img_reset_btn", type="primary", use_container_width=True, disabled=st.session_state.image_url=="")
+        model_list = image_model_list
+        model = st.selectbox("Model", model_list, 0, key="img_model", disabled=st.session_state.image_url!="")
+    
+    if model == "black-forest-labs/FLUX.1-dev":
+        with st.sidebar:
+            image_size = st.selectbox("Image Size", flux_image_size, 0, key="flux_img_size")
+            if image_size == "others":
+                length = st.text_input("Length", "", key="length")
+                width = st.text_input("Width", "", key="width")
+                if length and width and "." not in length and "." not in width:
+                    if length[0]!="0" and width[0]!="0":
+                        image_size = f"{length}x{width}"
+                        st.session_state.generate_state = False
+                        st.markdown(f"Custom Image Size: `{image_size}`")
+                    elif length[0]=="0" or width[0]=="0":
+                        st.session_state.generate_state = True
+                        st.warning("Please input an integer!")
+                elif "." in length or "." in width:
+                    st.session_state.generate_state = True
+                    st.warning("Please input an integer!")
+
+            step = st.slider("Inference Steps", 1, 50, 50, 1, key="flux_step")
+            seed_input = st.text_input("Seed", "", key="flux_seed")
+            if seed_input and "." not in seed_input:
+                try:
+                    seed = int(seed_input)
+                    st.session_state.generate_state = False
+                except Exception as e:
+                    st.session_state.generate_state = True
+                    st.error(f"Error occured: {e}")
+            elif seed_input and "." in seed_input:
+                st.session_state.generate_state = True
+                st.warning("Please input an integer!")
+            elif not seed_input:
+                st.session_state.generate_state = False
+                seed = None
+            prompt_enhancement = st.toggle("Prompt Enhancement", False, key="flux_enhancement")
+
+        prompt = st.text_area("Prompt", "", key="flux_prompt", disabled=st.session_state.generate_state)
+        generate_btn = st.button("Generate", "flux_generate", type="primary", disabled=prompt=="")
+
+        if generate_btn:
+            try:
+                with st.spinner("Generating..."):
+                    st.session_state.image_url = flux_image_generator(api_key, prompt, image_size, seed, step, prompt_enhancement)
+                    st.rerun()
+            except Exception as e:
+                st.error(f"Error occured: {e}")
+        
+        if st.session_state.image_url != "":
+            st.image(st.session_state.image_url, output_format="PNG")
+    
+    elif model == "stabilityai/stable-diffusion-3-5-large":
+        with st.sidebar:
+            image_size = st.selectbox("Image Size", sd_image_size, 0, key="sd_img_size")
+            step = st.slider("Inference Steps", 1, 50, 50, 1, key="sd_step")
+            guidance_scale = st.slider("Guidance Scale", 0.0, 20.0, 4.5, 0.1, key="sd_guidance")
+            seed_input = st.text_input("Seed", "", key="sd_seed")
+            if seed_input and "." not in seed_input:
+                try:
+                    seed = int(seed_input)
+                    st.session_state.generate_state = False
+                except Exception as e:
+                    st.session_state.generate_state = True
+                    st.error(f"Error occured: {e}")
+            elif seed_input and "." in seed_input:
+                st.session_state.generate_state = True
+                st.warning("Please input an integer!")
+            elif not seed_input:
+                st.session_state.generate_state = False
+                seed = None
+            prompt_enhancement = st.toggle("Prompt Enhancement", False, key="sd_enhancement")
+
+        prompt = st.text_area("Prompt", "", key="sd_prompt", disabled=st.session_state.generate_state)
+        negative_prompt = st.text_area("Negative Prompt", "", key="negative_prompt", disabled=st.session_state.generate_state)
+        generate_btn = st.button("Generate", "sd_generate", type="primary", disabled=prompt=="")
+
+        if generate_btn:
+            try:
+                with st.spinner("Generating..."):
+                    st.session_state.image_url = sd_image_generator(api_key, prompt, negative_prompt, image_size, seed, step, guidance_scale, prompt_enhancement)
+                    st.rerun()
+            except Exception as e:
+                st.error(f"Error occured: {e}")
+        
+        if st.session_state.image_url != "":
+            st.image(st.session_state.image_url, output_format="PNG")
+    
+    if reset_btn:
+        st.session_state.image_url = ""
+        st.rerun()

model_config.py

@@ -0,0 +1,77 @@
+import requests
+import re
+
+url = "https://api.siliconflow.cn/v1/models"
+
+visual_model_list = [
+    "Qwen/Qwen2-VL-72B-Instruct",
+    "OpenGVLab/InternVL2-26B",
+    "TeleAI/TeleMM",
+    "Pro/Qwen/Qwen2-VL-7B-Instruct",
+    "Pro/OpenGVLab/InternVL2-8B"
+]
+
+reasoning_model_list = [
+    "Qwen/QwQ-32B-Preview",
+    "Qwen/QVQ-72B-Preview",
+    "AIDC-AI/Marco-o1"
+]
+
+excluded_models = [
+    "deepseek-ai/deepseek-vl2",
+    "01-ai/Yi-1.5-6B-Chat"
+]
+
+image_model_list = [
+    "black-forest-labs/FLUX.1-dev",
+    "stabilityai/stable-diffusion-3-5-large"
+]
+
+qwen_pattern = re.compile(r'^Qwen/')
+meta_llama_pattern = re.compile(r'^meta-llama/')
+deepseek_ai_pattern = re.compile(r'^deepseek-ai/')
+pro_lora_pattern = re.compile(r'^(Pro|LoRA)/')
+
+def extract_version_and_params(model):
+    version_match = re.search(r'(\d+(\.\d+)+)', model)
+    version = float(version_match.group(1)) if version_match else 0.0
+    
+    params_match = re.search(r'(\d+(\.\d+)?)(B|b)', model)
+    params = float(params_match.group(1)) if params_match else 0.0
+    
+    return version, params
+
+def sort_models(model_list):
+    return sorted(model_list, key=lambda x: extract_version_and_params(x), reverse=True)
+
+def text_model(api_key: str) -> list:
+    model_list = []
+
+    querystring = {"type":"text","sub_type":"chat"}
+    headers = {"Authorization": f"Bearer {api_key}"}
+    response = requests.request("GET", url, params=querystring, headers=headers)
+
+    if response.status_code == 200:
+        response_object = response.json()
+        response_data = response_object["data"]
+        for i in response_data:
+            if i["id"] not in visual_model_list and i["id"] not in reasoning_model_list and i["id"] not in excluded_models:
+                model_list.append(i["id"])
+    
+    qwen_models = [model for model in model_list if qwen_pattern.search(model) and not pro_lora_pattern.search(model)]
+    meta_llama_models = [model for model in model_list if meta_llama_pattern.search(model) and not pro_lora_pattern.search(model)]
+    deepseek_ai_models = [model for model in model_list if deepseek_ai_pattern.search(model) and not pro_lora_pattern.search(model)]
+    other_models = [model for model in model_list if not qwen_pattern.search(model) and not meta_llama_pattern.search(model) and not deepseek_ai_pattern.search(model) and not pro_lora_pattern.search(model)]
+    pro_lora_models = [model for model in model_list if pro_lora_pattern.search(model)]
+
+    qwen_models_sorted = sort_models(qwen_models)
+    meta_llama_models_sorted = sort_models(meta_llama_models)
+    deepseek_ai_models_sorted = sort_models(deepseek_ai_models)
+    other_models_sorted = sort_models(other_models)
+    pro_lora_models_sorted = sort_models(pro_lora_models)
+
+    model_list = qwen_models_sorted + meta_llama_models_sorted + deepseek_ai_models_sorted + other_models_sorted + pro_lora_models_sorted
+
+    return model_list
+
+

note.py

@@ -0,0 +1,9 @@
+regester = '<span style="color: grey;">No API key yet? Register here: </span><a href="https://cloud.siliconflow.cn/i/b7XJpKVo" style="color: #4682B4;" target="_blank">SiliconCloud</a>'
+
+notes = """<strong style="color: red;">Please note:</strong>
+
+1. This site does not retain chat records. Please copy and save any important chat data before refreshing or leaving the site.
+2. We recommend not sharing personal sensitive information, such as phone numbers, emails, or home addresses, during conversations.
+3. This site only supports open-source models officially deployed by SiliconFlow.
+4. This site is a Playground Demo and is not affiliated with SiliconFlow.
+"""

process_image.py

@@ -0,0 +1,28 @@
+from PIL import Image
+import io
+import base64
+
+def image_processor(uploaded_image):
+    img = Image.open(uploaded_image)
+
+    if img.mode in ('RGBA', 'LA') or (img.mode == 'P' and 'transparency' in img.info):
+        background = Image.new('RGB', img.size, (255, 255, 255))
+        background.paste(img, mask=img.split()[-1])
+        img = background
+
+    max_size = 1024
+    if max(img.size) > max_size:
+        ratio = max_size / max(img.size)
+        new_size = tuple(int(dim * ratio) for dim in img.size)
+        img = img.resize(new_size, Image.Resampling.LANCZOS)
+
+    output_buffer = io.BytesIO()
+    img.save(output_buffer, format='PNG', quality=95)
+    while output_buffer.tell() > 1024 * 1024:
+        quality = int(95 * (1024 * 1024 / output_buffer.tell()))
+        output_buffer = io.BytesIO()
+        img.save(output_buffer, format='PNG', quality=quality)
+
+    base64_encoded = base64.b64encode(output_buffer.getvalue()).decode('utf-8')
+
+    return base64_encoded

reasoning_chat.py

@@ -0,0 +1,209 @@
+import streamlit as st
+
+from session_state import set_session_state
+from chat import chat_completion
+from template import qwen_reasoning_prompt, marco_reasoning_prompt
+from model_config import reasoning_model_list
+
+def reasoningChat(api_key: str):
+    set_session_state("reasoning", "", 8192, 0.50)
+    
+    if st.session_state.reasoning_msg == []:
+        disable = True
+    elif st.session_state.reasoning_msg != []:
+        disable = False
+    
+    with st.sidebar:
+        clear_btn = st.button("Clear", "re_clear", type="primary", use_container_width=True, disabled=disable)
+        undo_btn = st.button("Undo", "re_undo", use_container_width=True, disabled=disable)
+        retry_btn = st.button("Retry", "re_retry", use_container_width=True, disabled=disable)
+
+        model_list = reasoning_model_list
+        model = st.selectbox("Model", model_list, 0, key="reason_model", disabled=not disable)
+        st.session_state.reasoning_model = model
+
+        if model == "AIDC-AI/Marco-o1":
+            st.session_state.reasoning_sys = marco_reasoning_prompt
+        else:
+            st.session_state.reasoning_sys = qwen_reasoning_prompt
+        
+        with st.expander("Advanced Setting"):
+            tokens = st.slider("Max Tokens", 1, 8192, st.session_state.reasoning_tokens, 1, key="re_tokens", disabled=not disable)
+            temp = st.slider("Temperature", 0.00, 2.00, st.session_state.reasoning_temp, 0.01, key="re_temp", disabled=not disable)
+            topp = st.slider("Top P", 0.01, 1.00, st.session_state.reasoning_topp, 0.01, key="re_topp", disabled=not disable)
+            freq = st.slider("Frequency Penalty", -2.00, 2.00, st.session_state.reasoning_freq, 0.01, key="re_freq", disabled=not disable)
+            pres = st.slider("Presence Penalty", -2.00, 2.00, st.session_state.reasoning_pres, 0.01, key="re_pres", disabled=not disable)
+            if st.toggle("Set stop", key="re_stop_toggle", disabled=not disable):
+                st.session_state.reasoning_stop = []
+                stop_str = st.text_input("Stop", st.session_state.reasoning_stop_str, key="re_stop_str", disabled=not disable)
+                st.session_state.visual_stop_str = stop_str
+                submit_stop = st.button("Submit", "re_submit_stop", disabled=not disable)
+                if submit_stop and stop_str:
+                    st.session_state.reasoning_stop.append(st.session_state.reasoning_stop_str)
+                    st.session_state.reasoning_stop_str = ""
+                    st.rerun()
+                if st.session_state.reasoning_stop:
+                    for stop_str in st.session_state.reasoning_stop:
+                        st.markdown(f"`{stop_str}`")
+        
+        st.session_state.reasoning_tokens = tokens
+        st.session_state.reasoning_temp = temp
+        st.session_state.reasoning_topp = topp
+        st.session_state.reasoning_freq = freq
+        st.session_state.reasoning_pres = pres
+
+    if st.session_state.reasoning_model == "Qwen/QVQ-72B-Preview":
+        from process_image import image_processor
+        image_type = ["PNG", "JPG", "JPEG"]
+        uploaded_image: list = st.file_uploader("Upload an image", type=image_type, accept_multiple_files=True, key="re_uploaded_image")
+        base64_image_list = []
+        if uploaded_image is not None:
+            with st.expander("Image"):
+                for i in uploaded_image:
+                    st.image(uploaded_image, output_format="PNG")
+                    base64_image_list.append(image_processor(i))
+        
+        for i in st.session_state.reasoning_cache:
+            with st.chat_message(i["role"]):
+                st.markdown(i["content"])
+        
+        if query := st.chat_input("Say something...", key="re_qvq_query", disabled=base64_image_list==[]):
+            with st.chat_message("user"):
+                st.markdown(query)
+            
+            st.session_state.reasoning_msg.append({"role": "user", "content": query})
+
+            if len(st.session_state.reasoning_msg) == 1:
+                messages = [
+                    {"role": "system", "content": st.session_state.reasoning_sys},
+                    {"role": "user", "content": []}
+                ]
+                for base64_img in base64_image_list:
+                    img_url_obj = {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_img}", "detail": "high"}}
+                    messages[1]["content"].append(img_url_obj)
+                messages[1]["content"].append({"type": "text", "text": query})
+            elif len(st.session_state.reasoning_msg) > 1:
+                messages = [
+                    {"role": "system", "content": st.session_state.reasoning_sys},
+                    {"role": "user", "content": []}
+                ]
+                for base64_img in base64_image_list:
+                    img_url_obj = {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_img}", "detail": "high"}}
+                    messages[1]["content"].append(img_url_obj)
+                messages[1]["content"].append({"type": "text", "text": st.session_state.reasoning_msg[0]["content"]})
+                messages += st.session_state.reasoning_msg[1:]
+            
+            with st.chat_message("assistant"):
+                try:
+                    response = chat_completion(api_key, model, messages, tokens, temp, topp, freq, pres, st.session_state.reasoning_stop)
+                    result = st.write_stream(chunk.choices[0].delta.content for chunk in response if chunk.choices[0].delta.content is not None)
+                    st.session_state.reasoning_msg.append({"role": "assistant", "content": result})
+                except Exception as e:
+                    st.error(f"Error occured: {e}")
+            
+            st.session_state.reasoning_cache = st.session_state.reasoning_msg
+            st.rerun()
+
+        if retry_btn:
+            st.session_state.reasoning_msg.pop()
+            st.session_state.reasoning_cache = []
+            st.session_state.reasoning_retry = True
+            st.rerun()
+        if st.session_state.reasoning_retry:
+            for i in st.session_state.reasoning_msg:
+                with st.chat_message(i["role"]):
+                    st.markdown(i["content"])
+            if len(st.session_state.reasoning_msg) == 1:
+                messages = [
+                    {"role": "system", "content": st.session_state.reasoning_sys},
+                    {"role": "user", "content": []}
+                ]
+                for base64_img in base64_image_list:
+                    img_url_obj = {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_img}", "detail": "high"}}
+                    messages[1]["content"].append(img_url_obj)
+                messages[1]["content"].append({"type": "text", "text": st.session_state.reasoning_msg[0]["content"]})
+            elif len(st.session_state.reasoning_msg) > 1:
+                messages = [
+                    {"role": "system", "content": st.session_state.reasoning_sys},
+                    {"role": "user", "content": []}
+                ]
+                for base64_img in base64_image_list:
+                    img_url_obj = {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_img}", "detail": "high"}}
+                    messages[1]["content"].append(img_url_obj)
+                messages[1]["content"].append({"type": "text", "text": st.session_state.reasoning_msg[0]["content"]})
+                messages += st.session_state.reasoning_msg[1:]
+            
+            with st.chat_message("assistant"):
+                try:
+                    response = chat_completion(api_key, model, messages, tokens, temp, topp, freq, pres, st.session_state.reasoning_stop)
+                    result = st.write_stream(chunk.choices[0].delta.content for chunk in response if chunk.choices[0].delta.content is not None)
+                    st.session_state.reasoning_msg.append({"role": "assistant", "content": result})
+                except Exception as e:
+                    st.error(f"Error occured: {e}")
+            
+            st.session_state.reasoning_cache = st.session_state.reasoning_msg
+            st.session_state.reasoning_retry = False
+            st.rerun()
+    else:
+        for i in st.session_state.reasoning_cache:
+            with st.chat_message(i["role"]):
+                st.markdown(i["content"])
+        
+        if query := st.chat_input("Say something...", key="re_query", disabled=model==""):
+            with st.chat_message("user"):
+                st.markdown(query)
+            
+            st.session_state.reasoning_msg.append({"role": "user", "content": query})
+
+            messages = [{"role": "system", "content": st.session_state.reasoning_sys}] + st.session_state.reasoning_msg
+
+            with st.chat_message("assistant"):
+                try:
+                    response = chat_completion(api_key, model, messages, tokens, temp, topp, freq, pres, st.session_state.reasoning_stop)
+                    result = st.write_stream(chunk.choices[0].delta.content for chunk in response if chunk.choices[0].delta.content is not None)
+                    st.session_state.reasoning_msg.append({"role": "assistant", "content": result})
+                except Exception as e:
+                    st.error(f"Error occured: {e}")
+            
+            st.session_state.reasoning_cache = st.session_state.reasoning_msg
+            st.rerun()
+
+        if retry_btn:
+            st.session_state.reasoning_msg.pop()
+            st.session_state.reasoning_cache = []
+            st.session_state.reasoning_retry = True
+            st.rerun()
+        if st.session_state.reasoning_retry:
+            for i in st.session_state.reasoning_msg:
+                with st.chat_message(i["role"]):
+                    st.markdown(i["content"])
+            
+            messages = [{"role": "system", "content": st.session_state.reasoning_sys}] + st.session_state.reasoning_msg
+
+            with st.chat_message("assistant"):
+                try:
+                    response = chat_completion(api_key, model, messages, tokens, temp, topp, freq, pres, st.session_state.reasoning_stop)
+                    result = st.write_stream(chunk.choices[0].delta.content for chunk in response if chunk.choices[0].delta.content is not None)
+                    st.session_state.reasoning_msg.append({"role": "assistant", "content": result})
+                except Exception as e:
+                    st.error(f"Error occured: {e}")
+            
+            st.session_state.reasoning_cache = st.session_state.reasoning_msg
+            st.session_state.reasoning_retry = False
+            st.rerun()
+
+    if clear_btn:
+        st.session_state.reasoning_tokens = 8192
+        st.session_state.reasoning_temp = 0.50
+        st.session_state.reasoning_topp = 0.70
+        st.session_state.reasoning_freq = 0.00
+        st.session_state.reasoning_pres = 0.00
+        st.session_state.reasoning_msg = []
+        st.session_state.reasoning_cache = []
+        st.session_state.reasoning_stop = None
+        st.rerun()
+
+    if undo_btn:
+        del st.session_state.reasoning_msg[-1]
+        del st.session_state.reasoning_cache[-1]
+        st.rerun()

requirements.txt

@@ -0,0 +1 @@
+openai

session_state.py

@@ -0,0 +1,25 @@
+import streamlit as st
+
+def set_session_state(mode: str, sys: str, tokens: int, temp: float):
+    if f"{mode}_sys" not in st.session_state:
+        st.session_state[f"{mode}_sys"] = sys
+    if f"{mode}_msg" not in st.session_state:
+        st.session_state[f"{mode}_msg"] = []
+    if f"{mode}_cache" not in st.session_state:
+        st.session_state[f"{mode}_cache"] = []
+    if f"{mode}_tokens" not in st.session_state:
+        st.session_state[f"{mode}_tokens"] = tokens
+    if f"{mode}_temp" not in st.session_state:
+        st.session_state[f"{mode}_temp"] = temp
+    if f"{mode}_topp" not in st.session_state:
+        st.session_state[f"{mode}_topp"] = 0.70
+    if f"{mode}_freq" not in st.session_state:
+        st.session_state[f"{mode}_freq"] = 0.00
+    if f"{mode}_pres" not in st.session_state:
+        st.session_state[f"{mode}_pres"] = 0.00
+    if f"{mode}_stop" not in st.session_state:
+        st.session_state[f"{mode}_stop"] = None
+    if f"{mode}_stop_str" not in st.session_state:
+        st.session_state[f"{mode}_stop_str"] = ""
+    if f"{mode}_retry" not in st.session_state:
+        st.session_state[f"{mode}_retry"] = False

template.py

@@ -0,0 +1,11 @@
+general_default_prompt = "You are a helpful assistant."
+
+visual_default_prompt = "Answer questions or perform tasks based on the image uploaded by the user."
+
+qwen_reasoning_prompt = "You are a helpful and harmless assistant. You are Qwen developed by Alibaba. You should think step-by-step."
+
+marco_reasoning_prompt = """你是一个经过良好训练的 AI 助手，你的名字是 Marco-o1，由阿里国际数字商业集团的 AI Business 创造。
+        
+## 重要！！！！！
+当你回答问题时，你的思考应该在 <Thought> 内完成，<Output> 内输出你的结果。<Thought> 应该尽可能是英文，但是有 2 个特例，一个是对原文中的引用，另一个是是数学应该使用 markdown 格式，<Output> 内的输出需要遵循用户输入的语言。
+"""

visual_chat.py

@@ -0,0 +1,160 @@
+import streamlit as st
+
+from session_state import set_session_state
+from chat import chat_completion
+from template import visual_default_prompt
+from model_config import visual_model_list
+
+def visualChat(api_key: str):
+    set_session_state("visual", visual_default_prompt, 4096, 0.50)
+    
+    if st.session_state.visual_msg == []:
+        disable = True
+    elif st.session_state.visual_msg != []:
+        disable = False
+    
+    with st.sidebar:
+        clear_btn = st.button("Clear", "vi_clear", type="primary", use_container_width=True, disabled=disable)
+        undo_btn = st.button("Undo", "vi_undo", use_container_width=True, disabled=disable)
+        retry_btn = st.button("Retry", "vi_retry", use_container_width=True, disabled=disable)
+
+        model_list = visual_model_list
+        model = st.selectbox("Model", model_list, 0, key="vi_model", disabled=not disable)
+
+        system_prompt = st.text_area("System Prompt", st.session_state.visual_sys, key="vi_sys", disabled=not disable)
+
+        with st.expander("Advanced Setting"):
+            tokens = st.slider("Max Tokens", 1, 4096, st.session_state.visual_tokens, 1, key="vi_tokens", disabled=not disable)
+            temp = st.slider("Temperature", 0.00, 2.00, st.session_state.visual_temp, 0.01, key="vi_temp", disabled=not disable)
+            topp = st.slider("Top P", 0.01, 1.00, st.session_state.visual_topp, 0.01, key="vi_topp", disabled=not disable)
+            freq = st.slider("Frequency Penalty", -2.00, 2.00, st.session_state.visual_freq, 0.01, key="vi_freq", disabled=not disable)
+            pres = st.slider("Presence Penalty", -2.00, 2.00, st.session_state.visual_pres, 0.01, key="vi_pres", disabled=not disable)
+            if st.toggle("Set stop", key="vi_stop_toggle", disabled=not disable):
+                st.session_state.general_stop = []
+                stop_str = st.text_input("Stop", st.session_state.visual_stop_str, key="vi_stop_str", disabled=not disable)
+                st.session_state.visual_stop_str = stop_str
+                submit_stop = st.button("Submit", "vi_submit_stop", disabled=not disable)
+                if submit_stop and stop_str:
+                    st.session_state.visual_stop.append(st.session_state.visual_stop_str)
+                    st.session_state.visual_stop_str = ""
+                    st.rerun()
+                if st.session_state.visual_stop:
+                    for stop_str in st.session_state.visual_stop:
+                        st.markdown(f"`{stop_str}`")
+
+        st.session_state.visual_sys = system_prompt
+        st.session_state.visual_tokens = tokens
+        st.session_state.visual_temp = temp
+        st.session_state.visual_topp = topp
+        st.session_state.visual_freq = freq
+        st.session_state.visual_pres = pres
+
+    image_type = ["PNG", "JPG", "JPEG"]
+    uploaded_image: list = st.file_uploader("Upload an image", type=image_type, accept_multiple_files=True, key="uploaded_image", disabled=not disable)
+    base64_image_list = []
+    if uploaded_image is not None:
+        from process_image import image_processor
+        with st.expander("Image"):
+            for i in uploaded_image:
+                st.image(uploaded_image, output_format="PNG")
+                base64_image_list.append(image_processor(i))
+
+    for i in st.session_state.visual_cache:
+        with st.chat_message(i["role"]):
+            st.markdown(i["content"])
+    
+    if query := st.chat_input("Say something...", key="vi_query", disabled=base64_image_list==[]):
+        with st.chat_message("user"):
+            st.markdown(query)
+        
+        st.session_state.visual_msg.append({"role": "user", "content": query})
+
+        if len(st.session_state.visual_msg) == 1:
+            messages = [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": []}
+            ]
+            for base64_img in base64_image_list:
+                img_url_obj = {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_img}", "detail": "high"}}
+                messages[1]["content"].append(img_url_obj)
+            messages[1]["content"].append({"type": "text", "text": query})
+        elif len(st.session_state.visual_msg) > 1:
+            messages = [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": []}
+            ]
+            for base64_img in base64_image_list:
+                img_url_obj = {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_img}", "detail": "high"}}
+                messages[1]["content"].append(img_url_obj)
+            messages[1]["content"].append({"type": "text", "text": st.session_state.visual_msg[0]["content"]})
+            messages += st.session_state.visual_msg[1:]
+        
+        with st.chat_message("assistant"):
+            try:
+                response = chat_completion(api_key, model, messages, tokens, temp, freq, pres, st.session_state.visual_stop)
+                result = st.write_stream(chunk.choices[0].delta.content for chunk in response if chunk.choices[0].delta.content is not None)
+                st.session_state.general_msg.append({"role": "assistant", "content": result})
+            except Exception as e:
+                st.error(f"Error occured: {e}")
+        
+        st.session_state.visual_cache = st.session_state.visual_msg
+        st.rerun()
+
+    if clear_btn:
+        st.session_state.visual_sys = visual_default_prompt
+        st.session_state.visual_tokens = 4096
+        st.session_state.visual_temp = 0.50
+        st.session_state.visual_topp = 0.70
+        st.session_state.visual_freq = 0.00
+        st.session_state.visual_pres = 0.00
+        st.session_state.visual_msg = []
+        st.session_state.visual_cache = []
+        st.session_state.visual_stop = None
+        st.rerun()
+
+    if undo_btn:
+        del st.session_state.visual_msg[-1]
+        del st.session_state.visual_cache[-1]
+        st.rerun()
+
+    if retry_btn:
+        st.session_state.visual_msg.pop()
+        st.session_state.visual_cache = []
+        st.session_state.visual_retry = True
+        st.rerun()
+    if st.session_state.visual_retry:
+        for i in st.session_state.visual_msg:
+            with st.chat_message(i["role"]):
+                st.markdown(i["content"])
+
+        if len(st.session_state.visual_msg) == 1:
+            messages = [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": []}
+            ]
+            for base64_img in base64_image_list:
+                img_url_obj = {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_img}", "detail": "high"}}
+                messages[1]["content"].append(img_url_obj)
+            messages[1]["content"].append({"type": "text", "text": st.session_state.visual_msg[0]["content"]})
+        elif len(st.session_state.visual_msg) > 1:
+            messages = [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": []}
+            ]
+            for base64_img in base64_image_list:
+                img_url_obj = {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{base64_img}", "detail": "high"}}
+                messages[1]["content"].append(img_url_obj)
+            messages[1]["content"].append({"type": "text", "text": st.session_state.visual_msg[0]["content"]})
+            messages += st.session_state.visual_msg[1:]
+        
+        with st.chat_message("assistant"):
+            try:
+                response = chat_completion(api_key, model, messages, tokens, temp, freq, pres, st.session_state.visual_stop)
+                result = st.write_stream(chunk.choices[0].delta.content for chunk in response if chunk.choices[0].delta.content is not None)
+                st.session_state.general_msg.append({"role": "assistant", "content": result})
+            except Exception as e:
+                st.error(f"Error occured: {e}")
+        
+        st.session_state.visual_cache = st.session_state.visual_msg
+        st.session_state.visual_retry = False
+        st.rerun()