Upload 6 files

Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.10-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/*
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create user with UID 1000 (standard for HF Spaces)
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Expose the standard HF port
+EXPOSE 7860
+
+CMD ["python", "main.py"]

core/config.py

@@ -0,0 +1,41 @@
+import os
+from pydantic_settings import BaseSettings
+from typing import Optional
+
+class Settings(BaseSettings):
+    # App Settings
+    APP_NAME: str = "Open Source Syllabus Engine"
+    DEBUG: bool = False
+    PORT: int = 7860
+    
+    # Storage Settings
+    PERSISTENT_STORAGE_PATH: str = os.getenv("PERSISTENT_STORAGE_PATH", "/data")
+    CHROMA_DB_PATH: str = os.path.join(PERSISTENT_STORAGE_PATH, "chromadb")
+    UPLOAD_DIR: str = os.path.join(PERSISTENT_STORAGE_PATH, "uploads")
+    
+    # Model Settings
+    # For CPU: unsloth/Llama-3.2-1B-Instruct-GGUF (or similar small GGUF)
+    # For GPU: meta-llama/Llama-3.1-8B-Instruct
+    MODEL_ID_GPU: str = "meta-llama/Meta-Llama-3.1-8B-Instruct"
+    MODEL_ID_CPU: str = "bartowski/Llama-3.2-1B-Instruct-GGUF"
+    GGUF_FILE: str = "Llama-3.2-1B-Instruct-Q4_K_M.gguf"
+    
+    DEVICE: str = os.getenv("DEVICE", "cpu") # "cpu" or "cuda"
+    
+    # Security
+    API_KEY: Optional[str] = os.getenv("API_KEY") # Secret set in HF Spaces
+    HF_TOKEN: Optional[str] = os.getenv("HF_TOKEN")
+    
+    # Constraints
+    MAX_FILE_SIZE: int = 10 * 1024 * 1024 # 10MB
+    CHUNK_SIZE: int = 1000
+    CHUNK_OVERLAP: int = 200
+
+    class Config:
+        env_file = ".env"
+
+settings = Settings()
+
+# Ensure directories exist
+os.makedirs(settings.UPLOAD_DIR, exist_ok=True)
+os.makedirs(settings.CHROMA_DB_PATH, exist_ok=True)

core/ingestion.py

@@ -0,0 +1,61 @@
+import os
+import hashlib
+from typing import List
+import pypdf
+from docx import Document
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import Chroma
+from langchain_huggingface import HuggingFaceEmbeddings
+from .config import settings
+
+class DocumentProcessor:
+    def __init__(self):
+        self.embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
+        self.vector_store = Chroma(
+            persist_directory=settings.CHROMA_DB_PATH,
+            embedding_function=self.embeddings
+        )
+        self.text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=settings.CHUNK_SIZE,
+            chunk_overlap=settings.CHUNK_OVERLAP
+        )
+
+    def get_file_checksum(self, file_path: str) -> str:
+        with open(file_path, "rb") as f:
+            return hashlib.md5(f.read()).hexdigest()
+
+    def extract_text(self, file_path: str) -> str:
+        ext = os.path.splitext(file_path)[1].lower()
+        text = ""
+        if ext == ".pdf":
+            with open(file_path, "rb") as f:
+                reader = pypdf.PdfReader(f)
+                for page in reader.pages:
+                    text += page.extract_text() + "\n"
+        elif ext == ".docx":
+            doc = Document(file_path)
+            for para in doc.paragraphs:
+                text += para.text + "\n"
+        elif ext == ".txt":
+            with open(file_path, "r", encoding="utf-8") as f:
+                text = f.read()
+        return text
+
+    def ingest_document(self, file_path: str, metadata: dict = None):
+        text = self.extract_text(file_path)
+        if not text.strip():
+            return None
+        
+        chunks = self.text_splitter.split_text(text)
+        metadatas = [metadata or {} for _ in chunks]
+        for meta in metadatas:
+            meta["source"] = os.path.basename(file_path)
+            meta["checksum"] = self.get_file_checksum(file_path)
+            
+        self.vector_store.add_texts(texts=chunks, metadatas=metadatas)
+        return len(chunks)
+
+    def search(self, query: str, k: int = 5):
+        return self.vector_store.similarity_search(query, k=k)
+
+processor = DocumentProcessor()

core/model.py

@@ -0,0 +1,59 @@
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+from llama_cpp import Llama
+import os
+from .config import settings
+
+class SyllabusGenerator:
+    def __init__(self):
+        self.model = None
+        self.tokenizer = None
+        self.is_gpu = settings.DEVICE == "cuda" and torch.cuda.is_available()
+        self.load_model()
+
+    def load_model(self):
+        if self.is_gpu:
+            print(f"Loading GPU model: {settings.MODEL_ID_GPU}")
+            self.tokenizer = AutoTokenizer.from_pretrained(settings.MODEL_ID_GPU)
+            self.model = AutoModelForCausalLM.from_pretrained(
+                settings.MODEL_ID_GPU,
+                device_map="auto",
+                torch_dtype=torch.bfloat16,
+                load_in_4bit=True
+            )
+        else:
+            print(f"Loading CPU model (GGUF): {settings.MODEL_ID_CPU}")
+            # Ensure model file is downloaded
+            # In a real HF space, these would be pre-cached or downloaded on init
+            self.llm = Llama.from_pretrained(
+                repo_id=settings.MODEL_ID_CPU,
+                filename=settings.GGUF_FILE,
+                n_ctx=2048,
+                n_threads=os.cpu_count() or 4
+            )
+
+    def generate(self, prompt: str, context: str = "", max_tokens: int = 1000):
+        full_prompt = f"""
+        System: You are an expert academic curriculum designer. 
+        Use the following context to generate a detailed syllabus.
+        Context: {context}
+        
+        Question: {prompt}
+        
+        Syllabus Output:
+        """
+        
+        if self.is_gpu:
+            inputs = self.tokenizer(full_prompt, return_tensors="pt").to("cuda")
+            outputs = self.model.generate(**inputs, max_new_tokens=max_tokens)
+            return self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+        else:
+            response = self.llm(
+                full_prompt,
+                max_tokens=max_tokens,
+                stop=["Question:", "System:"],
+                echo=False
+            )
+            return response["choices"][0]["text"]
+
+generator = SyllabusGenerator()

main.py

@@ -0,0 +1,77 @@
+import os
+import shutil
+from typing import List, Optional
+from fastapi import FastAPI, UploadFile, File, Header, HTTPException, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from .core.config import settings
+from .core.ingestion import processor
+from .core.model import generator
+
+app = FastAPI(title=settings.APP_NAME)
+
+# CORS configuration
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Authentication Dependency
+def verify_api_key(x_api_key: Optional[str] = Header(None)):
+    if settings.API_KEY and x_api_key != settings.API_KEY:
+        raise HTTPException(status_code=403, detail="Invalid API Key")
+    return x_api_key
+
+class GenerateRequest(BaseModel):
+    course_name: str
+    description: str
+    constraints: Optional[str] = ""
+    max_tokens: int = 2000
+
+@app.get("/health")
+def health_check():
+    return {
+        "status": "healthy",
+        "device": settings.DEVICE,
+        "gpu_available": generator.is_gpu
+    }
+
+@app.post("/ingest")
+async def ingest_file(file: UploadFile = File(...), api_key: str = Depends(verify_api_key)):
+    if file.size > settings.MAX_FILE_SIZE:
+        raise HTTPException(status_code=413, detail="File too large")
+    
+    file_path = os.path.join(settings.UPLOAD_DIR, file.filename)
+    with open(file_path, "wb") as buffer:
+        shutil.copyfileobj(file.file, buffer)
+    
+    chunks = processor.ingest_document(file_path)
+    if chunks is None:
+        raise HTTPException(status_code=400, detail="Could not extract text from file")
+        
+    return {"filename": file.filename, "chunks_ingested": chunks}
+
+@app.post("/generate_syllabus")
+async def generate_syllabus(req: GenerateRequest, api_key: str = Depends(verify_api_key)):
+    # 1. Search for relevant context
+    query = f"{req.course_name} {req.description}"
+    docs = processor.search(query, k=5)
+    context = "\n".join([d.page_content for d in docs])
+    
+    # 2. Build prompt
+    prompt = f"Design a comprehensive syllabus for a course titled '{req.course_name}'. Description: {req.description}. Constraints: {req.constraints}"
+    
+    # 3. Generate
+    syllabus = generator.generate(prompt, context=context, max_tokens=req.max_tokens)
+    
+    return {
+        "course_name": req.course_name,
+        "syllabus": syllabus,
+        "sources": [d.metadata["source"] for d in docs]
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=settings.PORT)

requirements.txt

@@ -0,0 +1,16 @@
+fastapi
+uvicorn
+python-multipart
+pydantic-settings
+pypdf
+python-docx
+langchain
+langchain-community
+langchain-huggingface
+chromadb
+transformers
+bitsandbytes
+accelerate
+torch
+llama-cpp-python
+huggingface-hub