Update app configuration and README for OpenRouter and Ollama support

- Update `.env` to include OpenRouter and Ollama configurations
- Modify `.gitignore` to ignore environment files
- Enhance `README.md` with detailed installation, configuration, and usage instructions
- Improve `app.py` to handle message validation and error responses

.env

@@ -1,4 +1,14 @@
-OPENAI_API_KEY=sk-xxxxx
-OPENAI_MODEL=gpt-4o
+# Choose one provider only
+USE_OPENROUTER=true
 USE_OLLAMA=false
-OLLAMA_MODEL=llama3
+
+# OpenRouter settings
+OPENROUTER_API_KEY=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
+OPENROUTER_MODEL=meta-llama/llama-3.3-8b-instruct:free
+
+# Ollama (if used)
+OLLAMA_MODEL=llama3
+
+# OpenAI fallback (if used)
+OPENAI_API_KEY=
+OPENAI_MODEL=gpt-4o

.gitignore

@@ -9,6 +9,11 @@ wheels/
 # Python bytecode and cache
 __pycache__/
 *.py[cod]
+
+# Environment files
+.env
+.env.local
+.env.*.local
 *$py.class
 
 # Distribution / packaging
@@ -34,6 +39,9 @@ share/python-wheels/
 MANIFEST
 /.python-version
 
+# Gradio
+.gradio/
+
 # PyInstaller
 *.manifest
 *.spec

README.md

@@ -1,20 +1,68 @@
 # 🤖 LLMates – Chat with Custom AI Personas
 
-LLMates is a minimal, modular chatbot app where you can switch between assistant personas powered by LLMs.
-It supports OpenAI (e.g. GPT-4o), or free alternatives like **Ollama** (LLaMA3, Mistral) or Hugging Face.
+LLMates is a minimal, modular chatbot application that allows you to switch between different AI assistant personas powered by language models. The application supports both cloud-based (OpenAI) and local (Ollama) model backends.
 
-## 💡 Personas
-- Python Tutor
-- Regex Helper
-- Motivational Coach
-- Startup Advisor
+## 🚀 Features
 
-## ⚙️ Stack
-- Gradio UI
-- OpenAI / Ollama / HF model backend
-- Modular Python
+- Multiple AI personas with distinct personalities and expertise
+- Support for OpenAI models (including GPT-4o) and local models via Ollama
+- Simple and intuitive Gradio-based web interface
+- Easy configuration through environment variables
+
+## 💡 Available Personas
+
+- **Python Tutor**: Get help with Python programming concepts and debugging
+- **Regex Helper**: Expert assistance with regular expressions
+- **Motivational Coach**: Encouraging and inspiring conversations
+- **Startup Advisor**: Practical advice for startups and entrepreneurship
+
+## 🛠️ Installation
+
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/yourusername/llmates.git
+   cd llmates
+   ```
+
+2. Install the required dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. Create a `.env` file and configure your settings (see Configuration section below)
+
+## ⚙️ Configuration
+
+Copy the example `.env` file and update it with your settings:
+
+```env
+# OpenAI Configuration (required if not using Ollama)
+OPENAI_API_KEY=your_openai_api_key
+OPENAI_MODEL=gpt-4o  # or any other OpenAI model
+
+# Ollama Configuration (set to true to use local models)
+USE_OLLAMA=false
+OLLAMA_MODEL=llama3  # or any other Ollama model
+
+# Application Settings
+DEFAULT_PERSONA="Python Tutor"
+TEMPERATURE=0.7
+MAX_TURNS=10
+```
+
+## 🚀 Running the Application
+
+Start the application with:
 
-## 🧪 Run Locally
 ```bash
-pip install -r requirements.txt
-python app.py
+python app.py
+```
+
+The application will start a local web server, and you can access it in your browser at `http://localhost:7860`.
+
+## 🛠️ Tech Stack
+
+- **UI**: Gradio
+- **Backend**: OpenAI API / Ollama
+- **Language**: Python 3.8+
+- **Configuration**: Environment variables via python-dotenv

app.py

@@ -4,23 +4,72 @@ from utils import generate_response
 from config import DEFAULT_PERSONA
 
 
-def chat_fn(persona, user_input, history):
-    return generate_response(PERSONAS[persona], user_input, history)
+def handle_message(persona, user_input, history):
+    """
+    Handle a new message in the chat.
 
+    Args:
+        persona (str): The selected persona
+        user_input (str): The user's message
+        history (list): Chat history in messages format
 
-with gr.Blocks() as app:
+    Returns:
+        list: Updated chat history with new messages
+    """
+    # Validate inputs
+    if not persona or persona not in PERSONAS:
+        return history + [
+            {"role": "assistant", "content": "Please select a valid persona"}
+        ]
+
+    if not user_input.strip():
+        return history + [
+            {"role": "assistant", "content": "Please enter a message"}
+        ]
+
+    try:
+        # Get response from model
+        return generate_response(PERSONAS[persona], user_input, history)
+    except Exception as e:
+        # Return error message in proper format
+        return history + [
+            {"role": "assistant", "content": f"Error: {str(e)}"}
+        ]
+
+with gr.Blocks() as demo:
     gr.Markdown("## 🤖 LLMates: Persona-based Chat Assistant")
 
     persona = gr.Dropdown(
         choices=list(PERSONAS.keys()), value=DEFAULT_PERSONA, label="Choose Persona"
     )
-    chatbox = gr.Chatbot(label="LLMates")
+    chatbox = gr.Chatbot(label="LLMates", type="messages")
     msg = gr.Textbox(label="Type your message...")
-    state = gr.State([])
+    chat_history = gr.State([])
+
+    def user_submit(user_input, history, persona):
+        if not user_input.strip():
+            return ([], history, "")  # Return empty chatbox update but keep history and clear input
+
+        if not persona or persona not in PERSONAS:
+            return ([], history + [{"role": "assistant", "content": "Please select a valid persona"}], "")
+
+        try:
+            # Get response from model
+            new_history = generate_response(PERSONAS[persona], user_input, history)
+            return (new_history, new_history, "")  # Clear input after successful submission
+        except Exception as e:
+            return ([], history + [{"role": "assistant", "content": f"Error: {str(e)}"}], "")
+
+    def clear_history():
+        """Clear the chat history and reset message input when persona changes"""
+        return ([], [], "")  # Clear chatbox, history state, and message input
 
-    def user_submit(user_input, history):
-        return chat_fn(persona.value, user_input, history)
+    # Clear chat history and reset message input when persona changes
+    persona.change(clear_history, outputs=[chatbox, chat_history, msg])
 
-    msg.submit(user_submit, [msg, state], [chatbox, state])
+    # Handle message submission
+    msg.submit(user_submit, [msg, chat_history, persona], [chatbox, chat_history, msg])
 
-app.launch()
+# main function
+if __name__ == "__main__":
+    demo.launch()

config.py

@@ -3,13 +3,20 @@ from dotenv import load_dotenv
 
 load_dotenv()
 
-# Model and key
+# OpenAI configuration
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 OPENAI_MODEL = os.getenv("OPENAI_MODEL", "gpt-4o")
+
+# Ollama configuration
 USE_OLLAMA = os.getenv("USE_OLLAMA", "false").lower() == "true"
 OLLAMA_MODEL = os.getenv("OLLAMA_MODEL", "llama3")
 
+# OpenRouter configuration
+USE_OPENROUTER = os.getenv("USE_OPENROUTER", "false").lower() == "true"
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "")
+OPENROUTER_MODEL = os.getenv("OPENROUTER_MODEL", "openai/gpt-4")
+
 # UI + LLM behavior config
-DEFAULT_PERSONA = "Python Tutor"
+DEFAULT_PERSONA = "Startup Advisor"
 TEMPERATURE = 0.7
 MAX_TURNS = 10

utils.py

@@ -1,73 +1,88 @@
-from config import OPENAI_API_KEY, OPENAI_MODEL, USE_OLLAMA, OLLAMA_MODEL
 import requests
 import openai
+from config import (
+    OPENAI_API_KEY,
+    OPENAI_MODEL,
+    USE_OLLAMA,
+    OLLAMA_MODEL,
+    USE_OPENROUTER,
+    OPENROUTER_API_KEY,
+    OPENROUTER_MODEL,
+    TEMPERATURE,
+)
 
 openai.api_key = OPENAI_API_KEY
 
 
 def query_openai(messages):
-    """Query the OpenAI API with the given messages.
-
-    Args:
-        messages (list): A list of message dictionaries, where each dictionary contains
-                       'role' and 'content' keys representing the conversation history.
-
-    Returns:
-        str: The assistant's response as a string, or an error message if the API call fails.
-    """
     try:
-        response = openai.ChatCompletion.create(model=OPENAI_MODEL, messages=messages)
+        response = openai.ChatCompletion.create(
+            model=OPENAI_MODEL, messages=messages, temperature=TEMPERATURE
+        )
         return response["choices"][0]["message"]["content"]
     except Exception as e:
         return f"⚠️ OpenAI Error: {e}"
 
 
-def query_ollama(prompt):
-    """Query a local Ollama instance with the given prompt.
+def query_openrouter(messages):
+    headers = {
+        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+        "Content-Type": "application/json",
+    }
+    payload = {
+        "model": OPENROUTER_MODEL,
+        "messages": messages,
+        "temperature": TEMPERATURE,
+    }
+    try:
+        response = requests.post(
+            "https://openrouter.ai/api/v1/chat/completions",
+            headers=headers,
+            json=payload,
+        )
+        return response.json()["choices"][0]["message"]["content"]
+    except Exception as e:
+        return f"⚠️ OpenRouter Error: {e}"
 
-    Args:
-        prompt (str): The input prompt to send to the Ollama model.
 
-    Returns:
-        str: The model's response as a string, or an error message if the API call fails.
-    """
+def query_ollama(prompt):
     try:
-        res = requests.post(
+        response = requests.post(
             "http://localhost:11434/api/generate",
             json={"model": OLLAMA_MODEL, "prompt": prompt},
         )
-        return res.json()["response"]
+        return response.json()["response"]
     except Exception as e:
         return f"⚠️ Ollama Error: {e}"
 
 
-def generate_response(persona, user_input, history):
-    """Generate a response using either OpenAI or Ollama based on configuration.
-
-    Args:
-        persona (str): The system prompt or persona that defines the assistant's behavior.
-        user_input (str): The latest user input message.
-        history (list): A list of tuples representing the conversation history,
-                      where each tuple is (user_message, bot_response).
-
-    Returns:
-        tuple: A tuple containing:
-            - Updated conversation history including the new exchange
-            - The same history (for compatibility with some interfaces)
-    """
+def generate_response(persona_prompt, user_input, history):
+    # Handle Ollama case
     if USE_OLLAMA:
-        full_prompt = f"{persona}\n\n"
-        for u, b in history:
-            full_prompt += f"User: {u}\nBot: {b}\n"
+        # Convert history to Ollama format
+        full_prompt = f"{persona_prompt}\n\n"
+        for msg in history:
+            full_prompt += f"{msg['role'].capitalize()}: {msg['content']}\n"
         full_prompt += f"User: {user_input}\nBot:"
+
         reply = query_ollama(full_prompt)
+        return history + [
+            {"role": "user", "content": user_input},
+            {"role": "assistant", "content": reply}
+        ]
+
+    # Handle OpenAI/OpenRouter case
+    messages = [{"role": "system", "content": persona_prompt}]
+    messages.extend(history)
+    messages.append({"role": "user", "content": user_input})
+
+    if USE_OPENROUTER:
+        reply = query_openrouter(messages)
     else:
-        messages = [{"role": "system", "content": persona}]
-        for u, b in history:
-            messages.append({"role": "user", "content": u})
-            messages.append({"role": "assistant", "content": b})
-        messages.append({"role": "user", "content": user_input})
         reply = query_openai(messages)
 
-    history.append((user_input, reply))
-    return history, history
+    # Return the complete history with the new messages
+    return history + [
+        {"role": "user", "content": user_input},
+        {"role": "assistant", "content": reply}
+    ]