Upload 4 files

agent/graph.py

@@ -0,0 +1,82 @@
+import os
+from typing import List, Optional, TypedDict
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import JsonOutputParser
+from langgraph.graph import StateGraph, END
+from pydantic import BaseModel, Field
+
+# Define the output structure for the LLM
+class QuestionOutput(BaseModel):
+    question_text: str = Field(description="The text of the question")
+    options: List[str] = Field(description="A list of options including distractors and the correct answer")
+    correct_option_index: int = Field(description="The index of the correct option in the options list")
+
+# Define the state of the graph
+class AgentState(TypedDict):
+    qcm_description: str
+    existing_questions: List[str]
+    document_content: Optional[str]
+    generated_question: Optional[dict]
+
+# Initialize the LLM
+# Ensure OPENAI_API_KEY is set in the environment
+#GOOGLE_API_KEY = ""
+try:
+    llm = ChatGoogleGenerativeAI(model="gemini-2.5-flash-lite", temperature=0.7, api_key=GOOGLE_API_KEY)
+except Exception as e:
+    print(f"Warning: Failed to initialize ChatOpenAI: {e}")
+    llm = None
+
+def generate_question_node(state: AgentState):
+    """
+    Generates a new question based on the description and existing questions.
+    """
+    if not llm:
+        return {"generated_question": None}
+
+    description = state["qcm_description"]
+    existing = "\n".join([f"- {q}" for q in state["existing_questions"]])
+    
+    parser = JsonOutputParser(pydantic_object=QuestionOutput)
+    
+    document_content = state.get("document_content", "")
+    
+    prompt_text = "QCM Description: {description}\n\n"
+    if document_content:
+        prompt_text += "Document Content:\n{document_content}\n\n"
+        
+    prompt_text += "Existing Questions:\n{existing}\n\n"
+    prompt_text += "Generate a new question:\n{format_instructions}"
+
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", "You are an expert teacher assistant helping to create a Multiple Choice Question (QCM). "
+                   "Your goal is to generate a NEW, unique question based on the QCM description and the provided document content (if any). "
+                   "Avoid duplicating any of the existing questions. "
+                   "Provide the output in JSON format with 'question_text', 'options' (list of strings), and 'correct_option_index' (int)."),
+        ("user", prompt_text)
+    ])
+    
+    chain = prompt | llm | parser
+    
+    try:
+        result = chain.invoke({
+            "description": description,
+            "existing": existing,
+            "document_content": document_content,
+            "format_instructions": parser.get_format_instructions()
+        })
+        
+        return {"generated_question": result}
+    except Exception as e:
+        # Fallback or error handling
+        print(f"Error generating question: {e}")
+        return {"generated_question": None}
+
+# Build the graph
+workflow = StateGraph(AgentState)
+workflow.add_node("generate_question", generate_question_node)
+workflow.set_entry_point("generate_question")
+workflow.add_edge("generate_question", END)
+
+app = workflow.compile()

main.py

@@ -0,0 +1,19 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from routers import agent
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(agent.router)
+
+@app.get("/")
+def read_root():
+    return {"message": "Welcome to the QCM API"}

requirements.txt

@@ -0,0 +1,9 @@
+fastapi[standard]
+pydantic
+langgraph
+langchain
+langchain-openai
+langchain-google-genai
+pypdf
+python-docx
+

routers/agent.py

@@ -0,0 +1,70 @@
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from pydantic import BaseModel
+from typing import List, Optional
+import json
+import io
+from pypdf import PdfReader
+import docx
+from agent.graph import app as agent_app
+
+router = APIRouter(
+    prefix="/agent",
+    tags=["agent"],
+    responses={404: {"description": "Not found"}},
+)
+
+class GenerateQuestionRequest(BaseModel):
+    description: str
+    existing_questions: List[str]
+
+class GenerateQuestionResponse(BaseModel):
+    question_text: str
+    options: List[str]
+    correct_option_index: int
+
+@router.post("/generate-question", response_model=GenerateQuestionResponse)
+async def generate_question(
+    description: str = Form(...),
+    existing_questions: str = Form(default="[]"),
+    file: Optional[UploadFile] = File(None)
+):
+    try:
+        existing_questions_list = json.loads(existing_questions)
+        
+        document_content = ""
+        if file:
+            content = await file.read()
+            filename = file.filename.lower()
+            
+            if filename.endswith(".pdf"):
+                pdf = PdfReader(io.BytesIO(content))
+                text = ""
+                for page in pdf.pages:
+                    text += page.extract_text() + "\n"
+                document_content = text
+            elif filename.endswith(".docx"):
+                doc = docx.Document(io.BytesIO(content))
+                text = ""
+                for para in doc.paragraphs:
+                    text += para.text + "\n"
+                document_content = text
+            elif filename.endswith(".txt") or filename.endswith(".md"):
+                document_content = content.decode("utf-8")
+
+        inputs = {
+            "qcm_description": description,
+            "existing_questions": existing_questions_list,
+            "document_content": document_content,
+            "generated_question": None
+        }
+        
+        result = await agent_app.ainvoke(inputs)
+        
+        generated = result.get("generated_question")
+        if not generated:
+            raise HTTPException(status_code=500, detail="Failed to generate question")
+            
+        return generated
+    except Exception as e:
+        print(f"Error in generate_question: {e}")
+        raise HTTPException(status_code=500, detail=str(e))