Deploy clean version to HF Space (no binary files)

.gitignore

@@ -0,0 +1,3 @@
+ml/models/*.pkl
+ml\models\*.pkl
+*.pkl

Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONPATH=/app
+
+COPY . /app
+RUN pip install --no-cache-dir -r requirements.txt
+
+EXPOSE 7860
+CMD ["bash", "start.sh"]

README.md

@@ -0,0 +1,5 @@
+---
+title: LearnLanguage
+sdk: docker
+app_port: 7860
+---

backend/app/api/routes_auth.py

@@ -0,0 +1,40 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from ..schemas.auth import RegisterIn, LoginIn, AuthOut
+from ..db.models import User
+from ..core.security import hash_password, verify_password, create_access_token
+from ..core.deps import get_db, get_current_user
+
+router = APIRouter(prefix="/auth", tags=["auth"])
+
+@router.post("/register", response_model=AuthOut)
+def register(payload: RegisterIn, db: Session = Depends(get_db)):
+    if db.query(User).filter(User.email == payload.email).first():
+        raise HTTPException(status_code=400, detail="Email already used")
+    if db.query(User).filter(User.username == payload.username).first():
+        raise HTTPException(status_code=400, detail="Username already used")
+
+    user = User(
+        email=payload.email,
+        username=payload.username,
+        password_hash=hash_password(payload.password),
+    )
+    db.add(user)
+    db.commit()
+    db.refresh(user)
+
+    token = create_access_token(user.id, user.email)
+    return AuthOut(token=token, user_id=user.id, email=user.email, username=user.username)
+
+@router.post("/login", response_model=AuthOut)
+def login(payload: LoginIn, db: Session = Depends(get_db)):
+    user = db.query(User).filter(User.email == payload.email).first()
+    if not user or not verify_password(payload.password, user.password_hash):
+        raise HTTPException(status_code=401, detail="Invalid credentials")
+
+    token = create_access_token(user.id, user.email)
+    return AuthOut(token=token, user_id=user.id, email=user.email, username=user.username)
+
+@router.get("/me")
+def me(user: User = Depends(get_current_user)):
+    return {"user_id": user.id, "email": user.email, "username": user.username}

backend/app/api/routes_cefr.py

@@ -0,0 +1,13 @@
+from fastapi import APIRouter
+from pydantic import BaseModel
+from ..services.cefr_predictor import CEFRPredictor
+
+router = APIRouter()
+predictor = CEFRPredictor()
+
+class PredictRequest(BaseModel):
+    text: str
+
+@router.post("/predict-level")
+def predict_level(payload: PredictRequest):
+    return {"level": predictor.predict(payload.text)}

backend/app/api/routes_chat.py

@@ -0,0 +1,31 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+from pydantic import BaseModel
+
+from ..core.deps import get_db, get_current_user
+from ..db.models import User
+from ..services import tutor_engine
+
+router = APIRouter()
+
+# -------- REQUEST MODEL --------
+class ChatRequest(BaseModel):
+    message: str
+    mode: str = "conversation"
+
+
+# -------- CHAT ENDPOINT --------
+@router.post("/chat")
+def chat_endpoint(
+    payload: ChatRequest,
+    user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    result = tutor_engine.chat(
+        user_text=payload.message,
+        user=user,
+        history=[],
+        mode=payload.mode,
+        db=db
+    )
+    return result

backend/app/api/routes_chat_stream.py

@@ -0,0 +1,76 @@
+import json
+import requests
+from fastapi import APIRouter
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+from typing import List, Dict, Any
+
+from ..services.tutor_engine import build_prompt_context, safe_json_parse, make_exercise_from_top_errors
+from ..db.database import SessionLocal
+from ..db.repo import save_message, save_corrections, get_last_messages, top_errors
+
+router = APIRouter()
+
+OLLAMA_URL = "http://127.0.0.1:11434/api/chat"
+OLLAMA_MODEL = "llama3.2:3b"
+
+class StreamChatRequest(BaseModel):
+    session_id: str
+    message: str
+
+@router.post("/chat_stream")
+def chat_stream(payload: StreamChatRequest):
+    db = SessionLocal()
+
+    # load memory (last messages) from DB
+    history = get_last_messages(db, payload.session_id, limit=12)
+    # build prompt context (level/topic/profile + JSON-only instructions)
+    ctx = build_prompt_context(payload.message, history, db, payload.session_id)
+
+    # save user message first
+    save_message(db, payload.session_id, "You", payload.message, level=ctx["level"], topic=ctx["topic"])
+
+    messages = ctx["ollama_messages"]
+
+    body = {
+        "model": OLLAMA_MODEL,
+        "messages": messages,
+        "stream": True,
+        "options": {"temperature": 0.4, "num_predict": 260}
+    }
+
+    def gen():
+        full = ""
+        try:
+            with requests.post(OLLAMA_URL, json=body, stream=True, timeout=180) as r:
+                r.raise_for_status()
+                for line in r.iter_lines(decode_unicode=True):
+                    if not line:
+                        continue
+                    data = json.loads(line)
+                    if "message" in data and "content" in data["message"]:
+                        chunk = data["message"]["content"]
+                        full += chunk
+                        # send chunk to streamlit
+                        yield chunk
+
+            # after stream ends: parse JSON and persist bot output + corrections
+            parsed = safe_json_parse(full)
+            bot_reply = parsed.get("reply","")
+            corrections = parsed.get("corrections", [])
+
+            # generate extra exercise from top errors
+            errs = top_errors(db, payload.session_id, limit=3)
+            parsed["exercise_from_progress"] = make_exercise_from_top_errors(ctx["level"], errs)
+
+            # persist bot message + corrections
+            save_message(db, payload.session_id, "Bot", bot_reply, level=ctx["level"], topic=ctx["topic"])
+            save_corrections(db, payload.session_id, corrections)
+
+            # send final JSON marker
+            yield "\n\n[[FINAL_JSON]]\n" + json.dumps(parsed, ensure_ascii=False)
+
+        finally:
+            db.close()
+
+    return StreamingResponse(gen(), media_type="text/plain")

backend/app/api/routes_stats.py

@@ -0,0 +1,74 @@
+from fastapi import APIRouter, Depends
+from sqlalchemy import func
+from sqlalchemy.orm import Session
+
+from ..core.deps import get_db, get_current_user   # ✅ هنا الصحيح
+from ..db.models import Message, Correction, User  # حسب الموديلات ديالك
+
+router = APIRouter(tags=["stats"])
+
+LEVEL_ORDER = ["A1","A2","B1","B2","C1","C2"]
+
+
+@router.get("/stats/me")
+def stats_me(user: User = Depends(get_current_user), db: Session = Depends(get_db)):
+    # ✅ Top 5 errors (ديال هاد user فقط)
+    errors = (
+        db.query(
+            Correction.error,
+            Correction.suggestion,
+            func.count(Correction.id).label("count")
+        )
+        .filter(Correction.user_id == user.id)   # ✅ بدل session_id
+        .group_by(Correction.error, Correction.suggestion)
+        .order_by(func.count(Correction.id).desc())
+        .limit(5)
+        .all()
+    )
+
+    top_errors = [
+        {"error": e.error, "suggestion": e.suggestion, "count": e.count}
+        for e in errors
+    ]
+
+    # ✅ Messages per day (ديال user فقط)
+    messages_per_day = (
+        db.query(
+            func.date(Message.created_at).label("day"),
+            func.count(Message.id).label("count")
+        )
+        .filter(Message.user_id == user.id)     # ✅ بدل session_id
+        .group_by("day")
+        .order_by("day")
+        .all()
+    )
+    msgs = [{"day": str(m.day), "count": m.count} for m in messages_per_day]
+
+    # ✅ CEFR progression (ديال user فقط)
+    levels = (
+        db.query(Message.created_at, Message.level)
+        .filter(Message.user_id == user.id)     # ✅ بدل session_id
+        .filter(Message.level.isnot(None))
+        .filter(Message.level != "")
+        .order_by(Message.created_at)
+        .all()
+    )
+
+    level_map = {lvl: i for i, lvl in enumerate(LEVEL_ORDER)}
+    progression = [
+        {"time": str(l.created_at), "level": l.level, "value": level_map.get(l.level, 0)}
+        for l in levels
+    ]
+
+    total_messages = (
+        db.query(func.count(Message.id))
+        .filter(Message.user_id == user.id)     # ✅ بدل session_id
+        .scalar()
+    )
+
+    return {
+        "top_errors": top_errors,
+        "messages_per_day": msgs,
+        "progression": progression,
+        "total_messages": total_messages
+    }

backend/app/core/deps.py

@@ -0,0 +1,33 @@
+from fastapi import Depends, HTTPException
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from sqlalchemy.orm import Session
+from ..db.session import SessionLocal
+from ..db.models import User
+from ..core.security import decode_token
+
+bearer = HTTPBearer(auto_error=False)
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+def get_current_user(
+    creds: HTTPAuthorizationCredentials = Depends(bearer),
+    db: Session = Depends(get_db),
+):
+    if not creds:
+        raise HTTPException(status_code=401, detail="Missing token")
+    token = creds.credentials
+    try:
+        payload = decode_token(token)
+        user_id = int(payload["sub"])
+    except Exception:
+        raise HTTPException(status_code=401, detail="Invalid token")
+
+    user = db.query(User).filter(User.id == user_id).first()
+    if not user:
+        raise HTTPException(status_code=401, detail="User not found")
+    return user

backend/app/core/security.py

@@ -0,0 +1,24 @@
+import os
+from datetime import datetime, timedelta
+from passlib.context import CryptContext
+import jwt
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+JWT_SECRET = os.getenv("JWT_SECRET", "CHANGE_ME_SUPER_SECRET")
+JWT_ALG = "HS256"
+JWT_EXPIRE_HOURS = int(os.getenv("JWT_EXPIRE_HOURS", "72"))
+
+def hash_password(password: str) -> str:
+    return pwd_context.hash(password)
+
+def verify_password(password: str, password_hash: str) -> bool:
+    return pwd_context.verify(password, password_hash)
+
+def create_access_token(user_id: int, email: str):
+    exp = datetime.utcnow() + timedelta(hours=JWT_EXPIRE_HOURS)
+    payload = {"sub": str(user_id), "email": email, "exp": exp}
+    return jwt.encode(payload, JWT_SECRET, algorithm=JWT_ALG)
+
+def decode_token(token: str):
+    return jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALG])

backend/app/db/database.py

@@ -0,0 +1,26 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, declarative_base
+
+DATABASE_URL = "sqlite:///./learnlanguage.db"
+
+engine = create_engine(
+    DATABASE_URL,
+    connect_args={"check_same_thread": False}
+)
+
+SessionLocal = sessionmaker(
+    autocommit=False,
+    autoflush=False,
+    bind=engine
+)
+
+Base = declarative_base()
+
+
+# ✅ IMPORTANT: THIS WAS MISSING
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

backend/app/db/models.py

@@ -0,0 +1,41 @@
+from sqlalchemy import Column, Integer, String, DateTime, ForeignKey, Text, func
+from sqlalchemy.orm import relationship
+from datetime import datetime
+from .session import Base
+
+class User(Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(String(255), unique=True, index=True, nullable=False)
+    username = Column(String(80), unique=True, index=True, nullable=False)
+    password_hash = Column(String(255), nullable=False)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    messages = relationship("Message", back_populates="user", cascade="all, delete-orphan")
+
+
+class Message(Base):
+    __tablename__ = "messages"
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False, index=True)
+    role = Column(String(16), nullable=False)  # "user" | "bot"
+    text = Column(Text, nullable=False)
+    level = Column(String(8), nullable=True)
+    topic = Column(String(64), nullable=True)
+    created_at = Column(DateTime, default=datetime.utcnow, index=True)
+
+    user = relationship("User", back_populates="messages")
+
+class Correction(Base):
+    __tablename__ = "corrections"
+    id = Column(Integer, primary_key=True, index=True)
+
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False, index=True)  # ✅ مهم
+
+    error = Column(String, nullable=False)
+    suggestion = Column(String, default="")
+    explanation = Column(Text, default="")
+
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    user = relationship("User")

backend/app/db/repo.py

@@ -0,0 +1,38 @@
+from sqlalchemy.orm import Session
+from .models import Message, Correction
+
+def save_message(db: Session, session_id: str, role: str, content: str, level: str = "", topic: str = ""):
+    m = Message(session_id=session_id, role=role, content=content, level=level, topic=topic)
+    db.add(m)
+    db.commit()
+
+def save_corrections(db: Session, session_id: str, corrections: list):
+    for c in corrections or []:
+        db.add(Correction(
+            session_id=session_id,
+            error=c.get("error",""),
+            suggestion=c.get("suggestion",""),
+            explanation=c.get("explanation","")
+        ))
+    db.commit()
+
+def get_last_messages(db: Session, session_id: str, limit: int = 12):
+    rows = (db.query(Message)
+              .filter(Message.session_id == session_id)
+              .order_by(Message.id.desc())
+              .limit(limit)
+              .all())
+    rows.reverse()
+    return [{"role": r.role, "content": r.content, "level": r.level, "topic": r.topic} for r in rows]
+
+def top_errors(db: Session, session_id: str, limit: int = 5):
+    # simple frequency count in python (fast enough)
+    rows = (db.query(Correction)
+              .filter(Correction.session_id == session_id)
+              .all())
+    freq = {}
+    for r in rows:
+        key = (r.error.strip().lower(), r.suggestion.strip())
+        freq[key] = freq.get(key, 0) + 1
+    ranked = sorted(freq.items(), key=lambda x: x[1], reverse=True)[:limit]
+    return [{"error": k[0], "suggestion": k[1], "count": v} for k, v in ranked]

backend/app/db/session.py

@@ -0,0 +1,19 @@
+import os
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, declarative_base
+
+# مهم: نخلي db داخل storage باش ما يطيحش
+DB_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), "..", "storage")
+DB_DIR = os.path.abspath(DB_DIR)
+os.makedirs(DB_DIR, exist_ok=True)
+
+DB_PATH = os.path.join(DB_DIR, "learnlanguage.db")
+DATABASE_URL = f"sqlite:///{DB_PATH}"
+
+engine = create_engine(
+    DATABASE_URL,
+    connect_args={"check_same_thread": False},
+    future=True,
+)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine, future=True)
+Base = declarative_base()

backend/app/main.py

@@ -0,0 +1,16 @@
+from fastapi import FastAPI
+from .db.session import Base, engine
+from .api.routes_auth import router as auth_router
+from .api.routes_chat import router as chat_router
+from .api.routes_stats import router as stats_router
+
+app = FastAPI(title="LearnLanguage API")
+
+Base.metadata.create_all(bind=engine)
+
+@app.get("/")
+def health():
+    return {"status": "ok"}
+app.include_router(auth_router)
+app.include_router(chat_router)
+app.include_router(stats_router)

backend/app/schemas/auth.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel, EmailStr
+
+class RegisterIn(BaseModel):
+    email: EmailStr
+    username: str
+    password: str
+
+class LoginIn(BaseModel):
+    email: EmailStr
+    password: str
+
+class AuthOut(BaseModel):
+    token: str
+    user_id: int
+    email: EmailStr
+    username: str

backend/app/services/__init__.py

@@ -0,0 +1,16 @@
+from pathlib import Path
+import joblib
+
+MODEL_PATH = Path("ml/models/cefr_model.pkl")
+
+class CEFRPredictor:
+    def __init__(self):
+        if not MODEL_PATH.exists():
+            raise FileNotFoundError(f"Model not found: {MODEL_PATH}")
+        self.model = joblib.load(MODEL_PATH)
+
+    def predict(self, text: str) -> str:
+        text = (text or "").strip()
+        if not text:
+            return "A2"  # default safe
+        return self.model.predict([text])[0]

backend/app/services/cefr_predictor.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+import joblib
+
+# رجّع root ديال المشروع (learnlanguage)
+ROOT = Path(__file__).resolve().parents[3]  # .../learnlanguage
+MODEL_PATH = ROOT / "ml" / "models" / "cefr_model.pkl"
+
+class CEFRPredictor:
+    def __init__(self):
+        if not MODEL_PATH.exists():
+            raise FileNotFoundError(f"Model not found: {MODEL_PATH}")
+        self.model = joblib.load(MODEL_PATH)
+
+    def predict(self, text: str) -> str:
+        text = (text or "").strip()
+        if not text:
+            return "A2"
+        return self.model.predict([text])[0]

backend/app/services/feedback.py

@@ -0,0 +1,36 @@
+import language_tool_python
+
+_tool = None
+
+def _get_tool():
+    global _tool
+    if _tool is None:
+        _tool = language_tool_python.LanguageTool("en-US")
+    return _tool
+
+def grammar_feedback(text: str, max_items: int = 6):
+    text = (text or "").strip()
+    if not text:
+        return text, []
+
+    try:
+        tool = _get_tool()
+        matches = tool.check(text)
+        corrected = language_tool_python.utils.correct(text, matches)
+
+        corrections = []
+        for m in matches[:max_items]:
+            suggestion = m.replacements[0] if m.replacements else ""
+            # ✅ هنا الفرق
+            error_fragment = text[m.offset:m.offset + m.error_length]
+
+            corrections.append({
+                "offset": m.offset,
+                "error": error_fragment,
+                "suggestion": suggestion,
+                "rule": getattr(m, "ruleId", ""),
+                "message": m.message
+            })
+        return corrected, corrections
+    except Exception:
+        return text, []

backend/app/services/llm_tutor.py

@@ -0,0 +1,96 @@
+import json
+import requests
+from typing import List, Dict, Any
+
+OLLAMA_URL = "http://127.0.0.1:11434/api/chat"
+OLLAMA_MODEL = "llama3.2:3b"   # بدلها لـ llama3.1:8b إذا بغيتي
+
+SYSTEM_TUTOR = """
+You are a professional English tutor.
+
+You MUST:
+1. Correct the user's sentence.
+2. Explain the corrections briefly.
+3. Answer the user's question directly.
+4. Ask ONE follow-up question related to the user's message.
+5. Provide ONE short exercise related to the same topic.
+
+VERY IMPORTANT:
+- Output MUST be ONLY valid JSON.
+- No markdown.
+- No code fences.
+- No extra text.
+- Always fill all fields.
+
+Return exactly this structure:
+
+{
+  "reply": "...",
+  "corrected_text": "...",
+  "corrections": [
+      {"error": "...", "suggestion": "...", "explanation": "..."}
+  ],
+  "followup_question": "...",
+  "exercise": {"type": "...", "prompt": "...", "answer": "..."}
+}
+"""
+
+def _history_to_messages(history: List[Dict[str, Any]]) -> List[Dict[str, str]]:
+    msgs = [{"role": "system", "content": SYSTEM_TUTOR.strip()}]
+
+    # keep last 10 turns
+    for h in history[-10:]:
+        role = (h.get("role") or "").lower()
+        content = (h.get("content") or "").strip()
+        if not content:
+            continue
+
+        if role == "you":
+            msgs.append({"role": "user", "content": content})
+        elif role == "bot":
+            msgs.append({"role": "assistant", "content": content})
+
+    return msgs
+
+def call_llm(message: str, cefr_level: str, topic: str, profile: dict, history: List[Dict[str, Any]]):
+    msgs = _history_to_messages(history)
+
+    user_prompt = f"""
+CEFR level: {cefr_level}
+Detected topic: {topic}
+Known profile facts: {profile}
+
+User message:
+{message}
+
+Return JSON only.
+""".strip()
+
+    msgs.append({"role": "user", "content": user_prompt})
+
+    payload = {
+        "model": OLLAMA_MODEL,
+        "messages": msgs,
+        "stream": False,
+             "options": {
+  "temperature": 0.4,
+  "num_predict": 300
+}
+    }
+
+    try:
+        r = requests.post(OLLAMA_URL, json=payload, timeout=180)
+   
+        r.raise_for_status()
+        data = r.json()
+        # Ollama returns: {"message": {"role":"assistant","content":"..."} , ...}
+        return data["message"]["content"]
+    except Exception:
+        # fallback JSON if Ollama is not running
+        return """{
+  "reply":"⚠️ Local LLM (Ollama) not reachable. Make sure Ollama is running and the model is pulled.",
+  "corrected_text":"",
+  "corrections":[],
+  "followup_question":"What do you want to practice today (home, study, food, travel)?",
+  "exercise":{"type":"fill_blank","prompt":"I ___ English every day. (study/studies)","answer":"study"}
+}"""

backend/app/services/tutor_engine.py

@@ -0,0 +1,188 @@
+import json, re
+from collections import Counter
+from .cefr_predictor import CEFRPredictor
+from ..db.repo import top_errors
+
+predictor = CEFRPredictor()
+LEVEL_ORDER = ["A1","A2","B1","B2","C1","C2"]
+
+SYSTEM_JSON = """
+You are a professional English tutor.
+
+You MUST:
+- Answer the user's question directly.
+- Correct the user's sentence (capitalization, punctuation, grammar).
+- Provide corrections with short explanations.
+- Ask ONE follow-up question related to the same topic.
+- Provide ONE short micro-exercise related to the same topic.
+- Keep reply under 2 sentences.
+
+Return ONLY valid JSON (no markdown, no code fences), exactly keys:
+reply, corrected_text, corrections, followup_question, exercise
+
+corrections: array of {error, suggestion, explanation} max 5
+exercise: {type, prompt, answer}
+"""
+
+def smooth_level(levels, current):
+    levels = [x for x in (levels or []) if x in LEVEL_ORDER]
+    if current in LEVEL_ORDER: levels.append(current)
+    if not levels: return current or "A2"
+    return Counter(levels).most_common(1)[0][0]
+
+def detect_topic(text: str) -> str:
+    t = (text or "").lower()
+    if "irregular" in t: return "irregular_verbs"
+    if any(k in t for k in ["tense","past","present","future"]): return "tenses"
+    if any(k in t for k in ["food","eat"]): return "food"
+    if any(k in t for k in ["study","school","exam"]): return "study"
+    if any(k in t for k in ["live","city","country","from","morocco"]): return "home"
+    return "general"
+
+def extract_profile(history):
+    profile = {}
+    for h in history[-12:]:
+        if (h.get("role") or "") == "You":
+            msg = (h.get("content") or "").lower()
+            m = re.search(r"\bmy name is\s+([a-z]+)", msg)
+            if m: profile["name"] = m.group(1).title()
+            m = re.search(r"\bi live in\s+([a-z\s]+)", msg)
+            if m: profile["lives_in"] = m.group(1).strip().title()
+    return profile
+
+def safe_json_parse(text: str):
+    cleaned = (text or "").strip()
+    cleaned = re.sub(r"^```(?:json)?\s*", "", cleaned, flags=re.IGNORECASE)
+    cleaned = re.sub(r"\s*```$", "", cleaned)
+
+    m = re.search(r"\{.*\}", cleaned, flags=re.DOTALL)
+    if m: cleaned = m.group(0)
+
+    try:
+        data = json.loads(cleaned)
+        data.setdefault("reply","")
+        data.setdefault("corrected_text","")
+        data.setdefault("corrections",[])
+        data.setdefault("followup_question","")
+        data.setdefault("exercise", {"type":"","prompt":"","answer":""})
+        return data
+    except Exception:
+        return {
+            "reply": cleaned[:700],
+            "corrected_text": "",
+            "corrections": [],
+            "followup_question": "Can you tell me more?",
+            "exercise": {"type":"rewrite","prompt":"Rewrite your sentence correctly.","answer":""}
+        }
+
+def make_exercise_from_top_errors(level: str, errors: list):
+    # errors = [{"error":"at morocco","suggestion":"in Morocco","count":3},...]
+    if not errors:
+        return {"type":"", "prompt":"", "answer":""}
+
+    e0 = errors[0]
+    if level in ["A1","A2"]:
+        return {
+            "type":"fix_mistake",
+            "prompt": f"Fix this: 'I live {e0['error']}'.",
+            "answer": f"I live {e0['suggestion']}."
+        }
+    return {
+        "type":"rewrite",
+        "prompt": f"Rewrite correctly and add a reason: 'I live {e0['error']}'.",
+        "answer": f"I live {e0['suggestion']} because ..."
+    }
+
+def build_prompt_context(user_text: str, history: list, db, session_id: str):
+    recent_levels = [h.get("level") for h in history if h.get("level")]
+    pred = predictor.predict(user_text)
+    level = smooth_level(recent_levels, pred)
+    topic = detect_topic(user_text)
+    profile = extract_profile(history)
+
+    # progress: top errors from db
+    errs = top_errors(db, session_id, limit=3)
+
+    # build messages for ollama
+    # We include system + short conversation + user instruction
+    msgs = [{"role":"system","content":SYSTEM_JSON.strip()}]
+
+    for h in history[-10:]:
+        role = (h.get("role") or "")
+        content = (h.get("content") or "")
+        if not content: continue
+        if role == "You":
+            msgs.append({"role":"user","content":content})
+        elif role == "Bot":
+            msgs.append({"role":"assistant","content":content})
+
+    user_instruction = f"""
+CEFR: {level}
+Topic: {topic}
+Profile: {profile}
+Common mistakes to focus on: {errs}
+
+User message:
+{user_text}
+
+Return JSON only.
+""".strip()
+
+    msgs.append({"role":"user","content":user_instruction})
+
+    return {"level": level, "topic": topic, "profile": profile, "ollama_messages": msgs}
+from ..db.models import Message, Correction
+from .llm_tutor import call_llm
+def chat(user_text: str, user, history=None, mode="conversation", db=None):
+    history = history or []
+
+    pred = predictor.predict(user_text)
+    recent_levels = [h.get("level") for h in history if h.get("level")]
+    level = smooth_level(recent_levels, pred)
+    topic = detect_topic(user_text)
+    profile = extract_profile(history)
+
+    # Call LLM
+    raw = call_llm(user_text, level, topic, profile, history)
+    parsed = safe_json_parse(raw)
+
+    # ---------------- SAVE USER MESSAGE ----------------
+    user_msg = Message(
+        user_id=user.id,
+        role="user",
+        text=user_text,
+        level=level,
+        topic=topic
+    )
+    db.add(user_msg)
+
+    # ---------------- SAVE BOT MESSAGE ----------------
+    bot_msg = Message(
+        user_id=user.id,
+        role="bot",
+        text=parsed.get("reply",""),
+        level=level,
+        topic=topic
+    )
+    db.add(bot_msg)
+
+    db.flush()  # باش ناخدو id
+
+    # ---------------- SAVE CORRECTIONS ----------------
+    corrections = parsed.get("corrections", [])
+    for c in corrections:
+        corr = Correction(
+            user_id=user.id,
+            error=c.get("error",""),
+            suggestion=c.get("suggestion",""),
+            explanation=c.get("explanation","")
+        )
+        db.add(corr)
+
+    db.commit()
+
+    return {
+        "level": level,
+        "topic": topic,
+        **parsed
+    }

backend/render.yaml

@@ -0,0 +1 @@
+

backend/requirements.txt

@@ -0,0 +1,11 @@
+fastapi==0.111.0
+uvicorn[standard]==0.30.1
+
+sqlalchemy==2.0.30
+pydantic==2.7.4
+
+python-jose[cryptography]==3.3.0
+passlib==1.7.4
+
+python-multipart==0.0.9
+requests==2.32.3

backend/run.py

@@ -0,0 +1,4 @@
+import uvicorn
+
+if __name__ == "__main__":
+    uvicorn.run("backend.app.main:app", host="127.0.0.1", port=8000)

frontend/app.py

@@ -0,0 +1,203 @@
+import streamlit as st
+import requests
+import json
+import pandas as pd
+from datetime import datetime
+
+API_URL = "http://127.0.0.1:8001"
+
+st.set_page_config(
+    page_title="LearnLanguage 2026 • Tutor",
+    page_icon="🧠",
+    layout="wide",
+)
+
+# ---------------- SESSION ----------------
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+
+if "last" not in st.session_state:
+    st.session_state.last = None
+
+if "mode" not in st.session_state:
+    st.session_state.mode = "conversation"
+
+if "token" not in st.session_state:
+    st.session_state.token = None
+
+
+# ---------------- STREAM FUNCTION ----------------
+def stream_chat(message: str):
+
+    payload = {
+        "message": message,
+        "mode": st.session_state.mode
+    }
+
+    headers = {
+        "Authorization": f"Bearer {st.session_state.token}"
+    }
+
+    r = requests.post(
+        f"{API_URL}/chat",
+        json=payload,
+        headers=headers,
+        timeout=180
+    )
+
+    r.raise_for_status()
+
+    data = r.json()
+
+    yield ("final", data)
+# ---------------- SIDEBAR AUTH ----------------
+with st.sidebar:
+    st.markdown("## 🔐 Account")
+
+    tabL, tabR = st.tabs(["Login", "Register"])
+
+    with tabL:
+        email = st.text_input("Email", key="login_email")
+        pwd = st.text_input("Password", type="password", key="login_pwd")
+
+        if st.button("Login", use_container_width=True):
+            r = requests.post(
+                f"{API_URL}/auth/login",
+                json={"email": email, "password": pwd}
+            )
+
+            if r.status_code == 200:
+                st.session_state.token = r.json()["token"]
+                st.success("Logged in ✅")
+                st.rerun()
+            else:
+                st.error(r.text)
+
+    with tabR:
+        email2 = st.text_input("Email", key="reg_email")
+        username2 = st.text_input("Username", key="reg_username")
+        pwd2 = st.text_input("Password", type="password", key="reg_pwd")
+
+        if st.button("Create account", use_container_width=True):
+            r = requests.post(
+                f"{API_URL}/auth/register",
+                json={"email": email2, "username": username2, "password": pwd2}
+            )
+
+            if r.status_code == 200:
+                st.session_state.token = r.json()["token"]
+                st.success("Account created ✅")
+                st.rerun()
+            else:
+                st.error(r.text)
+
+    if st.session_state.token:
+        me = requests.get(
+            f"{API_URL}/auth/me",
+            headers={"Authorization": f"Bearer {st.session_state.token}"}
+        )
+
+        if me.status_code == 200:
+            st.success(f"Connected as: {me.json()['username']}")
+
+        if st.button("Logout", use_container_width=True):
+            st.session_state.token = None
+            st.session_state.messages = []
+            st.rerun()
+
+
+# ---------------- MAIN HEADER ----------------
+st.title("🧠 LearnLanguage • Streaming Tutor")
+st.caption("Streaming replies • Corrections • Exercises • Progress-ready")
+
+
+# ---------------- INPUT ----------------
+if not st.session_state.token:
+    st.warning("Please login first to start chatting.")
+    st.stop()
+
+colA, colB = st.columns([5, 1])
+
+with colA:
+    user_msg = st.text_input(
+        "Type your message (English)",
+        placeholder="e.g., I like my city because it is calm..."
+    )
+
+with colB:
+    send = st.button("Send 🚀", use_container_width=True)
+
+
+# ---------------- SEND LOGIC ----------------
+if send and user_msg.strip():
+
+    ts = datetime.now().strftime("%H:%M")
+
+    st.session_state.messages.append({
+        "role": "user",
+        "text": user_msg,
+        "ts": ts
+    })
+
+    streamed_text = ""
+    placeholder = st.empty()
+
+    try:
+        for kind, data in stream_chat(user_msg):
+
+            if kind == "text":
+                streamed_text += data
+                placeholder.markdown(f"**Tutor (streaming…)**\n\n{streamed_text}")
+
+            else:
+                res = data
+                st.session_state.last = res
+                st.session_state.messages.append({
+                    "role": "bot",
+                    "text": res.get("reply", ""),
+                    "ts": datetime.now().strftime("%H:%M")
+                })
+                break
+
+        st.rerun()
+
+    except Exception as e:
+        st.error(f"Streaming error: {e}")
+
+
+# ---------------- CHAT HISTORY ----------------
+st.markdown("## 💬 Conversation")
+
+for m in st.session_state.messages[-30:]:
+    who = "You" if m["role"] == "user" else "Tutor"
+    st.markdown(f"**{who} • {m['ts']}**")
+    st.write(m["text"])
+
+
+# ---------------- TUTOR PANEL ----------------
+st.markdown("## 🧾 Tutor Panel")
+
+res = st.session_state.last or {}
+
+tabs = st.tabs(["Feedback", "Exercises", "Raw JSON"])
+
+with tabs[0]:
+    st.markdown("**Corrected text**")
+    st.write(res.get("corrected_text", "—"))
+
+    st.markdown("**Corrections**")
+    corrections = res.get("corrections", [])
+    if corrections:
+        st.dataframe(pd.DataFrame(corrections))
+    else:
+        st.success("No corrections 🎉")
+
+    st.markdown("**Follow-up question**")
+    st.write(res.get("followup_question", "—"))
+
+with tabs[1]:
+    st.json(res.get("exercise", {}))
+    st.json(res.get("exercise_from_progress", {}))
+
+with tabs[2]:
+    st.json(res)

frontend/pages/2_📊_Dashboard.py

@@ -0,0 +1,182 @@
+import streamlit as st
+import requests
+import pandas as pd
+
+API_URL = "http://127.0.0.1:8001"
+
+st.set_page_config(
+    page_title="LearnLanguage • Dashboard",
+    page_icon="📊",
+    layout="wide"
+)
+
+# ---------------- SESSION ----------------
+if "token" not in st.session_state:
+    st.session_state.token = None
+
+# ---------------- CSS ----------------
+st.markdown("""
+<style>
+.stApp{ background:#f6f7fb; }
+.card{
+  background:#ffffff;
+  border:1px solid #e9ecf3;
+  border-radius:16px;
+  padding:16px 18px;
+  box-shadow:0 10px 24px rgba(17,24,39,0.06);
+}
+.kpi-title{ color:#6b7280; font-size:12px; font-weight:700; }
+.kpi-value{ color:#111827; font-size:26px; font-weight:900; }
+.empty-state{
+  padding:14px;
+  border:1px dashed #d8dde8;
+  border-radius:14px;
+  background:#fbfcff;
+  color:#6b7280;
+}
+</style>
+""", unsafe_allow_html=True)
+
+# ---------------- HELPERS ----------------
+def api_get(path: str, token: str, timeout=10):
+    headers = {"Authorization": f"Bearer {token}"}
+    r = requests.get(f"{API_URL}{path}", headers=headers, timeout=timeout)
+    r.raise_for_status()
+    return r.json()
+
+def api_post(path: str, payload: dict, timeout=10):
+    r = requests.post(f"{API_URL}{path}", json=payload, timeout=timeout)
+    return r
+
+# ---------------- SIDEBAR: LOGIN ----------------
+with st.sidebar:
+    st.markdown("<div class='card'>", unsafe_allow_html=True)
+    st.markdown("### 🔐 Account")
+
+    if not st.session_state.token:
+        email = st.text_input("Email", key="dash_email")
+        pwd = st.text_input("Password", type="password", key="dash_pwd")
+
+        c1, c2 = st.columns(2)
+        with c1:
+            if st.button("Login", use_container_width=True):
+                resp = api_post("/auth/login", {"email": email, "password": pwd})
+                if resp.status_code == 200:
+                    st.session_state.token = resp.json()["token"]
+                    st.success("Logged in ✅")
+                    st.rerun()
+                else:
+                    st.error(resp.text)
+
+        with c2:
+            if st.button("Register", use_container_width=True):
+                st.info("Register from main app (or add register form here).")
+
+    else:
+        # show user
+        try:
+            me = api_get("/auth/me", st.session_state.token, timeout=6)
+            st.caption(f"Connected as: **{me.get('username','')}**")
+        except Exception:
+            st.caption("Connected (token)")
+
+        if st.button("Logout", use_container_width=True):
+            st.session_state.token = None
+            st.rerun()
+
+    st.markdown("</div>", unsafe_allow_html=True)
+
+# ---------------- LOGIN CHECK ----------------
+if not st.session_state.token:
+    st.warning("Please login to view your dashboard.")
+    st.stop()
+
+# ---------------- LOAD DATA ----------------
+try:
+    data = api_get("/stats/me", st.session_state.token, timeout=10)
+except Exception as e:
+    st.error(f"Cannot load stats: {e}")
+    st.stop()
+
+# ---------------- KPIs ----------------
+total_messages = data.get("total_messages", 0)
+progression = data.get("progression", [])
+messages_per_day = data.get("messages_per_day", [])
+top_errors = data.get("top_errors", [])
+
+current_level = progression[-1]["level"] if progression else "—"
+active_days = len(messages_per_day) if messages_per_day else 0
+top_error_text = top_errors[0]["error"] if top_errors else "—"
+
+st.title("📊 Progress Dashboard")
+
+c1, c2, c3, c4 = st.columns(4)
+
+with c1:
+    st.markdown("<div class='card'>", unsafe_allow_html=True)
+    st.markdown("<div class='kpi-title'>Total Messages</div>", unsafe_allow_html=True)
+    st.markdown(f"<div class='kpi-value'>{total_messages}</div>", unsafe_allow_html=True)
+    st.markdown("</div>", unsafe_allow_html=True)
+
+with c2:
+    st.markdown("<div class='card'>", unsafe_allow_html=True)
+    st.markdown("<div class='kpi-title'>Current Level</div>", unsafe_allow_html=True)
+    st.markdown(f"<div class='kpi-value'>{current_level}</div>", unsafe_allow_html=True)
+    st.markdown("</div>", unsafe_allow_html=True)
+
+with c3:
+    st.markdown("<div class='card'>", unsafe_allow_html=True)
+    st.markdown("<div class='kpi-title'>Active Days</div>", unsafe_allow_html=True)
+    st.markdown(f"<div class='kpi-value'>{active_days}</div>", unsafe_allow_html=True)
+    st.markdown("</div>", unsafe_allow_html=True)
+
+with c4:
+    st.markdown("<div class='card'>", unsafe_allow_html=True)
+    st.markdown("<div class='kpi-title'>Top Mistake</div>", unsafe_allow_html=True)
+    st.markdown(f"<div class='kpi-value'>{top_error_text}</div>", unsafe_allow_html=True)
+    st.markdown("</div>", unsafe_allow_html=True)
+
+st.divider()
+
+# ---------------- CHARTS ----------------
+left, right = st.columns(2)
+
+with left:
+    st.markdown("### 📈 CEFR Progression")
+
+    if progression:
+        dfp = pd.DataFrame(progression)
+
+        mapping = {"A1":0,"A2":1,"B1":2,"B2":3,"C1":4,"C2":5}
+        if "value" not in dfp.columns:
+            dfp["value"] = dfp["level"].map(mapping).fillna(0)
+
+        dfp["time"] = pd.to_datetime(dfp["time"], errors="coerce")
+        dfp = dfp.dropna(subset=["time"]).sort_values("time").set_index("time")
+
+        st.line_chart(dfp["value"])
+        st.caption("0=A1, 1=A2, 2=B1, 3=B2, 4=C1, 5=C2")
+    else:
+        st.markdown("<div class='empty-state'>No progression yet.</div>", unsafe_allow_html=True)
+
+with right:
+    st.markdown("### 💬 Messages Per Day")
+
+    if messages_per_day:
+        dfm = pd.DataFrame(messages_per_day)
+        dfm["day"] = pd.to_datetime(dfm["day"], errors="coerce")
+        dfm = dfm.dropna(subset=["day"]).sort_values("day").set_index("day")
+
+        st.bar_chart(dfm["count"])
+    else:
+        st.markdown("<div class='empty-state'>No activity yet.</div>", unsafe_allow_html=True)
+
+st.divider()
+
+# ---------------- TOP ERRORS ----------------
+st.markdown("### ❌ Top Frequent Mistakes")
+
+if top_errors:
+    st.dataframe(pd.DataFrame(top_errors), use_container_width=True, hide_index=True)
+else:
+    st.markdown("<div class='empty-state'>🎉 No repeated errors yet.</div>", unsafe_allow_html=True)