Made app

.gitignore

@@ -0,0 +1,19 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.db
+
+# Env
+.env
+.venv/
+venv/
+
+# IDEs
+.vscode/
+.idea/
+
+# OS
+.DS_Store
+Thumbs.db

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1 @@
+from backend.server import app

backend/chains/router.py

@@ -0,0 +1,191 @@
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from langchain_chroma import Chroma
+from langchain_huggingface import HuggingFaceEmbeddings
+from backend.llms.custom import CustomChatModel
+from langchain_openai import ChatOpenAI
+from langchain_core.runnables import (
+    RunnableBranch,
+    RunnableLambda,
+    RunnableParallel,
+    RunnablePassthrough,
+)
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.messages import get_buffer_string
+from langchain_core.runnables.history import RunnableWithMessageHistory
+from langchain_community.chat_message_histories import ChatMessageHistory
+
+from backend.schemas.api_models import ChatInput, ChatOutput
+from backend.prompts.templates import (
+    rag_prompt,
+    quiz_generator_prompt,
+    flashcard_generator_prompt,
+    condense_question_prompt,
+)
+
+vector_store = Chroma(
+    persist_directory="app/vector_store",
+    embedding_function=HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2"),
+)
+openai_llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.1)
+finetuned_llm = CustomChatModel(
+    api_url="https://nutnell-directed-ai.hf.space/generate"
+).with_fallbacks([openai_llm])
+
+
+def format_docs(docs):
+    return "\n---\n".join(doc.page_content for doc in docs)
+
+
+def get_sources_from_docs(docs):
+    return [
+        {
+            "source": doc.metadata.get("source_url", ""),
+            "name": doc.metadata.get("source_name", ""),
+        }
+        for doc in docs
+    ]
+
+
+memories = {}
+
+
+def get_memory_for_session(session_id: str):
+    if session_id not in memories:
+        memories[session_id] = ChatMessageHistory()
+    return memories[session_id]
+
+
+def EducationalRetriever():
+    """Component 1: Identifies relevant curriculum content."""
+    return vector_store.as_retriever(search_kwargs={"k": 5})
+
+
+def AdaptiveConversationChain():
+    """Component 2: Produces personalized explanations using structured prompts and context."""
+    retriever = EducationalRetriever()
+    condense_question_chain = (
+        RunnableLambda(
+            lambda x: {
+                "question": x["input"],
+                "chat_history": get_buffer_string(x["chat_history"]),
+            }
+        )
+        | condense_question_prompt
+        | openai_llm
+        | StrOutputParser()
+    )
+    return RunnablePassthrough.assign(
+        standalone_question=condense_question_chain
+    ).assign(
+        context=(
+            RunnableLambda(lambda x: x["standalone_question"]) | retriever
+        ).with_config({"run_name": "EducationalRetriever"})
+    ) | RunnableParallel(
+        answer=(
+            RunnableLambda(
+                lambda x: {
+                    "context": format_docs(x["context"]),
+                    "question": x["input"],
+                    "subject": x.get("subject", "the topic"),
+                    "difficulty_level": x.get("difficulty_level", "beginner"),
+                }
+            )
+            | rag_prompt
+            | finetuned_llm.with_config({"run_name": "AdaptiveConversationChain."})
+            | StrOutputParser()
+        ),
+        sources=RunnableLambda(lambda x: get_sources_from_docs(x["context"])),
+    )
+
+
+def ContentGenerator():
+    """Component 3: Creates practice questions, flashcards, and assessments."""
+    retriever = EducationalRetriever()
+
+    QuizGenerationChain = RunnablePassthrough.assign(
+        context=(RunnableLambda(lambda x: x["input"]) | retriever).with_config(
+            {"run_name": "EducationalRetriever_Quiz"}
+        )
+    ) | RunnableParallel(
+        answer=(
+            RunnableLambda(
+                lambda x: {
+                    "context": format_docs(x["context"]),
+                    "subject": x.get("subject", "the provided topic"),
+                    "difficulty_level": x.get("difficulty_level", "intermediate"),
+                }
+            )
+            | quiz_generator_prompt
+            | finetuned_llm.with_config({"run_name": "QuizGenerator"})
+            | StrOutputParser()
+        ),
+        sources=RunnableLambda(lambda x: get_sources_from_docs(x["context"])),
+    )
+
+    FlashcardGenerationChain = RunnablePassthrough.assign(
+        context=(RunnableLambda(lambda x: x["input"]) | retriever).with_config(
+            {"run_name": "EducationalRetriever_Flashcard"}
+        )
+    ) | RunnableParallel(
+        answer=(
+            RunnableLambda(
+                lambda x: {
+                    "context": format_docs(x["context"]),
+                    "difficulty_level": x.get("difficulty_level", "beginner"),
+                }
+            )
+            | flashcard_generator_prompt
+            | finetuned_llm.with_config({"run_name": "FlashcardGenerator"})
+            | StrOutputParser()
+        ),
+        sources=RunnableLambda(lambda x: get_sources_from_docs(x["context"])),
+    )
+
+    return RunnableBranch(
+        (lambda x: x.get("request_type") == "quiz_generation", QuizGenerationChain),
+        (
+            lambda x: x.get("request_type") == "flashcard_creation",
+            FlashcardGenerationChain,
+        ),
+        RunnableLambda(
+            lambda x: {"answer": "Unknown content type requested.", "sources": []}
+        ),
+    )
+
+
+def LearningAnalyzer():
+    """Component 4: Monitors user engagement and adapts response approaches (Placeholder)."""
+
+    def analyze(input_data):
+        print("LOG: LearningAnalyzer executed. User input:", input_data.get("input"))
+        return input_data
+
+    return RunnableLambda(analyze).with_config({"run_name": "LearningAnalyzer"})
+
+
+def run_educational_assistant():
+    """Central function that invokes components based on user requests."""
+    return RunnableBranch(
+        (lambda x: x.get("request_type") == "tutoring", AdaptiveConversationChain()),
+        ContentGenerator(),
+    )
+
+
+educational_assistant_chain = run_educational_assistant() | LearningAnalyzer()
+
+chat_chain_with_history = RunnableWithMessageHistory(
+    educational_assistant_chain,
+    get_memory_for_session,
+    input_messages_key="input",
+    history_messages_key="chat_history",
+    output_messages_key="answer",
+).with_types(input_type=ChatInput, output_type=ChatOutput)
+
+content_generation_chain = (ContentGenerator() | LearningAnalyzer()).with_types(
+    input_type=ChatInput, output_type=ChatOutput
+)
+
+

backend/llms/custom.py

@@ -0,0 +1,48 @@
+import requests
+import json
+from typing import Any, List, Optional
+from langchain_core.callbacks.manager import CallbackManagerForLLMRun
+from langchain_core.language_models.chat_models import SimpleChatModel
+from langchain_core.messages import BaseMessage, AIMessage
+
+class CustomChatModel(SimpleChatModel):
+    """A custom chat model that calls a remote FastAPI endpoint."""
+
+    api_url: str
+
+    @property
+    def _llm_type(self) -> str:
+        return "custom_chat_model"
+
+    def _call(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> str:
+        raw_prompt = messages[-1].content
+        headers = {"Content-Type": "application/json"}
+        data = {"prompt": raw_prompt}
+
+        try:
+            response = requests.post(self.api_url, headers=headers, data=json.dumps(data))
+            response.raise_for_status()
+
+            result = response.json()
+            full_text = result.get("response", "")
+
+            parts = full_text.split("<|start_header_id|>assistant<|end_header_id|>\n\n")
+            if len(parts) > 1:
+            
+                assistant_response = parts[1].replace("<|eot_id|>", "").strip()
+                if not assistant_response:
+                    raise ValueError("Model returned an empty response.")
+                return assistant_response
+            else:
+                raise ValueError("Could not parse the model's response.")
+
+        except (requests.exceptions.RequestException, ValueError) as e:
+            
+            print(f"Custom model failed: {e}. Attempting fallback.")
+            raise

backend/prompts/templates.py

@@ -0,0 +1,76 @@
+from langchain_core.prompts import ChatPromptTemplate
+
+CONDENSE_QUESTION_PROMPT_TEMPLATE = """
+Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question, in its original language.
+
+Chat History:
+{chat_history}
+
+Follow Up Input: {question}
+Standalone question:"""
+condense_question_prompt = ChatPromptTemplate.from_template(CONDENSE_QUESTION_PROMPT_TEMPLATE)
+
+RAG_PROMPT_TEMPLATE = """
+You are a helpful AI assistant for the DirectEd learning platform.
+Answer the user's question about the subject of '{subject}' based only on the following context.
+Your explanation should be tailored for a '{difficulty_level}' level.
+Cite the source name and URL if possible.
+If you don't know the answer, just say that you don't know.
+
+Context:
+{context}
+
+Question:
+{question}
+
+Helpful Answer:
+"""
+rag_prompt = ChatPromptTemplate.from_template(RAG_PROMPT_TEMPLATE)
+
+
+QUIZ_GENERATOR_PROMPT_TEMPLATE = """
+You are an expert quiz creator for a tech learning platform.
+Your task is to create at least 5-question multiple-choice quiz based on the provided context for the subject of '{subject}'.
+The questions should be of '{difficulty_level}' difficulty and relevant to the context.
+Provide the question, four options (A, B, C, D), and the correct answer.
+You can generate more than five if the user requests it.
+
+Format your response as follows:
+1. [Question 1]
+    A) [Option A]
+    B) [Option B]
+    C) [Option C]
+    D) [Option D]
+    Correct Answer: [A, B, C, or D]
+
+2. [Question 2]
+    ...
+
+Context:
+{context}
+
+Quiz Questions:
+"""
+quiz_generator_prompt = ChatPromptTemplate.from_template(QUIZ_GENERATOR_PROMPT_TEMPLATE)
+
+
+FLASHCARD_GENERATOR_PROMPT_TEMPLATE = """
+You are an expert instructional designer for the DirectEd learning platform.
+Based on the provided context, create at least a set of 5 concise flashcards of '{difficulty_level}' difficulty to help a user study.
+Each flashcard should have a 'Front' (a key term or question) and a 'Back' (a clear, simple definition or answer).
+
+Format your response exactly as follows:
+**Front:** [Term 1]
+**Back:** [Definition 1]
+
+**Front:** [Term 2]
+**Back:** [Definition 2]
+
+...
+
+Context:
+{context}
+
+Flashcards:
+"""
+flashcard_generator_prompt = ChatPromptTemplate.from_template(FLASHCARD_GENERATOR_PROMPT_TEMPLATE)

backend/schemas/api_models.py

@@ -0,0 +1,38 @@
+from pydantic import BaseModel, Field
+from typing import List, Literal, Optional
+
+class ChatInput(BaseModel):
+    input: str = Field(
+        ...,
+        description="The user's question or the topic for content generation.",
+        examples=["What is the difference between MLOps and LLMOps?"]
+    )
+    user_type: Literal["student", "instructor"] = Field(
+        ...,
+        description="The type of user making the request.",
+        examples=["student"]
+    )
+    request_type: Literal["tutoring", "quiz_generation", "flashcard_creation"] = Field( # <-- ADD flashcard_creation
+        ...,
+        description="The type of request, e.g., a tutoring question or a request to generate content.",
+        examples=["quiz_generation"]
+    )
+    
+    subject: Optional[str] = Field(
+        None, 
+        description="The subject or topic, can be used for filtering or context.",
+        examples=["LLMOps Fundamentals"]
+    )
+    difficulty_level: Optional[Literal["beginner", "intermediate", "advanced"]] = Field(
+        None, 
+        description="The desired difficulty level for the response or content.",
+        examples=["beginner"]
+    )
+
+class Source(BaseModel):
+    source: str = Field(..., description="The URL of the source document.")
+    name: str = Field(..., description="The name of the source (e.g., 'DirectEd Curriculum').")
+
+class ChatOutput(BaseModel):
+    answer: str = Field(..., description="The AI-generated answer or content.")
+    sources: Optional[List[Source]] = Field(None, description="A list of source documents used for the answer.")

backend/server.py

@@ -0,0 +1,48 @@
+import os
+from fastapi import FastAPI, Depends, HTTPException, status
+
+from langserve import add_routes
+from fastapi.middleware.cors import CORSMiddleware
+from dotenv import load_dotenv
+
+from backend.chains.router import educational_assistant_chain, chat_chain_with_history, content_generation_chain
+from backend.schemas.api_models import ChatInput
+
+load_dotenv()
+
+app = FastAPI(
+    title="DirectEd AI Assistant Server",
+    version="1.0",
+    description="A multi-functional API server for the DirectEd AI assistant.",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"],
+)
+
+
+add_routes(
+    app,
+    chat_chain_with_history,
+    path="/api/assistant/chat",
+)
+
+add_routes(
+    app,
+    content_generation_chain,
+    path="/api/assistant/content/generate",
+)
+
+@app.get("/api/assistant/analytics")
+def get_analytics():
+    """Placeholder endpoint for retrieving usage analytics."""
+    return {"status": "ok", "message": "Analytics endpoint is under development."}
+
+
+@app.get("/")
+def read_root():
+    """Health check endpoint."""
+    return {"status": "DirectEd AI Assistant is running"}
+
+

requirements.txt

@@ -0,0 +1,21 @@
+selenium
+webdriver-manager
+pypdf
+fastapi==0.111.0
+pydantic==2.8.2
+uvicorn==0.30.1
+python-dotenv==1.0.1
+langserve==0.3.1
+
+langchain
+langchain-core
+langchain-community
+langchain-openai
+langchain-chroma
+langchain-huggingface
+
+sentence-transformers
+chromadb
+requests
+beautifulsoup4
+sse_starlette