Refactor response handling in app.py and various tool modules to improve JSON parsing and error management. Introduce utility functions for cleaning and extracting JSON from text, ensuring consistent data handling across quiz, lesson, learning path, and interaction tools. Enhance robustness by accommodating multiple response formats, including strings and dictionaries, to streamline educational interactions.

app.py

@@ -420,7 +420,6 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                         async with ClientSession(sse, write) as session:
                             await session.initialize()
                             response = await session.call_tool("generate_quiz_tool", {"concept": concept.strip(), "difficulty": difficulty_str})
-                            # --- PATCH: Parse quiz JSON for pretty display ---
                             if hasattr(response, 'content') and isinstance(response.content, list):
                                 for item in response.content:
                                     if hasattr(item, 'text') and item.text:
@@ -468,7 +467,22 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                     async with ClientSession(sse, write) as session:
                         await session.initialize()
                         response = await session.call_tool("generate_lesson_tool", {"topic": topic, "grade_level": grade, "duration_minutes": duration})
-                        return response
+                        if hasattr(response, 'content') and isinstance(response.content, list):
+                            for item in response.content:
+                                if hasattr(item, 'text') and item.text:
+                                    try:
+                                        lesson_data = json.loads(item.text)
+                                        return lesson_data
+                                    except Exception:
+                                        return {"raw": item.text}
+                        if isinstance(response, dict):
+                            return response
+                        if isinstance(response, str):
+                            try:
+                                return json.loads(response)
+                            except Exception:
+                                return {"raw": response}
+                        return {"raw": str(response)}
                 
             gen_lesson_btn.click(
                 fn=generate_lesson_async,
@@ -495,7 +509,22 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                                 "concept_ids": [c.strip() for c in concept_ids.split(",") if c.strip()],
                                 "student_level": student_level
                             })
-                            return result
+                            if hasattr(result, 'content') and isinstance(result.content, list):
+                                for item in result.content:
+                                    if hasattr(item, 'text') and item.text:
+                                        try:
+                                            lp_data = json.loads(item.text)
+                                            return lp_data
+                                        except Exception:
+                                            return {"raw": item.text}
+                            if isinstance(result, dict):
+                                return result
+                            if isinstance(result, str):
+                                try:
+                                    return json.loads(result)
+                                except Exception:
+                                    return {"raw": result}
+                            return {"raw": str(result)}
                 except Exception as e:
                     return {"error": str(e)}
             lp_btn.click(
@@ -520,7 +549,22 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                     async with ClientSession(sse, write) as session:
                         await session.initialize()
                         response = await session.call_tool("text_interaction", {"query": text, "student_id": student_id})
-                        return response
+                        if hasattr(response, 'content') and isinstance(response.content, list):
+                            for item in response.content:
+                                if hasattr(item, 'text') and item.text:
+                                    try:
+                                        data = json.loads(item.text)
+                                        return data
+                                    except Exception:
+                                        return {"raw": item.text}
+                        if isinstance(response, dict):
+                            return response
+                        if isinstance(response, str):
+                            try:
+                                return json.loads(response)
+                            except Exception:
+                                return {"raw": response}
+                        return {"raw": str(response)}
                 
             text_btn.click(
                 fn=text_interaction_async,
@@ -558,23 +602,32 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                         file_path = file
                     if not file_path or not os.path.exists(file_path):
                         return {"error": "File not found", "success": False}
-                    
-                    # Upload file to storage API
                     upload_result = await upload_file_to_storage(file_path)
                     if not upload_result.get("success"):
                         return upload_result
-                    
-                    # Get the storage URL from the upload response
                     storage_url = upload_result.get("storage_url")
                     if not storage_url:
                         return {"error": "No storage URL returned from upload", "success": False}
-                    
-                    # Use the storage URL for OCR processing
                     async with sse_client(SERVER_URL) as (sse, write):
                         async with ClientSession(sse, write) as session:
                             await session.initialize()
                             response = await session.call_tool("mistral_document_ocr", {"document_url": storage_url})
-                            return response
+                            if hasattr(response, 'content') and isinstance(response.content, list):
+                                for item in response.content:
+                                    if hasattr(item, 'text') and item.text:
+                                        try:
+                                            data = json.loads(item.text)
+                                            return data
+                                        except Exception:
+                                            return {"raw": item.text}
+                            if isinstance(response, dict):
+                                return response
+                            if isinstance(response, str):
+                                try:
+                                    return json.loads(response)
+                                except Exception:
+                                    return {"raw": response}
+                            return {"raw": str(response)}
                 except Exception as e:
                     return {"error": f"Error processing document: {str(e)}", "success": False}
             doc_ocr_btn.click(
@@ -609,7 +662,22 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                     async with ClientSession(sse, write) as session:
                         await session.initialize()
                         response = await session.call_tool("check_submission_originality", {"submission": submission, "reference_sources": [reference] if isinstance(reference, str) else reference})
-                        return response
+                        if hasattr(response, 'content') and isinstance(response.content, list):
+                            for item in response.content:
+                                if hasattr(item, 'text') and item.text:
+                                    try:
+                                        data = json.loads(item.text)
+                                        return data
+                                    except Exception:
+                                        return {"raw": item.text}
+                        if isinstance(response, dict):
+                            return response
+                        if isinstance(response, str):
+                            try:
+                                return json.loads(response)
+                            except Exception:
+                                return {"raw": response}
+                        return {"raw": str(response)}
                 
             plagiarism_btn.click(
                 fn=check_plagiarism_async,

mcp_server/tools/concept_tools.py

@@ -8,20 +8,13 @@ import sys
 import os
 from pathlib import Path
 import json
+import re
 
 # Add the parent directory to the Python path
 current_dir = Path(__file__).parent
 parent_dir = current_dir.parent.parent
 sys.path.insert(0, str(parent_dir))
 
-import sys
-import os
-from pathlib import Path
-
-# Add the parent directory to the Python path
-current_dir = Path(__file__).parent
-parent_dir = current_dir.parent
-sys.path.insert(0, str(parent_dir))
 
 # Import from local resources
 from resources.concept_graph import get_concept, get_all_concepts
@@ -32,6 +25,20 @@ from mcp_server.model.gemini_flash import GeminiFlash
 
 MODEL = GeminiFlash()
 
+def clean_json_trailing_commas(json_text: str) -> str:
+    return re.sub(r',([ \t\r\n]*[}}\]])', r'\1', json_text)
+
+def extract_json_from_text(text: str):
+    if not text or not isinstance(text, str):
+        return None
+    # Remove code fences
+    text = re.sub(r'^\s*```(?:json)?\s*', '', text, flags=re.IGNORECASE)
+    text = re.sub(r'\s*```\s*$', '', text, flags=re.IGNORECASE)
+    text = text.strip()
+    # Remove trailing commas
+    cleaned = clean_json_trailing_commas(text)
+    return json.loads(cleaned)
+
 @mcp.tool()
 async def get_concept_tool(concept_id: str = None) -> dict:
     """
@@ -46,7 +53,7 @@ async def get_concept_tool(concept_id: str = None) -> dict:
     )
     llm_response = await MODEL.generate_text(prompt)
     try:
-        data = json.loads(llm_response)
+        data = extract_json_from_text(llm_response)
     except Exception:
         data = {"llm_raw": llm_response, "error": "Failed to parse LLM output as JSON"}
     return data
@@ -63,7 +70,7 @@ async def assess_skill_tool(student_id: str, concept_id: str) -> dict:
     )
     llm_response = await MODEL.generate_text(prompt)
     try:
-        data = json.loads(llm_response)
+        data = extract_json_from_text(llm_response)
     except Exception:
         data = {"llm_raw": llm_response, "error": "Failed to parse LLM output as JSON"}
     return data

mcp_server/tools/interaction_tools.py

@@ -14,6 +14,20 @@ def calculate_similarity(text1: str, text2: str) -> float:
     """Calculate the similarity ratio between two texts."""
     return 0.0  # No longer used, LLM-driven
 
+def clean_json_trailing_commas(json_text: str) -> str:
+    return re.sub(r',([ \t\r\n]*[}}\]])', r'\1', json_text)
+
+def extract_json_from_text(text: str):
+    if not text or not isinstance(text, str):
+        return None
+    # Remove code fences
+    text = re.sub(r'^\s*```(?:json)?\s*', '', text, flags=re.IGNORECASE)
+    text = re.sub(r'\s*```\s*$', '', text, flags=re.IGNORECASE)
+    text = text.strip()
+    # Remove trailing commas
+    cleaned = clean_json_trailing_commas(text)
+    return json.loads(cleaned)
+
 @mcp.tool()
 async def text_interaction(query: str, student_id: str) -> dict:
     """
@@ -26,7 +40,7 @@ async def text_interaction(query: str, student_id: str) -> dict:
     )
     llm_response = await MODEL.generate_text(prompt)
     try:
-        data = json.loads(llm_response)
+        data = extract_json_from_text(llm_response)
     except Exception:
         data = {"llm_raw": llm_response, "error": "Failed to parse LLM output as JSON"}
     return data

mcp_server/tools/learning_path_tools.py

@@ -8,21 +8,13 @@ import sys
 import os
 from pathlib import Path
 import json
+import re
 
 # Add the parent directory to the Python path
 current_dir = Path(__file__).parent
 parent_dir = current_dir.parent.parent
 sys.path.insert(0, str(parent_dir))
 
-import sys
-import os
-from pathlib import Path
-
-# Add the parent directory to the Python path
-current_dir = Path(__file__).parent
-parent_dir = current_dir.parent
-sys.path.insert(0, str(parent_dir))
-
 # Import from local resources
 from resources.concept_graph import CONCEPT_GRAPH
 
@@ -146,6 +138,20 @@ def generate_learning_path(concept_ids: List[str], student_level: str = "beginne
         "generated_at": datetime.utcnow().isoformat() + "Z"
     }
 
+def clean_json_trailing_commas(json_text: str) -> str:
+    return re.sub(r',([ \t\r\n]*[}}\]])', r'\1', json_text)
+
+def extract_json_from_text(text: str):
+    if not text or not isinstance(text, str):
+        return None
+    # Remove code fences
+    text = re.sub(r'^\s*```(?:json)?\s*', '', text, flags=re.IGNORECASE)
+    text = re.sub(r'\s*```\s*$', '', text, flags=re.IGNORECASE)
+    text = text.strip()
+    # Remove trailing commas
+    cleaned = clean_json_trailing_commas(text)
+    return json.loads(cleaned)
+
 @mcp.tool()
 async def get_learning_path(student_id: str, concept_ids: list, student_level: str = "beginner") -> dict:
     """
@@ -158,7 +164,7 @@ async def get_learning_path(student_id: str, concept_ids: list, student_level: s
     )
     llm_response = await MODEL.generate_text(prompt)
     try:
-        data = json.loads(llm_response)
+        data = extract_json_from_text(llm_response)
     except Exception:
         data = {"llm_raw": llm_response, "error": "Failed to parse LLM output as JSON"}
     return data

mcp_server/tools/lesson_tools.py

@@ -8,6 +8,22 @@ import json
 
 MODEL = GeminiFlash()
 
+def clean_json_trailing_commas(json_text: str) -> str:
+    import re
+    return re.sub(r',([ \t\r\n]*[}}\]])', r'\1', json_text)
+
+def extract_json_from_text(text: str):
+    import re, json
+    if not text or not isinstance(text, str):
+        return None
+    # Remove code fences
+    text = re.sub(r'^\s*```(?:json)?\s*', '', text, flags=re.IGNORECASE)
+    text = re.sub(r'\s*```\s*$', '', text, flags=re.IGNORECASE)
+    text = text.strip()
+    # Remove trailing commas
+    cleaned = clean_json_trailing_commas(text)
+    return json.loads(cleaned)
+
 @mcp.tool()
 async def generate_lesson_tool(topic: str, grade_level: int, duration_minutes: int) -> dict:
     """
@@ -20,7 +36,7 @@ async def generate_lesson_tool(topic: str, grade_level: int, duration_minutes: i
     )
     llm_response = await MODEL.generate_text(prompt)
     try:
-        data = json.loads(llm_response)
+        data = extract_json_from_text(llm_response)
     except Exception:
         data = {"llm_raw": llm_response, "error": "Failed to parse LLM output as JSON"}
     return data

mcp_server/tools/ocr_tools.py

@@ -139,4 +139,20 @@ Document:
             "success": False,
             "error": f"Error processing document with Mistral OCR: {str(e)}",
             "document_url": document_url
-        }
+        }
+
+def clean_json_trailing_commas(json_text: str) -> str:
+    import re
+    return re.sub(r',([ \t\r\n]*[}}\]])', r'\1', json_text)
+
+def extract_json_from_text(text: str):
+    import re, json
+    if not text or not isinstance(text, str):
+        return None
+    # Remove code fences
+    text = re.sub(r'^\s*```(?:json)?\s*', '', text, flags=re.IGNORECASE)
+    text = re.sub(r'\s*```\s*$', '', text, flags=re.IGNORECASE)
+    text = text.strip()
+    # Remove trailing commas
+    cleaned = clean_json_trailing_commas(text)
+    return json.loads(cleaned)