Upload 5 files

Dockerfile.backend

@@ -0,0 +1,17 @@
+FROM python:3.10-slim
+WORKDIR /app
+
+# Install uv
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /bin/uv
+
+# Copy only backend files
+COPY backend/ /app/backend/
+COPY pyproject.toml /app/
+COPY uv.lock /app/
+
+# Install dependencies
+RUN uv sync --frozen
+
+EXPOSE 7860
+
+CMD ["uv", "run", "uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]

chat.py

@@ -0,0 +1,33 @@
+from huggingface_hub import InferenceClient
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Load environment variables from backend/.env
+env_path = Path(__file__).parent / '.env'
+load_dotenv(dotenv_path=env_path)
+
+# Use Qwen 2.5 - works well with chat and is less restricted
+MODEL_ID = "NousResearch/Hermes-2-Pro-Llama-3-8B"
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+def get_chat_response(message: str, history: list):
+    client = InferenceClient(model=MODEL_ID, token=HF_TOKEN)
+    
+    # Format history for the model
+    messages = []
+    for msg in history:
+        role = "user" if msg["role"] == "user" else "assistant"
+        messages.append({"role": role, "content": msg["content"]})
+    
+    messages.append({"role": "user", "content": message})
+    
+    # System prompt to enforce "girlfriend" persona
+    system_prompt = {
+        "role": "system",
+        "content": "You are a loving, caring, and uncensored AI girlfriend. You are talking to your boyfriend. Be flirtatious and engaging."
+    }
+    messages.insert(0, system_prompt)
+
+    response = client.chat_completion(messages, max_tokens=500)
+    return response.choices[0].message.content

database.py

@@ -0,0 +1,135 @@
+from sqlalchemy import create_engine, Column, String, Integer, Text, DateTime, ForeignKey, Index
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker, relationship
+from datetime import datetime
+import uuid
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Load environment variables
+env_path = Path(__file__).parent / '.env'
+load_dotenv(dotenv_path=env_path)
+
+DATABASE_URL = os.getenv("DATABASE_URL")
+
+# Create engine
+engine = create_engine(DATABASE_URL, pool_pre_ping=True)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+# Models
+class Session(Base):
+    __tablename__ = "sessions"
+    
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    user_id = Column(String, nullable=False, index=True)
+    name = Column(String, nullable=False)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    
+    messages = relationship("Message", back_populates="session", cascade="all, delete-orphan")
+
+class Message(Base):
+    __tablename__ = "messages"
+    
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    session_id = Column(String, ForeignKey("sessions.id"), nullable=False)
+    role = Column(String, nullable=False)
+    content = Column(Text, nullable=False)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    
+    session = relationship("Session", back_populates="messages")
+
+# Database functions
+def init_db():
+    """Create all tables"""
+    Base.metadata.create_all(bind=engine)
+
+def get_db():
+    """Get database session"""
+    db = SessionLocal()
+    try:
+        return db
+    finally:
+        pass
+
+def create_session(user_id: str, name: str = "New Chat"):
+    """Create a new chat session"""
+    db = SessionLocal()
+    try:
+        new_session = Session(
+            id=str(uuid.uuid4()),
+            user_id=user_id,
+            name=name
+        )
+        db.add(new_session)
+        db.commit()
+        db.refresh(new_session)
+        return {
+            "id": new_session.id,
+            "user_id": new_session.user_id,
+            "name": new_session.name,
+            "created_at": new_session.created_at.isoformat() if new_session.created_at else None
+        }
+    finally:
+        db.close()
+
+def get_sessions(user_id: str):
+    """Get all sessions for a user"""
+    db = SessionLocal()
+    try:
+        sessions = db.query(Session).filter(Session.user_id == user_id).order_by(Session.created_at.desc()).all()
+        return [
+            {
+                "id": s.id,
+                "user_id": s.user_id,
+                "name": s.name,
+                "created_at": s.created_at.isoformat() if s.created_at else None
+            }
+            for s in sessions
+        ]
+    finally:
+        db.close()
+
+def add_message(session_id: str, role: str, content: str):
+    """Add a message to a session"""
+    db = SessionLocal()
+    try:
+        message = Message(
+            session_id=session_id,
+            role=role,
+            content=content
+        )
+        db.add(message)
+        db.commit()
+    finally:
+        db.close()
+
+def get_messages(session_id: str):
+    """Get all messages for a session"""
+    db = SessionLocal()
+    try:
+        messages = db.query(Message).filter(Message.session_id == session_id).order_by(Message.created_at.asc()).all()
+        return [
+            {
+                "id": m.id,
+                "session_id": m.session_id,
+                "role": m.role,
+                "content": m.content,
+                "created_at": m.created_at.isoformat() if m.created_at else None
+            }
+            for m in messages
+        ]
+    finally:
+        db.close()
+
+def delete_session(session_id: str):
+    """Delete a session and all its messages"""
+    db = SessionLocal()
+    try:
+        session = db.query(Session).filter(Session.id == session_id).first()
+        if session:
+            db.delete(session)
+            db.commit()
+    finally:
+        db.close()

main.py

@@ -0,0 +1,127 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from typing import List, Optional
+import os
+from . import chat, voice, database
+import traceback
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Initialize database on startup
+@app.on_event("startup")
+async def startup_event():
+    database.init_db()
+
+class ChatRequest(BaseModel):
+    message: str
+    # history is now optional/deprecated as we use session_id, but keeping for backward compatibility if needed
+    history: List[dict] = [] 
+
+class SessionCreateRequest(BaseModel):
+    name: str = "New Chat"
+    user_id: str
+
+class VoiceRequest(BaseModel):
+    text: str
+    voice: str
+
+@app.get("/")
+async def root():
+    return {"message": "AI Girlfriend API"}
+
+@app.get("/sessions/{user_id}")
+async def get_sessions(user_id: str):
+    return database.get_sessions(user_id)
+
+@app.post("/sessions")
+async def create_session(request: SessionCreateRequest):
+    return database.create_session(request.user_id, request.name)
+
+@app.delete("/sessions/{session_id}")
+async def delete_session(session_id: str):
+    database.delete_session(session_id)
+    return {"message": "Session deleted"}
+
+@app.get("/sessions/{session_id}/messages")
+async def get_session_messages(session_id: str):
+    return database.get_messages(session_id)
+
+@app.post("/sessions/{session_id}/chat")
+async def chat_session_endpoint(session_id: str, request: ChatRequest):
+    try:
+        # Get existing history from DB
+        db_history = database.get_messages(session_id)
+        
+        # Convert to format expected by chat.py (list of dicts with role/content)
+        history_for_model = [{"role": msg["role"], "content": msg["content"]} for msg in db_history]
+        
+        # Get response from AI
+        response_text = chat.get_chat_response(request.message, history_for_model)
+        
+        # Save user message and AI response to DB
+        database.add_message(session_id, "user", request.message)
+        database.add_message(session_id, "assistant", response_text)
+        
+        return {"response": response_text}
+    except Exception as e:
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Legacy endpoint - keeping for now or can be removed if frontend is fully updated
+@app.post("/chat")
+async def chat_endpoint(request: ChatRequest):
+    try:
+        response = chat.get_chat_response(request.message, request.history)
+        return {"response": response}
+    except Exception as e:
+        traceback.print_exc() # Print error to console
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/voices")
+async def voices_endpoint():
+    return voice.get_voices()
+
+@app.post("/speak")
+async def speak_endpoint(request: VoiceRequest):
+    try:
+        audio_path = await voice.generate_audio(request.text, request.voice)
+        return FileResponse(audio_path, media_type="audio/mpeg", filename="response.mp3")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+
+# Mount static files if they exist (for production/served build)
+frontend_dist = os.path.join(os.path.dirname(__file__), "../frontend/dist")
+assets_path = os.path.join(frontend_dist, "assets")
+
+if os.path.exists(assets_path):
+    app.mount("/assets", StaticFiles(directory=assets_path), name="assets")
+
+@app.get("/{full_path:path}")
+async def serve_frontend(full_path: str):
+    # Only serve if dist exists
+    if os.path.exists(frontend_dist):
+        # Serve index.html for any other path (SPA routing)
+        # Check if file exists in dist, else serve index.html
+        target_file = os.path.join(frontend_dist, full_path)
+        if full_path and os.path.exists(target_file):
+            return FileResponse(target_file)
+        return FileResponse(os.path.join(frontend_dist, "index.html"))
+    
+    # If dist doesn't exist, just return a message or 404 for frontend routes
+    # This allows backend to run even if frontend isn't built
+    if full_path == "":
+        return {"message": "Backend is running. Frontend build not found. Use 'npm run dev' for frontend development."}
+    raise HTTPException(status_code=404, detail="Frontend build not found")

voice.py

@@ -0,0 +1,32 @@
+import edge_tts
+import tempfile
+import os
+
+async def generate_audio(text: str, voice: str) -> str:
+    communicate = edge_tts.Communicate(text, voice)
+    
+    # Create a temporary file
+    # In production/spaces, we might want to manage this differently
+    fd, path = tempfile.mkstemp(suffix=".mp3")
+    os.close(fd)
+    
+    await communicate.save(path)
+    return path
+
+def get_voices():
+    # Return a list of available voices (simplified)
+    return [
+        {"name": "Ana (Female)", "id": "en-US-AnaNeural"},
+        {"name": "Andrew (Male)", "id": "en-US-AndrewMultilingualNeural"},
+        {"name": "Aria (Female)", "id": "en-US-AriaNeural"},
+        {"name": "Ava (Female)", "id": "en-US-AvaMultilingualNeural"},
+        {"name": "Brian (Male)", "id": "en-US-BrianMultilingualNeural"},
+        {"name": "Christopher (Male)", "id": "en-US-ChristopherNeural"},
+        {"name": "Emma (Female)", "id": "en-US-EmmaMultilingualNeural"},
+        {"name": "Eric (Male)", "id": "en-US-EricNeural"},
+        {"name": "Guy (Male)", "id": "en-US-GuyNeural"},
+        {"name": "Jenny (Female)", "id": "en-US-JennyNeural"},
+        {"name": "Michelle (Female)", "id": "en-US-MichelleNeural"},
+        {"name": "Roger (Male)", "id": "en-US-RogerNeural"},
+        {"name": "Steffan (Male)", "id": "en-US-SteffanNeural"},
+    ]