feat: Add environment-based configuration and chat history support

.env.example

@@ -0,0 +1,12 @@
+# Ollama Configuration
+# For local development, use localhost
+# OLLAMA_BASE_URL=http://localhost:11434
+
+# For Hugging Face Space deployment
+# Replace with your actual Ollama server endpoint
+# If hosting on Hugging Face Spaces, use your Space URL:
+# OLLAMA_BASE_URL=https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME
+OLLAMA_BASE_URL=https://huggingface.co/spaces/bahadur3093/ollama-server
+
+# Environment (development, production)
+NODE_ENV=production

.gitignore

@@ -28,9 +28,11 @@ yarn-error.log*
 # local env files
 .env*.local
 .env
+.env.local
 .env.development.local
 .env.test.local
 .env.production.local
+!.env.example
 
 # vercel
 .vercel

HUGGINGFACE_DEPLOYMENT.md

@@ -0,0 +1,141 @@
+# Hugging Face Spaces Deployment Guide
+
+## Your Space Information
+- **Space URL**: https://huggingface.co/spaces/bahadur3093/ollama-server
+- **Space Type**: Gradio App
+
+## Environment Configuration for Hugging Face Spaces
+
+### Setting Up Environment Variables (Secrets)
+
+Since your Space is hosted on Hugging Face, you need to configure the `OLLAMA_BASE_URL` as a **Space Secret**:
+
+1. **Go to your Space Settings**:
+   - Navigate to: https://huggingface.co/spaces/bahadur3093/ollama-server/settings
+
+2. **Add Repository Secret**:
+   - Scroll to the "Repository secrets" section
+   - Click "New secret"
+   - Name: `OLLAMA_BASE_URL`
+   - Value: Your actual Ollama server URL (see options below)
+
+### Ollama Server Options for Hugging Face Deployment
+
+#### Option 1: External Ollama Server (Recommended)
+If you have an Ollama server running elsewhere:
+```
+OLLAMA_BASE_URL=https://your-ollama-server.com
+```
+
+#### Option 2: Self-Hosted Ollama API
+If you're running Ollama on a VPS or cloud instance:
+```
+OLLAMA_BASE_URL=http://your-server-ip:11434
+```
+
+#### Option 3: Hugging Face Inference API
+If you want to use Hugging Face's inference endpoints:
+```
+OLLAMA_BASE_URL=https://api-inference.huggingface.co/models
+```
+(Note: This requires adapting the API format)
+
+#### Option 4: Local Testing
+For local development (already configured in app.py):
+```
+OLLAMA_BASE_URL=http://localhost:11434
+```
+
+## Committing Changes to Hugging Face
+
+### Important Files to Commit
+
+✅ **DO COMMIT**:
+- `app.py` (updated with environment variable support)
+- `requirements.txt`
+- `README.md`
+- `.gitignore`
+
+❌ **DO NOT COMMIT**:
+- `.env.local` (contains local development settings)
+- `.env` (if it exists)
+
+These files are already excluded in `.gitignore`
+
+### Deployment Steps
+
+1. **Commit your changes**:
+   ```bash
+   git add app.py requirements.txt README.md .gitignore
+   git commit -m "Add environment-based Ollama URL configuration"
+   ```
+
+2. **Push to Hugging Face**:
+   ```bash
+   git push origin main
+   ```
+
+3. **Set the Secret** (if not already done):
+   - Go to Space Settings → Repository secrets
+   - Add `OLLAMA_BASE_URL` with your production Ollama server URL
+
+4. **Verify Deployment**:
+   - Your Space will automatically rebuild
+   - Check the UI - it should display "Connected to: [your-url]"
+   - Test with a prompt to ensure connectivity
+
+## Current Configuration
+
+### app.py Changes
+- ✅ Reads `OLLAMA_BASE_URL` from environment variables
+- ✅ Falls back to `http://localhost:11434` for local development
+- ✅ Displays connected server URL in the UI
+- ✅ Improved error handling with timeout and detailed error messages
+
+### Local Development Workflow
+
+1. **For local testing** (using localhost Ollama):
+   ```bash
+   # No environment variable needed - defaults to localhost:11434
+   python app.py
+   ```
+
+2. **For testing with remote Ollama**:
+   ```bash
+   export OLLAMA_BASE_URL=https://your-test-server.com
+   python app.py
+   ```
+
+## Troubleshooting
+
+### Issue: "Could not connect to Ollama server"
+**Solution**: 
+- Verify `OLLAMA_BASE_URL` is set correctly in Space secrets
+- Ensure your Ollama server is accessible from Hugging Face (public URL)
+- Check firewall rules on your Ollama server
+
+### Issue: Space not updating after commit
+**Solution**:
+- Check the "Logs" tab in your Space
+- Verify the build completed successfully
+- Try a hard refresh (Ctrl+Shift+R)
+
+### Issue: Environment variable not working
+**Solution**:
+- Ensure the secret name is exactly `OLLAMA_BASE_URL` (case-sensitive)
+- Restart your Space after adding secrets
+- Check Space logs for any errors
+
+## Next Steps
+
+1. ✅ Set `OLLAMA_BASE_URL` in Hugging Face Space secrets
+2. ✅ Commit and push changes to Hugging Face
+3. ✅ Test the deployed Space
+4. ✅ Monitor logs for any connection issues
+
+## Notes
+
+- The `.env.local` file is for **local development only** and should never be committed
+- Hugging Face Spaces uses **repository secrets** for environment variables
+- The app automatically switches between local and production URLs based on environment
+- No special deployment configuration needed - just set the secret and push!

README_CONFIGURATION.md

@@ -0,0 +1,146 @@
+# Ollama Chat Configuration Guide
+
+## Overview
+This application now supports conversation memory and environment-based configuration for switching between local Ollama (testing) and production Ollama servers.
+
+## What Was Fixed
+
+### 1. **Conversation Memory Issue**
+The model wasn't remembering previous messages because:
+- The app was using Ollama's `/api/generate` endpoint (stateless, single prompt)
+- No conversation history was being passed to the model
+
+**Solution:**
+- Switched to Ollama's `/api/chat` endpoint
+- Now reads chat history from `chat-history.json` and passes all previous messages to the model
+- The model now maintains full conversation context
+
+### 2. **Environment-Based Configuration**
+Added support for automatic switching between local and production Ollama servers.
+
+## Configuration
+
+### Environment Variables
+
+Create a `.env.local` file in the root directory:
+
+```bash
+# For local development (default)
+OLLAMA_BASE_URL=http://localhost:11434
+NODE_ENV=development
+
+# For production deployment
+# OLLAMA_BASE_URL=https://your-ollama-server.com
+# NODE_ENV=production
+```
+
+### Automatic Switching
+
+The application will automatically use:
+- **Local Ollama** (`http://localhost:11434`) when `OLLAMA_BASE_URL` is not set
+- **Production Ollama** when you set `OLLAMA_BASE_URL` to your deployed server
+
+### Deployment Setup
+
+#### Option 1: Environment Variables (Recommended)
+Set the `OLLAMA_BASE_URL` environment variable in your deployment platform:
+
+**Vercel:**
+```bash
+vercel env add OLLAMA_BASE_URL
+# Enter: https://your-ollama-server.com
+```
+
+**Docker:**
+```bash
+docker run -e OLLAMA_BASE_URL=https://your-ollama-server.com ...
+```
+
+**Railway/Render/Heroku:**
+Add `OLLAMA_BASE_URL` in the environment variables section of your dashboard.
+
+#### Option 2: Git-Based Switching
+Create different `.env` files for different environments:
+
+```bash
+# .env.development (for local)
+OLLAMA_BASE_URL=http://localhost:11434
+
+# .env.production (for deployment)
+OLLAMA_BASE_URL=https://your-ollama-server.com
+```
+
+Add to `.gitignore`:
+```
+.env.local
+.env*.local
+```
+
+Commit only `.env.example` to git, and set up your CI/CD to copy the appropriate file during deployment.
+
+## Testing
+
+### Local Testing
+1. Make sure Ollama is running locally:
+   ```bash
+   ollama serve
+   ```
+
+2. Start the development server:
+   ```bash
+   npm run dev
+   ```
+
+3. The app will connect to `http://localhost:11434`
+
+### Production Testing
+1. Set `OLLAMA_BASE_URL` to your production server
+2. Build and deploy:
+   ```bash
+   npm run build
+   npm start
+   ```
+
+## How It Works
+
+### Conversation Flow
+1. User sends a message
+2. Message is saved to `chat-history.json`
+3. API reads all previous messages from history
+4. Sends complete conversation to Ollama's `/api/chat` endpoint
+5. Model responds with context from entire conversation
+6. Response is saved to history and displayed
+
+### API Endpoints Updated
+- `pages/api/generate.ts` - Now uses chat API with history
+- `pages/api/models.ts` - Uses environment-based URL
+- `pages/api/pull.ts` - Uses environment-based URL
+
+### Configuration Files
+- `next.config.js` - Exposes `OLLAMA_BASE_URL` to the app
+- `.env.local` - Local environment configuration (not committed)
+- `.env.example` - Template for environment variables (committed)
+
+## Troubleshooting
+
+### Model not remembering conversations
+- Check that `chat-history.json` exists and contains messages
+- Verify the API is using `/api/chat` endpoint (not `/api/generate`)
+- Clear chat history and start a new conversation
+
+### Connection errors
+- Verify `OLLAMA_BASE_URL` is set correctly
+- Check that Ollama server is running and accessible
+- Test the URL directly: `curl http://localhost:11434/api/tags`
+
+### Environment variable not working
+- Restart the development server after changing `.env.local`
+- Verify the variable is set: `console.log(process.env.OLLAMA_BASE_URL)`
+- For production, ensure the platform has the environment variable set
+
+## Additional Notes
+
+- The chat history is stored in `chat-history.json` in the project root
+- Clearing chat history (🗑️ button) will reset the conversation context
+- Each message includes metadata (timestamp, model used)
+- The system automatically filters and formats messages for Ollama's API

app.py

@@ -1,22 +1,30 @@
 import requests
 import gradio as gr
+import os
 
-OLLAMA_URL = "http://localhost:11434/api/generate"
+# Environment-based configuration
+# For Hugging Face Spaces, set OLLAMA_BASE_URL in Space secrets
+# For local development, it defaults to localhost
+OLLAMA_BASE_URL = os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
+OLLAMA_URL = f"{OLLAMA_BASE_URL}/api/generate"
 
 def generate_response(model, prompt):
-    response = requests.post(
-        OLLAMA_URL,
-        json={
-            "model": model,
-            "prompt": prompt,
-            "stream": False
-        }
-    )
-    
     try:
+        response = requests.post(
+            OLLAMA_URL,
+            json={
+                "model": model,
+                "prompt": prompt,
+                "stream": False
+            },
+            timeout=30
+        )
+        response.raise_for_status()
         return response.json()["response"]
-    except:
-        return "Error: Could not get response"
+    except requests.exceptions.RequestException as e:
+        return f"Error: Could not connect to Ollama server at {OLLAMA_BASE_URL}. Details: {str(e)}"
+    except Exception as e:
+        return f"Error: {str(e)}"
 
 # 🔥 Available models (you can update this)
 models = [
@@ -28,7 +36,8 @@ models = [
 
 # UI
 with gr.Blocks() as app:
-    gr.Markdown("# 🚀 Your Ollama UI")
+    gr.Markdown(f"# 🚀 Your Ollama UI")
+    gr.Markdown(f"**Connected to:** `{OLLAMA_BASE_URL}`")
 
     model_dropdown = gr.Dropdown(models, value="mistral", label="Select Model")
     prompt_input = gr.Textbox(lines=5, label="Enter Prompt")

next.config.js

@@ -1,6 +1,9 @@
 /** @type {import('next').NextConfig} */
 const nextConfig = {
   reactStrictMode: true,
+  env: {
+    OLLAMA_BASE_URL: process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
+  },
 }
 
 module.exports = nextConfig

pages/api/generate.ts

@@ -1,4 +1,36 @@
 import type { NextApiRequest, NextApiResponse } from "next"
+import fs from "fs"
+import path from "path"
+
+const CHAT_HISTORY_FILE = path.join(process.cwd(), "chat-history.json")
+
+interface ChatMessage {
+  role: "user" | "assistant" | "system"
+  content: string
+}
+
+// Get Ollama base URL from environment variable
+const OLLAMA_BASE_URL = process.env.OLLAMA_BASE_URL || "http://localhost:11434"
+
+// Read chat history from file
+function readChatHistory(): ChatMessage[] {
+  try {
+    if (fs.existsSync(CHAT_HISTORY_FILE)) {
+      const data = fs.readFileSync(CHAT_HISTORY_FILE, "utf-8")
+      const history = JSON.parse(data)
+      // Convert stored messages to Ollama format (only user and assistant roles)
+      return history.messages
+        .filter((msg: any) => msg.role === "user" || msg.role === "assistant")
+        .map((msg: any) => ({
+          role: msg.role,
+          content: msg.content,
+        }))
+    }
+  } catch (error) {
+    console.error("Error reading chat history:", error)
+  }
+  return []
+}
 
 export default async function handler(
   req: NextApiRequest,
@@ -11,12 +43,22 @@ export default async function handler(
   const { model, prompt } = req.body
 
   try {
-    const ollamaRes = await fetch("http://localhost:11434/api/generate", {
+    // Get conversation history
+    const conversationHistory = readChatHistory()
+    
+    // Add current user message to the conversation
+    const messages = [
+      ...conversationHistory,
+      { role: "user" as const, content: prompt },
+    ]
+
+    // Use chat endpoint instead of generate to maintain conversation context
+    const ollamaRes = await fetch(`${OLLAMA_BASE_URL}/api/chat`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
         model,
-        prompt,
+        messages,
         stream: false,
       }),
     })
@@ -24,6 +66,7 @@ export default async function handler(
     const data = await ollamaRes.json()
     res.status(200).json(data)
   } catch (err) {
+    console.error("Ollama API error:", err)
     res.status(500).json({ error: "Failed to connect to Ollama" })
   }
 }

pages/api/models.ts

@@ -1,6 +1,7 @@
 import type { NextApiRequest, NextApiResponse } from "next"
 
-const OLLAMA = "http://localhost:11434"
+// Get Ollama base URL from environment variable
+const OLLAMA_BASE_URL = process.env.OLLAMA_BASE_URL || "http://localhost:11434"
 
 export default async function handler(
   req: NextApiRequest,
@@ -9,7 +10,7 @@ export default async function handler(
   // GET → list all models
   if (req.method === "GET") {
     try {
-      const r = await fetch(`${OLLAMA}/api/tags`)
+      const r = await fetch(`${OLLAMA_BASE_URL}/api/tags`)
       const data = await r.json()
       res.status(200).json(data)
     } catch {
@@ -22,7 +23,7 @@ export default async function handler(
   if (req.method === "DELETE") {
     const { name } = req.body
     try {
-      const r = await fetch(`${OLLAMA}/api/delete`, {
+      const r = await fetch(`${OLLAMA_BASE_URL}/api/delete`, {
         method: "DELETE",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ name }),

pages/api/pull.ts

@@ -1,5 +1,8 @@
 import type { NextApiRequest, NextApiResponse } from "next"
 
+// Get Ollama base URL from environment variable
+const OLLAMA_BASE_URL = process.env.OLLAMA_BASE_URL || "http://localhost:11434"
+
 export default async function handler(
   req: NextApiRequest,
   res: NextApiResponse
@@ -15,7 +18,7 @@ export default async function handler(
   }
 
   try {
-    const r = await fetch("http://localhost:11434/api/pull", {
+    const r = await fetch(`${OLLAMA_BASE_URL}/api/pull`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ name, stream: false }),

pages/index.tsx

@@ -178,7 +178,7 @@ export default function Home() {
       const assistantMessage: ChatMessage = {
         id: `assistant-${Date.now()}`,
         role: "assistant",
-        content: data.response || data.error || "No response",
+        content: data.message?.content || data.response || data.error || "No response",
         timestamp: Date.now(),
         model,
       }