Got feedback endpoint working

backend/app/main.py

@@ -4,7 +4,9 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse
 from pydantic import BaseModel
 from backend.app.problem_generator import ProblemGenerationPipeline
+from backend.app.problem_grader import ProblemGradingPipeline
 from typing import Dict, List
+import asyncio
 
 app = FastAPI()
 
@@ -22,11 +24,15 @@ class UrlInput(BaseModel):
 class UserQuery(BaseModel):
     user_query: str
 
-class FeedbackInput(BaseModel):
+# TODO: Make this a list of {problem: str, answer: str}. Would be cleaner for data validation
+class FeedbackRequest(BaseModel):
     user_query: str
     problems: list[str]
     user_answers: list[str]
 
+class FeedbackResponse(BaseModel):
+    feedback: List[str]
+
 @app.post("/api/crawl/")
 async def crawl_documentation(input_data: UrlInput):
     print(f"Received url {input_data.url}")
@@ -37,17 +43,28 @@ async def generate_problems(query: UserQuery):
     problems = ProblemGenerationPipeline().generate_problems(query.user_query)
     return {"Problems": problems}
 
-@app.post("/api/feedback/")
-async def submit_feedback(feedback: FeedbackInput):
-    # check if problems len is equal to user_answers len
-    if len(feedback.problems) != len(feedback.user_answers):
+@app.post("/api/feedback", response_model=FeedbackResponse)
+async def get_feedback(request: FeedbackRequest):
+    if len(request.problems) != len(request.user_answers):
         raise HTTPException(status_code=400, detail="Problems and user answers must have the same length")
-    
-    for problem, user_answer in zip(feedback.problems, feedback.user_answers):
-        print(f"Problem: {problem}")
-        print(f"User answer: {user_answer}")
-    
-    return {"status": "success"}
+    try:
+        grader = ProblemGradingPipeline()
+        
+        grading_tasks = [
+            grader.grade(
+                query=request.user_query,
+                problem=problem,
+                answer=user_answer,
+            )
+            for problem, user_answer in zip(request.problems, request.user_answers)
+        ]
+        
+        feedback_list = await asyncio.gather(*grading_tasks)
+        
+        return FeedbackResponse(feedback=feedback_list)
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
 
 # Serve static files
 app.mount("/static", StaticFiles(directory="/app/static/static"), name="static")

backend/app/problem_generator.py

@@ -36,7 +36,6 @@ class ProblemGenerationPipeline:
         self.llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.7)
         self.retriever = get_vector_db().as_retriever(search_kwargs={"k": 2})
         
-        # Build the RAG chain
         self.rag_chain = (
             {"context": self.retriever, "query": RunnablePassthrough()}
             | self.chat_prompt

backend/app/problem_grader.py

@@ -40,7 +40,6 @@ class ProblemGradingPipeline:
         self.llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0.3)
         self.retriever = get_vector_db().as_retriever(search_kwargs={"k": 2})
         
-        # Build the RAG chain
         self.rag_chain = (
             {
                 "context": self.retriever, 
@@ -53,9 +52,9 @@ class ProblemGradingPipeline:
             | StrOutputParser()
         )
 
-    def grade(self, query: str, problem: str, answer: str) -> str:
+    async def grade(self, query: str, problem: str, answer: str) -> str:
         """
-        Grade a student's answer to a problem using RAG for context-aware evaluation.
+        Asynchronously grade a student's answer to a problem using RAG for context-aware evaluation.
         
         Args:
             query (str): The topic/context to use for grading
@@ -65,7 +64,7 @@ class ProblemGradingPipeline:
         Returns:
             str: Grading response indicating if the answer is correct and providing feedback
         """
-        return self.rag_chain.invoke({
+        return await self.rag_chain.ainvoke({
             "query": query,
             "problem": problem,
             "answer": answer

backend/tests/test_api.py

@@ -1,5 +1,6 @@
 from fastapi.testclient import TestClient
 from backend.app.main import app
+import pytest
 
 client = TestClient(app)
 
@@ -19,4 +20,48 @@ def test_problems_endpoint():
     assert response.status_code == 200
     assert "Problems" in response.json()
     assert len(response.json()["Problems"]) == 5 
+
+def test_feedback_validation_error():
+    """Test that mismatched problems and answers lengths return 400"""
+    response = client.post(
+        "/api/feedback",
+        json={
+            "user_query": "Python lists",
+            "problems": ["What is a list?", "How do you append?"],
+            "user_answers": ["A sequence",]  # Only one answer
+        }
+    )
+    
+    assert response.status_code == 400
+    assert "same length" in response.json()["detail"]
+
+@pytest.mark.asyncio
+async def test_successful_feedback():
+    """Test successful grading of multiple problems"""
+    response = client.post(
+        "/api/feedback",
+        json={
+            "user_query": "RAG",
+            "problems": [
+                "What are the two main components of a typical RAG application?",
+                "What is the purpose of the indexing component in a RAG application?"
+            ],
+            "user_answers": [
+                "A list is a mutable sequence type that can store multiple items in Python",
+                "You use the append() method to add an element to the end of a list"
+            ]
+        }
+    )
+    
+    assert response.status_code == 200
+    result = response.json()
+    assert "feedback" in result
+    assert len(result["feedback"]) == 2
+    
+    # Check that responses start with either "Correct" or "Incorrect"
+    for feedback in result["feedback"]:
+        assert feedback.startswith(("Correct", "Incorrect"))
+        # Check that there's an explanation after the classification
+        assert len(feedback.split(". ")) >= 2
+