feat: init

.gitignore

@@ -0,0 +1,2 @@
+venv
+.idea

app.py

@@ -0,0 +1,254 @@
+import gradio as gr
+import aiohttp
+import asyncio
+import json
+
+# Define the types and their associated models with labels and values
+types_and_models = {
+    'deepinfra': [
+        ('Llama 8B', 'meta-llama/Meta-Llama-3.1-8B-Instruct'),
+        ('Llama 70B', 'meta-llama/Meta-Llama-3.1-70B-Instruct'),
+        ('Llama 405B', 'meta-llama/Meta-Llama-3.1-405B-Instruct'),
+        ('Qwen 72B', 'Qwen/Qwen2.5-72B-Instruct'),
+    ],
+    'groq': [
+        ('Llama 3.1 8B Instant', 'llama-3.1-8b-instant'),
+        ('Llama 3.1 70B Versatile', 'llama-3.1-70b-versatile'),
+        ('Gemma 9B IT', 'gemma2-9b-it'),
+        ('Llama3 Groq 70B Preview', 'llama3-groq-70b-8192-tool-use-preview'),
+        ('Llama3 Groq 8B Preview', 'llama3-groq-8b-8192-tool-use-preview'),
+    ],
+    'openai': [
+        ('GPT-4o Mini', 'gpt-4o-mini'),
+        ('GPT-4o', 'gpt-4o'),
+    ],
+}
+
+
+def update_models(selected_type):
+    # Update the models dropdown based on the selected type
+    choices = types_and_models[selected_type]
+    default_value = choices[0][1]  # The value of the first model
+    return gr.update(choices=choices, value=default_value)
+
+
+async def chat_with_server(chat_history, api_key, base_url, selected_type, selected_model, temperature, max_tokens):
+    headers = {
+        'Content-Type': 'application/json',
+        'Authorization': f'Bearer {api_key}',
+    }
+
+    if base_url:
+        base_url = base_url
+    else:
+        base_url = 'http://localhost:3000'  # Default base URL
+
+    # Prepare the messages for the API
+    api_messages = []
+    for user_msg, assistant_msg in chat_history:
+        if user_msg is not None:
+            api_messages.append({'role': 'user', 'content': user_msg})
+        if assistant_msg is not None and not assistant_msg.startswith("Assistant is typing"):
+            api_messages.append({'role': 'assistant', 'content': assistant_msg})
+
+    payload = {
+        'type': selected_type,  # Include the selected type
+        'model': selected_model,
+        'messages': api_messages,
+        'temperature': temperature,
+        'max_tokens': int(max_tokens),
+        'stream': True,  # Enable streaming
+    }
+
+    # Initialize typing animation
+    if chat_history:
+        chat_history[-1][1] = "Assistant is typing"
+        yield chat_history
+
+    async with aiohttp.ClientSession() as session:
+        try:
+            # Start the server request asynchronously
+            response_task = asyncio.create_task(session.post(
+                f'{base_url}/v1/chat/completions',
+                headers=headers,
+                json=payload,
+                timeout=300
+            ))
+
+            # Typing animation variables
+            dots_count = 0
+            assistant_message = ''
+
+            while not response_task.done():
+                # Update typing animation
+                dots = '.' * ((dots_count % 3) + 1)
+                dots_count += 1
+                if chat_history:
+                    chat_history[-1][1] = f"Assistant is typing{dots}"
+                    yield chat_history
+                await asyncio.sleep(0.5)  # Wait before updating again
+
+            # Now get the response
+            response = await response_task
+            if response.status != 200:
+                error_message = f"Error {response.status}: {await response.text()}"
+                chat_history[-1][1] = error_message
+                yield chat_history
+                return
+
+            assistant_message = ''
+            # Read the streaming response
+            async for line in response.content:
+                line = line.decode('utf-8').strip()
+                if line == '':
+                    continue
+                if line == 'data: [DONE]':
+                    break
+                if line.startswith('data: '):
+                    data_str = line[6:].strip()
+                    if data_str:
+                        data = json.loads(data_str)
+                        if 'choices' in data and len(data['choices']) > 0:
+                            delta = data['choices'][0]['delta']
+                            if 'content' in delta:
+                                content = delta['content']
+                                assistant_message += content
+                                # Update the assistant's message in the chat
+                                chat_history[-1][1] = assistant_message
+                                yield chat_history
+            # Final update to the conversation
+            yield chat_history
+
+        except Exception as e:
+            error_message = f"Error: {str(e)}"
+            chat_history[-1][1] = error_message
+            yield chat_history
+
+
+def reset_chat():
+    return []
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Chat Application")
+
+    with gr.Row():
+        api_key = gr.Textbox(label="API Key", placeholder="Enter your API Key",
+                             value="ggkjgf", type="password", lines=1)
+        base_url = gr.Textbox(label="Base URL", placeholder="https://api.groq.com/openai/v1", lines=1)
+        selected_type = gr.Dropdown(
+            label="Type",
+            choices=list(types_and_models.keys()),
+            value=list(types_and_models.keys())[0]
+        )
+        # Initialize the selected_model with choices and value
+        initial_type = list(types_and_models.keys())[0]
+        initial_choices = types_and_models[initial_type]
+        selected_model = gr.Dropdown(
+            label="Model",
+            choices=initial_choices,
+            value=initial_choices[0][1]  # First model's value
+        )
+        temperature = gr.Slider(label="Temperature", minimum=0, maximum=1, value=0.3, step=0.1)
+        max_tokens = gr.Number(label="Max Tokens", value=4096)
+
+    # Initialize the chatbot component
+    chatbot = gr.Chatbot(elem_id="chatbot", height=400)
+
+    with gr.Row():
+        with gr.Column(scale=10):
+            user_input = gr.Textbox(
+                show_label=False,
+                placeholder="Type your message here...",
+                lines=5,
+                container=False
+            )
+        with gr.Column(min_width=50, scale=1):
+            send_button = gr.Button("Send", variant="primary")
+            reset_button = gr.Button("Reset Chat")
+
+    # Update the models dropdown when the type changes
+    selected_type.change(
+        update_models,
+        inputs=selected_type,
+        outputs=selected_model
+    )
+
+
+    def user(user_message, chat_history):
+        # Append the user's message to the chat history
+        if not chat_history:
+            chat_history = []
+        chat_history = chat_history + [[user_message, None]]
+        return user_message, chat_history
+
+        # Set up the event handlers
+
+
+    send_button.click(
+        user,
+        inputs=[user_input, chatbot],
+        outputs=[user_input, chatbot]
+    ).then(
+        chat_with_server,
+        inputs=[chatbot, api_key, base_url, selected_type, selected_model, temperature, max_tokens],
+        outputs=chatbot,
+    )
+
+    reset_button.click(reset_chat, outputs=chatbot)
+
+    # Include CSS to format code blocks and other markdown elements
+    gr.HTML("""
+    <style>
+    .message pre {
+        background-color: #f0f0f0;
+        padding: 10px;
+        border-radius: 5px;
+        overflow-x: auto;
+    }
+    .message code {
+        background-color: #f0f0f0;
+        padding: 2px 4px;
+        border-radius: 3px;
+    }
+    </style>
+    """)
+
+    # Add JavaScript for rendering Markdown and LaTeX
+    gr.HTML("""
+    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/katex@0.16.11/dist/katex.min.js" crossorigin="anonymous"></script>
+    <script src="https://cdn.jsdelivr.net/npm/katex@0.16.11/dist/contrib/auto-render.min.js" crossorigin="anonymous"></script>
+    <script>
+    function renderContent() {
+        const messages = document.querySelectorAll('.message');
+        messages.forEach((message) => {
+            // Render Markdown
+            message.innerHTML = marked.parse(message.innerHTML);
+            // Render LaTeX
+            renderMathInElement(message, {
+                delimiters: [
+                    {left: "$$", right: "$$", display: true},
+                    {left: "$", right: "$", display: false},
+                    {left: "\\(", right: "\\)", display: false},
+                    {left: "\\[", right: "\\]", display: true}
+                ],
+                throwOnError: false
+            });
+        });
+    }
+    // Observe changes in the chatbox to render content
+    const chatbox = document.querySelector('#chatbot');
+    const observer = new MutationObserver((mutations) => {
+        for (let mutation of mutations) {
+            if (mutation.addedNodes.length > 0) {
+                renderContent();
+            }
+        }
+    });
+    observer.observe(chatbox, {childList: true, subtree: true});
+    </script>
+    """)
+
+demo.queue()
+demo.launch()

requirements.txt

@@ -0,0 +1,2 @@
+gradio
+aiohttp