Initial commit

.env

@@ -0,0 +1,4 @@
+GOOGLE_AI_STUDIO_KEY=AIzaSyDdAWvaw8wW-PiljMKwGNNccPRMvG70MNA
+SUPABASE_URL=https://afuvukjavlffublsdvsa.supabase.co
+SUPABASE_SERVICE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImFmdXZ1a2phdmxmZnVibHNkdnNhIiwicm9sZSI6InNlcnZpY2Vfcm9sZSIsImlhdCI6MTc0NDA2NDY0MiwiZXhwIjoyMDU5NjQwNjQyfQ.3718kzdI96X23Ewrk_zh39mgKRD7PDB11P9Wv22Fk-Q
+HF_MODEL_ID=mradermacher/Huihui-gemma-3n-E4B-it-abliterated-GGUF

Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    software-properties-common \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first to leverage Docker cache
+COPY requirements.txt .
+RUN pip install -r requirements.txt
+
+# Copy the rest of the application
+COPY . .
+
+# Set environment variables
+ENV HOST=0.0.0.0
+ENV PORT=7860
+
+# Expose the port HF Spaces expects
+EXPOSE 7860
+
+# Start the FastAPI app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,63 @@
+# Gemma AI Assistant Space
+
+This Space hosts the backend API for the Gemma AI Assistant, a conversational AI that combines local LLM processing using HuggingFace Transformers and real-time chat capabilities with Google's Gemini API.
+
+## Features
+
+- FastAPI backend with async support
+- Local LLM using `mradermacher/Huihui-gemma-3n-E4B-it-abliterated-GGUF`
+- Gemini API integration for real-time chat
+- Supabase integration for data persistence
+- Containerized deployment
+
+## API Endpoints
+
+### POST /api/chat
+Process chat messages using either the local LLM or Gemini API.
+
+**Request Body:**
+```json
+{
+  "messages": [
+    {
+      "role": "user",
+      "content": "Hello, how are you?"
+    }
+  ],
+  "use_gemini": true,
+  "temperature": 0.7
+}
+```
+
+**Response:**
+```json
+{
+  "response": "I'm doing well, thank you! How can I help you today?"
+}
+```
+
+## Environment Variables Required
+
+- `GOOGLE_AI_STUDIO_KEY`: Your Google AI Studio API key
+- `SUPABASE_URL`: Your Supabase project URL
+- `SUPABASE_SERVICE_KEY`: Your Supabase service role key
+- `HF_MODEL_ID`: HuggingFace model ID (default: mradermacher/Huihui-gemma-3n-E4B-it-abliterated-GGUF)
+
+## Local Development
+
+1. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+2. Run the server:
+```bash
+uvicorn app:app --reload --port 7860
+```
+
+## Testing
+
+Run the tests using pytest:
+```bash
+pytest test_app.py -v
+```

app.py

@@ -0,0 +1,75 @@
+from fastapi import FastAPI, HTTPException, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Dict, Optional
+from supabase import create_client, Client
+import os
+from dotenv import load_dotenv
+
+from llm import LLMPipeline
+from chat import GeminiChat
+
+load_dotenv()
+
+app = FastAPI()
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # In production, replace with your frontend URL
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize Supabase client
+supabase_url = os.getenv("SUPABASE_URL")
+supabase_key = os.getenv("SUPABASE_SERVICE_KEY")
+
+if not supabase_url or not supabase_key:
+    raise ValueError("Supabase environment variables not set")
+
+supabase: Client = create_client(supabase_url, supabase_key)
+
+# Initialize AI models
+llm = LLMPipeline()
+gemini = GeminiChat()
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+class ChatRequest(BaseModel):
+    messages: List[Message]
+    use_gemini: bool = True
+    temperature: float = 0.7
+
+@app.post("/api/chat")
+async def chat(request: ChatRequest):
+    try:
+        if request.use_gemini:
+            # Use Gemini for interactive chat
+            response = await gemini.chat(
+                [{"role": m.role, "content": m.content} for m in request.messages],
+                temperature=request.temperature
+            )
+        else:
+            # Use local LLM for specific tasks
+            last_message = request.messages[-1].content
+            response = await llm.generate(last_message)
+        
+        # Store chat history in Supabase
+        supabase.table("chat_history").insert({
+            "messages": [m.dict() for m in request.messages],
+            "response": response,
+            "model": "gemini" if request.use_gemini else "local"
+        }).execute()
+        
+        return {"response": response}
+    
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

chat.py

@@ -0,0 +1,27 @@
+import google.generativeai as genai
+from typing import List, Dict
+import os
+
+class GeminiChat:
+    def __init__(self):
+        api_key = os.getenv("GOOGLE_AI_STUDIO_KEY")
+        if not api_key:
+            raise ValueError("GOOGLE_AI_STUDIO_KEY environment variable not set")
+        
+        genai.configure(api_key=api_key)
+        self.model = genai.GenerativeModel('gemini-pro')
+        
+    async def chat(self, 
+                  messages: List[Dict[str, str]], 
+                  temperature: float = 0.7) -> str:
+        """Generate a chat response using Gemini API."""
+        try:
+            chat = self.model.start_chat(history=messages)
+            response = chat.send_message(
+                messages[-1]["content"],
+                generation_config={"temperature": temperature}
+            )
+            return response.text
+        except Exception as e:
+            print(f"Error in Gemini chat: {e}")
+            return ""

llm.py

@@ -0,0 +1,31 @@
+from transformers import pipeline
+import torch
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class LLMPipeline:
+    def __init__(self):
+        model_id = os.getenv("HF_MODEL_ID", "mradermacher/Huihui-gemma-3n-E4B-it-abliterated-GGUF")
+        self.pipeline = pipeline(
+            "text-generation",
+            model=model_id,
+            torch_dtype=torch.float16,
+            device_map="auto"
+        )
+
+    async def generate(self, prompt: str, max_length: int = 100) -> str:
+        """Generate text using the local Gemma model."""
+        try:
+            result = self.pipeline(
+                prompt,
+                max_length=max_length,
+                num_return_sequences=1,
+                temperature=0.7,
+                top_p=0.9
+            )
+            return result[0]['generated_text']
+        except Exception as e:
+            print(f"Error in LLM generation: {e}")
+            return ""

requirements.txt

@@ -0,0 +1,12 @@
+fastapi>=0.68.0
+uvicorn>=0.15.0
+python-dotenv>=0.19.0
+transformers>=4.30.0
+torch>=2.0.0
+google-generativeai>=0.3.0
+supabase>=2.0.0
+python-multipart>=0.0.6
+numpy>=1.21.0
+scipy>=1.7.0
+pytest>=7.0.0
+httpx>=0.24.0  # Required for TestClient

test_app.py

@@ -0,0 +1,41 @@
+import pytest
+from fastapi.testclient import TestClient
+from app import app
+
+client = TestClient(app)
+
+def test_chat_endpoint():
+    test_messages = [
+        {"role": "user", "content": "What is 2+2?"}
+    ]
+    
+    response = client.post(
+        "/api/chat",
+        json={
+            "messages": test_messages,
+            "use_gemini": False,  # Test local LLM
+            "temperature": 0.7
+        }
+    )
+    
+    assert response.status_code == 200
+    assert "response" in response.json()
+    assert isinstance(response.json()["response"], str)
+
+def test_gemini_chat():
+    test_messages = [
+        {"role": "user", "content": "Tell me a short joke."}
+    ]
+    
+    response = client.post(
+        "/api/chat",
+        json={
+            "messages": test_messages,
+            "use_gemini": True,  # Test Gemini API
+            "temperature": 0.7
+        }
+    )
+    
+    assert response.status_code == 200
+    assert "response" in response.json()
+    assert isinstance(response.json()["response"], str)