Upload folder using huggingface_hub

GradioLMstudioInterface.py

@@ -1,103 +1,93 @@
 import gradio as gr
 import requests
 
-# LM Studio REST API base URL
+# Base URL for LM Studio REST API
 BASE_URL = "http://localhost:1234/api/v0"
 
-# Function to handle chat completions
-def chat_with_lmstudio(messages):
-    url = f"{BASE_URL}/chat/completions"
+# Chat completions function
+def chat_with_lmstudio(messages, model, temperature=0.7, max_tokens=150):
+    endpoint = f"{BASE_URL}/chat/completions"
     payload = {
-        "model": "granite-3.0-2b-instruct",  # Replace with the model you have loaded
+        "model": model,
         "messages": messages,
-        "temperature": 0.7,
-        "max_tokens": 1024,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
         "stream": False
     }
-    response = requests.post(url, json=payload)
-    response.raise_for_status()
-    response_data = response.json()
-    return response_data['choices'][0]['message']['content']
+    try:
+        response = requests.post(endpoint, json=payload)
+        response.raise_for_status()
+        data = response.json()
+        return data["choices"][0]["message"]["content"]
+    except requests.RequestException as e:
+        return f"Error: {str(e)}"
 
-# Function to handle text completions
-def get_text_completion(prompt):
-    url = f"{BASE_URL}/completions"
+# Text completions function
+def text_completion(prompt, model, temperature=0.7, max_tokens=150):
+    endpoint = f"{BASE_URL}/completions"
     payload = {
-        "model": "granite-3.0-2b-instruct",  # Replace with the model you have loaded
+        "model": model,
         "prompt": prompt,
-        "temperature": 0.7,
-        "max_tokens": 100,
+        "temperature": temperature,
+        "max_tokens": max_tokens,
         "stream": False
     }
-    response = requests.post(url, json=payload)
-    response.raise_for_status()
-    response_data = response.json()
-    return response_data['choices'][0]['text']
+    try:
+        response = requests.post(endpoint, json=payload)
+        response.raise_for_status()
+        data = response.json()
+        return data["choices"][0]["text"]
+    except requests.RequestException as e:
+        return f"Error: {str(e)}"
 
-# Function to handle text embeddings
-def get_text_embedding(text):
-    url = f"{BASE_URL}/embeddings"
+# Embeddings function
+def text_embedding(text, model):
+    endpoint = f"{BASE_URL}/embeddings"
     payload = {
-        "model": "text-embedding-nomic-embed-text-v1.5",  # Replace with your embedding model
+        "model": model,
         "input": text
     }
-    response = requests.post(url, json=payload)
-    response.raise_for_status()
-    response_data = response.json()
-    return response_data['data'][0]['embedding']
+    try:
+        response = requests.post(endpoint, json=payload)
+        response.raise_for_status()
+        data = response.json()
+        return data["data"][0]["embedding"]
+    except requests.RequestException as e:
+        return f"Error: {str(e)}"
 
-# Gradio interface for chat
-def gradio_chat_interface():
-    def chat_interface(user_input, history):
-        # Format history in LM Studio messages format
-        messages = []
-        for user_msg, assistant_msg in history:
-            messages.append({"role": "user", "content": user_msg})
-            messages.append({"role": "assistant", "content": assistant_msg})
-        messages.append({"role": "user", "content": user_input})
-        
-        # Get response from LM Studio
-        response = chat_with_lmstudio(messages)
-        
-        # Update history with the assistant's response
-        history.append((user_input, response))
-        return history, history
+# Gradio Interface
+def chat_interface(user_message, history, model="granite-3.0-2b-instruct"):
+    if history is None:
+        history = []
+    history.append({"role": "user", "content": user_message})
+    assistant_response = chat_with_lmstudio(history, model=model)
+    history.append({"role": "assistant", "content": assistant_response})
+    conversation = [(h["content"], history[i+1]["content"]) for i, h in enumerate(history[:-1]) if h["role"] == "user"]
+    return conversation, history
 
-    chat_interface = gr.ChatInterface(chat_interface)
-    chat_interface.launch()
+with gr.Blocks() as demo:
+    gr.Markdown("# LM Studio API Interface")
 
-# Gradio interface for text completion
-def gradio_text_completion():
-    gr.Interface(
-        fn=get_text_completion,
-        inputs="text",
-        outputs="text",
-        title="Text Completion with LM Studio"
-    ).launch()
+    with gr.Tab("Chat with Model"):
+        chat_history = gr.State([])
+        chat_model = gr.Textbox(value="granite-3.0-2b-instruct", label="Model")
+        chatbot = gr.Chatbot()
+        msg = gr.Textbox(placeholder="Enter your message", label="User Input")
+        submit_btn = gr.Button("Send")
+        submit_btn.click(chat_interface, inputs=[msg, chat_history, chat_model], outputs=[chatbot, chat_history])
 
-# Gradio interface for text embedding
-def gradio_text_embedding():
-    gr.Interface(
-        fn=get_text_embedding,
-        inputs="text",
-        outputs="text",
-        title="Text Embedding with LM Studio"
-    ).launch()
+    with gr.Tab("Text Completion"):
+        completion_prompt = gr.Textbox(placeholder="Enter a prompt for text completion", label="Prompt")
+        completion_model = gr.Textbox(value="granite-3.0-2b-instruct", label="Model")
+        completion_output = gr.Textbox(label="Completion")
+        generate_btn = gr.Button("Generate")
+        generate_btn.click(text_completion, inputs=[completion_prompt, completion_model], outputs=completion_output)
 
-# Main menu to choose the interface
-def main():
-    with gr.Blocks() as demo:
-        gr.Markdown("""
-        # LM Studio API Interface
-        Choose which function you want to use with LM Studio:
-        """)
-        
-        with gr.Row():
-            gr.Button("Chat with Model").click(gradio_chat_interface)
-            gr.Button("Text Completion").click(gradio_text_completion)
-            gr.Button("Text Embedding").click(gradio_text_embedding)
+    with gr.Tab("Text Embeddings"):
+        embedding_text = gr.Textbox(placeholder="Enter text for embeddings", label="Input Text")
+        embedding_model = gr.Textbox(value="text-embedding-nomic-embed-text-v1.5", label="Model")
+        embedding_output = gr.JSON(label="Embeddings")
+        embed_btn = gr.Button("Get Embeddings")
+        embed_btn.click(text_embedding, inputs=[embedding_text, embedding_model], outputs=embedding_output)
 
-    demo.launch()
-
-if __name__ == "__main__":
-    main()
+    demo.launch(share=True)