Upload 4 files

Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application
+COPY . .
+
+# Create data directory
+RUN mkdir -p /data
+
+# Expose port (Hugging Face Spaces uses 7860)
+EXPOSE 7860
+
+# Run the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,17 @@
 ---
-title: Chatbase Api
-emoji: 🏆
-colorFrom: indigo
-colorTo: indigo
+title: Chatbase Clone API
+emoji: 🤖
+colorFrom: purple
+colorTo: blue
 sdk: docker
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Chatbase Clone API
+
+RAG-powered chatbot backend using FAISS + Gemini 1.5 Flash.
+
+## Environment Variables
+
+Set these in your Space settings:
+- `GEMINI_API_KEY` — Your Google AI Studio API key

app.py

@@ -0,0 +1,423 @@
+# =============================================================================
+# 🤖 CHATBASE CLONE — BACKEND API
+# =============================================================================
+# Deploy this to Hugging Face Spaces (Docker SDK)
+# Provides RAG-powered chat using FAISS + Gemini 1.5 Flash
+# =============================================================================
+
+import os
+import json
+import hashlib
+import time
+import shutil
+from pathlib import Path
+from typing import Optional, List, Dict, Any
+
+import numpy as np
+import faiss
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse, JSONResponse
+from pydantic import BaseModel, Field
+from sentence_transformers import SentenceTransformer
+import google.generativeai as genai
+
+# =============================================================================
+# Configuration
+# =============================================================================
+
+DATA_DIR = os.environ.get("DATA_DIR", "/data")
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY", "")
+EMBED_MODEL_NAME = "all-MiniLM-L6-v2"
+GEMINI_MODEL = "gemini-1.5-flash"
+TOP_K = 5  # Number of chunks to retrieve
+GEMINI_TIMEOUT = 30  # Seconds before Gemini API request times out
+
+# =============================================================================
+# Initialize
+# =============================================================================
+
+app = FastAPI(
+    title="Chatbase Clone API",
+    description="RAG-powered chatbot backend using FAISS + Gemini 1.5 Flash",
+    version="1.0.0",
+)
+
+# CORS — allow all origins for development
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Load embedding model at startup
+print("Loading embedding model...")
+embed_model = SentenceTransformer(EMBED_MODEL_NAME)
+EMBED_DIM = embed_model.get_sentence_embedding_dimension()
+
+# Configure Gemini
+if GEMINI_API_KEY:
+    genai.configure(api_key=GEMINI_API_KEY)
+    gemini_model = genai.GenerativeModel(GEMINI_MODEL)
+else:
+    gemini_model = None
+    print("⚠️  GEMINI_API_KEY not set. Chat will not work until configured.")
+
+# In-memory store for chatbot data
+chatbots: Dict[str, Dict[str, Any]] = {}
+
+# =============================================================================
+# Pydantic Models
+# =============================================================================
+
+class ChunkData(BaseModel):
+    chunk_id: int
+    source_url: str = ""
+    page_title: str = ""
+    chunk_index: int = 0
+    total_chunks: int = 0
+    content: str
+
+class CreateChatbotRequest(BaseModel):
+    chatbot_id: str
+    source_url: str = ""
+    total_chunks: int = 0
+    chunk_config: dict = {}
+    chunks: List[ChunkData]
+
+class ChatMessage(BaseModel):
+    role: str  # "user" or "assistant"
+    content: str
+
+class ChatRequest(BaseModel):
+    message: str
+    history: List[ChatMessage] = []
+    stream: bool = False
+
+class ChatbotSettings(BaseModel):
+    name: Optional[str] = None
+    system_prompt: Optional[str] = None
+    temperature: Optional[float] = None
+    initial_message: Optional[str] = None
+    theme_color: Optional[str] = None
+
+# =============================================================================
+# Helper Functions
+# =============================================================================
+
+def get_chatbot_dir(chatbot_id: str) -> Path:
+    """Get the directory for a specific chatbot's data."""
+    safe_id = hashlib.md5(chatbot_id.encode()).hexdigest()[:12]
+    return Path(DATA_DIR) / f"chatbot_{safe_id}"
+
+def build_faiss_index(chunks: List[ChunkData]) -> tuple:
+    """Build a FAISS index from text chunks."""
+    texts = [c.content for c in chunks]
+    print(f"  Embedding {len(texts)} chunks...")
+    embeddings = embed_model.encode(texts, show_progress_bar=True, batch_size=32)
+    embeddings = np.array(embeddings, dtype='float32')
+
+    # Normalize for cosine similarity
+    faiss.normalize_L2(embeddings)
+
+    # Create index
+    index = faiss.IndexFlatIP(EMBED_DIM)  # Inner product = cosine on normalized
+    index.add(embeddings)
+
+    return index, texts
+
+def search_chunks(chatbot_id: str, query: str, top_k: int = TOP_K) -> List[Dict]:
+    """Search for relevant chunks using FAISS."""
+    bot = chatbots.get(chatbot_id)
+    if not bot:
+        return []
+
+    query_embedding = embed_model.encode([query])
+    query_embedding = np.array(query_embedding, dtype='float32')
+    faiss.normalize_L2(query_embedding)
+
+    scores, indices = bot['index'].search(query_embedding, top_k)
+
+    results = []
+    for score, idx in zip(scores[0], indices[0]):
+        if idx < len(bot['texts']):
+            results.append({
+                'content': bot['texts'][idx],
+                'score': float(score),
+            })
+
+    return results
+
+def build_rag_prompt(query: str, context_chunks: List[Dict], history: List[ChatMessage], system_prompt: str = "") -> str:
+    """Build the RAG prompt for Gemini."""
+    if not system_prompt:
+        system_prompt = (
+            "You are a helpful AI assistant. Answer questions based on the provided context. "
+            "If the context doesn't contain relevant information, say so honestly. "
+            "Be concise, accurate, and helpful. Use markdown formatting when appropriate."
+        )
+
+    context_text = "\n\n---\n\n".join([c['content'] for c in context_chunks])
+
+    prompt = f"""{system_prompt}
+
+## Context from Knowledge Base:
+{context_text}
+
+## Conversation History:
+"""
+    for msg in history[-6:]:  # Last 6 messages for context
+        role = "User" if msg.role == "user" else "Assistant"
+        prompt += f"{role}: {msg.content}\n"
+
+    prompt += f"\nUser: {query}\n\nAssistant:"
+
+    return prompt
+
+# =============================================================================
+# API Endpoints
+# =============================================================================
+
+@app.get("/")
+async def root():
+    return {"status": "ok", "service": "Chatbase Clone API", "version": "1.0.0"}
+
+@app.get("/api/health")
+async def health():
+    return {
+        "status": "healthy",
+        "gemini_configured": gemini_model is not None,
+        "chatbots_loaded": len(chatbots),
+        "embed_model": EMBED_MODEL_NAME,
+    }
+
+# --- Chatbot CRUD ---
+
+@app.post("/api/chatbot")
+async def create_chatbot(request: CreateChatbotRequest):
+    """Create a new chatbot from chunked data."""
+    chatbot_id = request.chatbot_id
+
+    if not request.chunks:
+        raise HTTPException(status_code=400, detail="No chunks provided")
+
+    print(f"📦 Creating chatbot: {chatbot_id} with {len(request.chunks)} chunks")
+
+    # Build FAISS index
+    index, texts = build_faiss_index(request.chunks)
+
+    # Store in memory
+    chatbots[chatbot_id] = {
+        'id': chatbot_id,
+        'source_url': request.source_url,
+        'total_chunks': len(request.chunks),
+        'index': index,
+        'texts': texts,
+        'created_at': time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        'settings': {
+            'name': chatbot_id,
+            'system_prompt': '',
+            'temperature': 0.7,
+            'initial_message': f"Hi! I'm an AI assistant trained on {request.source_url}. How can I help you?",
+            'theme_color': '#6C63FF',
+        },
+        'chat_count': 0,
+        'message_count': 0,
+    }
+
+    # Save to disk for persistence
+    bot_dir = get_chatbot_dir(chatbot_id)
+    bot_dir.mkdir(parents=True, exist_ok=True)
+    faiss.write_index(index, str(bot_dir / "index.faiss"))
+
+    # Save metadata
+    meta = {k: v for k, v in chatbots[chatbot_id].items() if k not in ('index', 'texts')}
+    meta['texts'] = texts
+    with open(bot_dir / "meta.json", 'w') as f:
+        json.dump(meta, f, indent=2)
+
+    print(f"✅ Chatbot '{chatbot_id}' created successfully!")
+
+    return {
+        "status": "success",
+        "chatbot_id": chatbot_id,
+        "total_chunks": len(request.chunks),
+        "message": f"Chatbot '{chatbot_id}' created with {len(request.chunks)} chunks",
+    }
+
+
+@app.get("/api/chatbots")
+async def list_chatbots():
+    """List all chatbots."""
+    bots = []
+    for bot_id, bot in chatbots.items():
+        bots.append({
+            'id': bot['id'],
+            'name': bot['settings']['name'],
+            'source_url': bot['source_url'],
+            'total_chunks': bot['total_chunks'],
+            'created_at': bot['created_at'],
+            'chat_count': bot.get('chat_count', 0),
+            'message_count': bot.get('message_count', 0),
+            'settings': bot['settings'],
+        })
+    return {"chatbots": bots}
+
+
+@app.get("/api/chatbot/{chatbot_id}")
+async def get_chatbot(chatbot_id: str):
+    """Get chatbot details."""
+    if chatbot_id not in chatbots:
+        raise HTTPException(status_code=404, detail="Chatbot not found")
+
+    bot = chatbots[chatbot_id]
+    return {
+        'id': bot['id'],
+        'name': bot['settings']['name'],
+        'source_url': bot['source_url'],
+        'total_chunks': bot['total_chunks'],
+        'created_at': bot['created_at'],
+        'chat_count': bot.get('chat_count', 0),
+        'message_count': bot.get('message_count', 0),
+        'settings': bot['settings'],
+    }
+
+
+@app.put("/api/chatbot/{chatbot_id}/settings")
+async def update_settings(chatbot_id: str, settings: ChatbotSettings):
+    """Update chatbot settings."""
+    if chatbot_id not in chatbots:
+        raise HTTPException(status_code=404, detail="Chatbot not found")
+
+    bot = chatbots[chatbot_id]
+    update_data = settings.dict(exclude_none=True)
+    bot['settings'].update(update_data)
+
+    return {"status": "success", "settings": bot['settings']}
+
+
+@app.delete("/api/chatbot/{chatbot_id}")
+async def delete_chatbot(chatbot_id: str):
+    """Delete a chatbot."""
+    if chatbot_id not in chatbots:
+        raise HTTPException(status_code=404, detail="Chatbot not found")
+
+    del chatbots[chatbot_id]
+
+    # Remove from disk
+    bot_dir = get_chatbot_dir(chatbot_id)
+    if bot_dir.exists():
+        shutil.rmtree(bot_dir)
+
+    return {"status": "success", "message": f"Chatbot '{chatbot_id}' deleted"}
+
+
+# --- Chat ---
+
+@app.post("/api/chat/{chatbot_id}")
+async def chat(chatbot_id: str, request: ChatRequest):
+    """Send a message and get an AI response."""
+    if chatbot_id not in chatbots:
+        raise HTTPException(status_code=404, detail="Chatbot not found")
+
+    if not gemini_model:
+        raise HTTPException(status_code=500, detail="Gemini API key not configured. Set GEMINI_API_KEY environment variable.")
+
+    bot = chatbots[chatbot_id]
+    bot['chat_count'] = bot.get('chat_count', 0) + 1
+    bot['message_count'] = bot.get('message_count', 0) + 1
+
+    # Retrieve relevant chunks
+    context_chunks = search_chunks(chatbot_id, request.message, TOP_K)
+
+    # Build prompt
+    prompt = build_rag_prompt(
+        query=request.message,
+        context_chunks=context_chunks,
+        history=request.history,
+        system_prompt=bot['settings'].get('system_prompt', ''),
+    )
+
+    # Generate response
+    if request.stream:
+        async def generate():
+            import signal
+            try:
+                response = gemini_model.generate_content(
+                    prompt,
+                    generation_config=genai.GenerationConfig(
+                        temperature=bot['settings'].get('temperature', 0.7),
+                        max_output_tokens=2048,
+                    ),
+                    stream=True,
+                    request_options={'timeout': GEMINI_TIMEOUT},
+                )
+                for chunk in response:
+                    if chunk.text:
+                        yield f"data: {json.dumps({'content': chunk.text})}\n\n"
+                yield "data: [DONE]\n\n"
+            except Exception as e:
+                yield f"data: {json.dumps({'error': str(e)})}\n\n"
+
+        return StreamingResponse(generate(), media_type="text/event-stream")
+    else:
+        try:
+            response = gemini_model.generate_content(
+                prompt,
+                generation_config=genai.GenerationConfig(
+                    temperature=bot['settings'].get('temperature', 0.7),
+                    max_output_tokens=2048,
+                ),
+                request_options={'timeout': GEMINI_TIMEOUT},
+            )
+            return {
+                "response": response.text,
+                "sources": [{"content": c['content'][:200], "score": c['score']} for c in context_chunks[:3]],
+            }
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Gemini error: {str(e)}")
+
+
+# --- Startup: Load existing chatbots ---
+
+@app.on_event("startup")
+async def startup_load():
+    """Load previously saved chatbots from disk."""
+    data_path = Path(DATA_DIR)
+    if not data_path.exists():
+        data_path.mkdir(parents=True, exist_ok=True)
+        return
+
+    for bot_dir in data_path.iterdir():
+        if bot_dir.is_dir() and bot_dir.name.startswith("chatbot_"):
+            meta_path = bot_dir / "meta.json"
+            index_path = bot_dir / "index.faiss"
+
+            if meta_path.exists() and index_path.exists():
+                try:
+                    with open(meta_path) as f:
+                        meta = json.load(f)
+
+                    index = faiss.read_index(str(index_path))
+                    texts = meta.pop('texts', [])
+
+                    chatbots[meta['id']] = {
+                        **meta,
+                        'index': index,
+                        'texts': texts,
+                    }
+                    print(f"  ✅ Loaded chatbot: {meta['id']}")
+                except Exception as e:
+                    print(f"  ⚠️ Failed to load {bot_dir.name}: {e}")
+
+    print(f"📦 Loaded {len(chatbots)} chatbots from disk")
+
+
+# =============================================================================
+# Run with: uvicorn app:app --host 0.0.0.0 --port 7860
+# =============================================================================
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.104.1
+uvicorn==0.24.0
+faiss-cpu==1.7.4
+sentence-transformers==2.2.2
+google-generativeai==0.8.3
+python-multipart==0.0.6
+numpy==1.26.2
+pydantic==2.5.2