Initial commit of FocusFlow backend

.gitignore

@@ -0,0 +1,8 @@
+venv/
+__pycache__/
+*.pyc
+chroma_db/
+*.db
+data/
+.DS_Store
+.env

backend/database.py

@@ -0,0 +1,41 @@
+from sqlalchemy import create_engine, Column, Integer, String, Boolean, ForeignKey
+from sqlalchemy.orm import declarative_base, sessionmaker
+
+DATABASE_URL = "sqlite:///./focusflow.db"
+
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+class Source(Base):
+    __tablename__ = "sources"
+
+    id = Column(Integer, primary_key=True, index=True)
+    filename = Column(String, index=True)
+    type = Column(String)  # online/offline
+    file_path = Column(String)
+    is_active = Column(Boolean, default=True)
+
+class Schedule(Base):
+    __tablename__ = "schedule"
+
+    id = Column(Integer, primary_key=True, index=True)
+    date = Column(String, index=True)  # YYYY-MM-DD
+    topic_name = Column(String)
+    is_completed = Column(Boolean, default=False)
+    is_locked = Column(Boolean, default=True)
+
+class Mastery(Base):
+    __tablename__ = "mastery"
+
+    id = Column(Integer, primary_key=True, index=True)
+    topic_name = Column(String, index=True)
+    quiz_score = Column(Integer, default=0)
+    flashcard_status = Column(String, default="Not Started")
+
+# Create tables
+def init_db():
+    Base.metadata.create_all(bind=engine)
+
+if __name__ == "__main__":
+    init_db()

backend/main.py

@@ -0,0 +1,115 @@
+from fastapi import FastAPI, Depends, UploadFile, File, HTTPException
+from sqlalchemy.orm import Session
+from backend.database import SessionLocal, engine, Source, Schedule, Mastery, init_db
+from backend.rag_engine import ingest_document, query_knowledge_base
+import shutil
+import os
+from pydantic import BaseModel
+from typing import List
+
+# Create tables
+init_db()
+
+app = FastAPI(title="FocusFlow Backend")
+
+# Dependency
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+# Pydantic Models
+class ScheduleItem(BaseModel):
+    id: int
+    date: str
+    topic_name: str
+    is_completed: bool
+    is_locked: bool
+
+class UnlockRequest(BaseModel):
+    topic_id: int
+    quiz_score: int
+
+class UnlockResponse(BaseModel):
+    success: bool
+    message: str
+    next_topic_unlocked: bool
+
+@app.post("/upload")
+async def upload_file(file: UploadFile = File(...), db: Session = Depends(get_db)):
+    file_location = f"data/{file.filename}"
+    try:
+        with open(file_location, "wb+") as buffer:
+            shutil.copyfileobj(file.file, buffer)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Could not save file: {str(e)}")
+
+    # Ingest
+    try:
+        ingest_document(file_location)
+    except Exception as e:
+        # cleanup if ingest fails?
+        # os.remove(file_location)
+        raise HTTPException(status_code=500, detail=f"Ingestion failed: {str(e)}")
+    
+    # Save to DB
+    new_source = Source(filename=file.filename, type="local", file_path=file_location, is_active=True)
+    db.add(new_source)
+    db.commit()
+    db.refresh(new_source)
+    
+    return {"message": "File uploaded and ingested successfully", "id": new_source.id}
+
+@app.get("/schedule/{date}", response_model=List[ScheduleItem])
+def get_schedule(date: str, db: Session = Depends(get_db)):
+    # Assuming date is YYYY-MM-DD
+    schedule_items = db.query(Schedule).filter(Schedule.date == date).all()
+    if not schedule_items:
+        # Just return empty list or maybe 404? 
+        return []
+    return schedule_items
+
+@app.post("/unlock_topic", response_model=UnlockResponse)
+def unlock_topic(request: UnlockRequest, db: Session = Depends(get_db)):
+    # 1. Update Mastery or Schedule completion
+    # Find the schedule item for this topic_id (Assuming topic_id refers to Schedule ID for simplicity, or we link Mastery to Schedule)
+    # The prompt says: Takes a topic_id and quiz_score.
+    
+    # Let's find the current topic in Schedule
+    current_topic = db.query(Schedule).filter(Schedule.id == request.topic_id).first()
+    if not current_topic:
+        raise HTTPException(status_code=404, detail="Topic not found")
+        
+    # Update Mastery logic (not explicitly detailed in prompt how Mastery links, but we can creating/update a Mastery record)
+    # Check if mastery exists for this topic name
+    mastery = db.query(Mastery).filter(Mastery.topic_name == current_topic.topic_name).first()
+    if not mastery:
+        mastery = Mastery(topic_name=current_topic.topic_name, quiz_score=request.quiz_score)
+        db.add(mastery)
+    else:
+        mastery.quiz_score = request.quiz_score
+    
+    # Update current topic completion if passed? Prompt doesn't specify, but implies progress.
+    if request.quiz_score > 60:
+        current_topic.is_completed = True
+        
+        # Unlock next topic
+        # Logic: Find next topic by ID (assuming sequential)
+        next_topic = db.query(Schedule).filter(Schedule.id > current_topic.id).order_by(Schedule.id.asc()).first()
+        
+        next_unlocked = False
+        if next_topic:
+            next_topic.is_locked = False
+            next_unlocked = True
+            
+        db.commit()
+        return {"success": True, "message": "Quiz passed. Next topic unlocked.", "next_topic_unlocked": next_unlocked}
+    else:
+        db.commit()
+        return {"success": True, "message": "Quiz score too low to unlock next topic.", "next_topic_unlocked": False}
+
+@app.get("/query")
+def query_kb(question: str):
+    return query_knowledge_base(question)

backend/rag_engine.py

@@ -0,0 +1,76 @@
+import os
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_chroma import Chroma
+from langchain_community.embeddings import OllamaEmbeddings
+from langchain_community.llms import Ollama
+
+CACHE_DIR = "./chroma_db"
+
+def ingest_document(file_path: str):
+    """
+    Ingests a PDF document into the vector database.
+    """
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"File not found: {file_path}")
+
+    # Load PDF
+    loader = PyPDFLoader(file_path)
+    docs = loader.load()
+
+    # Split text
+    splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
+    splits = splitter.split_documents(docs)
+    
+    # Store in ChromaDB
+    # Note: Chroma will automatically persist to disk in newer versions when persist_directory is set
+    Chroma.from_documents(
+        documents=splits,
+        embedding=OllamaEmbeddings(model="nomic-embed-text"),
+        persist_directory=CACHE_DIR
+    )
+    print(f"Ingested {len(splits)} chunks from {file_path}")
+
+def query_knowledge_base(question: str):
+    """
+    Queries the knowledge base and returns an answer with sources.
+    """
+    # Initialize DB with same embedding function
+    db = Chroma(persist_directory=CACHE_DIR, embedding_function=OllamaEmbeddings(model="nomic-embed-text"))
+    
+    # Retrieve top 3 chunks
+    results = db.similarity_search(question, k=3)
+    
+    if not results:
+        return {"answer": "No relevant information found.", "sources": []}
+
+    # Format context
+    context_str = "\n\n".join([f"Source: {doc.metadata.get('source', 'Unknown')}, Page: {doc.metadata.get('page', 'Unknown')}\nContent: {doc.page_content}" for doc in results])
+    
+    # Generate answer using Ollama
+    llm = Ollama(model="llama3.2:1b")
+    prompt = f"""You are an intelligent study assistant.
+    Answer the question using the provided context, but explain it in your own words.
+    Make it sound natural and easy to understand, like a teacher explaining to a student.
+    
+    Context:
+    {context_str}
+    
+    Question: {question}
+    """
+    
+    response = llm.invoke(prompt)
+    
+    # Format sources for return
+    sources = [
+        {
+            "source": os.path.basename(doc.metadata.get('source', '')),
+            "page": doc.metadata.get('page', 0)
+        } 
+        for doc in results
+    ]
+    
+    return {
+        "answer": response,
+        "sources": sources
+    }

requirements.txt

@@ -0,0 +1,10 @@
+fastapi
+uvicorn
+sqlalchemy
+chromadb
+langchain
+langchain-community
+langchain-chroma
+pypdf
+python-multipart
+requests