Refactor TutorX MCP server to integrate Mistral OCR for document processing, update concept graph tools for LLM-driven responses, and enhance learning path generation with Gemini. Transitioned various tools to utilize LLM for improved educational interactions and streamlined API responses.

.vscode/PythonImportHelper-v2-Completion.json

@@ -0,0 +1,2111 @@
+[
+    {
+        "label": "runpy",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "runpy",
+        "description": "runpy",
+        "detail": "runpy",
+        "documentation": {}
+    },
+    {
+        "label": "annotations",
+        "importPath": "__future__",
+        "description": "__future__",
+        "isExtraImport": true,
+        "detail": "__future__",
+        "documentation": {}
+    },
+    {
+        "label": "os",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "os",
+        "description": "os",
+        "detail": "os",
+        "documentation": {}
+    },
+    {
+        "label": "site",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "site",
+        "description": "site",
+        "detail": "site",
+        "documentation": {}
+    },
+    {
+        "label": "sys",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "sys",
+        "description": "sys",
+        "detail": "sys",
+        "documentation": {}
+    },
+    {
+        "label": "zip",
+        "importPath": "builtins",
+        "description": "builtins",
+        "isExtraImport": true,
+        "detail": "builtins",
+        "documentation": {}
+    },
+    {
+        "label": "str",
+        "importPath": "builtins",
+        "description": "builtins",
+        "isExtraImport": true,
+        "detail": "builtins",
+        "documentation": {}
+    },
+    {
+        "label": "os.path",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "os.path",
+        "description": "os.path",
+        "detail": "os.path",
+        "documentation": {}
+    },
+    {
+        "label": "cElementTree",
+        "importPath": "xml.etree",
+        "description": "xml.etree",
+        "isExtraImport": true,
+        "detail": "xml.etree",
+        "documentation": {}
+    },
+    {
+        "label": "pyxnat",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "pyxnat",
+        "description": "pyxnat",
+        "detail": "pyxnat",
+        "documentation": {}
+    },
+    {
+        "label": "google.generativeai",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "google.generativeai",
+        "description": "google.generativeai",
+        "detail": "google.generativeai",
+        "documentation": {}
+    },
+    {
+        "label": "Dict",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Any",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Optional",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "List",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Literal",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Union",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "TypeVar",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Callable",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Dict",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Any",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Dict",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Any",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Dict",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Any",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Optional",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Dict",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Any",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Optional",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Dict",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Any",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "List",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Optional",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Dict",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Any",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "List",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Optional",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Dict",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Any",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "List",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Dict",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Any",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Optional",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Dict",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Any",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "List",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "Optional",
+        "importPath": "typing",
+        "description": "typing",
+        "isExtraImport": true,
+        "detail": "typing",
+        "documentation": {}
+    },
+    {
+        "label": "wraps",
+        "importPath": "functools",
+        "description": "functools",
+        "isExtraImport": true,
+        "detail": "functools",
+        "documentation": {}
+    },
+    {
+        "label": "logging",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "logging",
+        "description": "logging",
+        "detail": "logging",
+        "documentation": {}
+    },
+    {
+        "label": "Path",
+        "importPath": "pathlib",
+        "description": "pathlib",
+        "isExtraImport": true,
+        "detail": "pathlib",
+        "documentation": {}
+    },
+    {
+        "label": "Path",
+        "importPath": "pathlib",
+        "description": "pathlib",
+        "isExtraImport": true,
+        "detail": "pathlib",
+        "documentation": {}
+    },
+    {
+        "label": "Path",
+        "importPath": "pathlib",
+        "description": "pathlib",
+        "isExtraImport": true,
+        "detail": "pathlib",
+        "documentation": {}
+    },
+    {
+        "label": "Path",
+        "importPath": "pathlib",
+        "description": "pathlib",
+        "isExtraImport": true,
+        "detail": "pathlib",
+        "documentation": {}
+    },
+    {
+        "label": "Path",
+        "importPath": "pathlib",
+        "description": "pathlib",
+        "isExtraImport": true,
+        "detail": "pathlib",
+        "documentation": {}
+    },
+    {
+        "label": "Path",
+        "importPath": "pathlib",
+        "description": "pathlib",
+        "isExtraImport": true,
+        "detail": "pathlib",
+        "documentation": {}
+    },
+    {
+        "label": "Path",
+        "importPath": "pathlib",
+        "description": "pathlib",
+        "isExtraImport": true,
+        "detail": "pathlib",
+        "documentation": {}
+    },
+    {
+        "label": "Path",
+        "importPath": "pathlib",
+        "description": "pathlib",
+        "isExtraImport": true,
+        "detail": "pathlib",
+        "documentation": {}
+    },
+    {
+        "label": "Path",
+        "importPath": "pathlib",
+        "description": "pathlib",
+        "isExtraImport": true,
+        "detail": "pathlib",
+        "documentation": {}
+    },
+    {
+        "label": "json",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "json",
+        "description": "json",
+        "detail": "json",
+        "documentation": {}
+    },
+    {
+        "label": "concept_graph",
+        "importPath": "resources",
+        "description": "resources",
+        "isExtraImport": true,
+        "detail": "resources",
+        "documentation": {}
+    },
+    {
+        "label": "concept_graph",
+        "importPath": "resources",
+        "description": "resources",
+        "isExtraImport": true,
+        "detail": "resources",
+        "documentation": {}
+    },
+    {
+        "label": "curriculum_standards",
+        "importPath": "resources",
+        "description": "resources",
+        "isExtraImport": true,
+        "detail": "resources",
+        "documentation": {}
+    },
+    {
+        "label": "mcp",
+        "importPath": "mcp_server.mcp_instance",
+        "description": "mcp_server.mcp_instance",
+        "isExtraImport": true,
+        "detail": "mcp_server.mcp_instance",
+        "documentation": {}
+    },
+    {
+        "label": "mcp",
+        "importPath": "mcp_server.mcp_instance",
+        "description": "mcp_server.mcp_instance",
+        "isExtraImport": true,
+        "detail": "mcp_server.mcp_instance",
+        "documentation": {}
+    },
+    {
+        "label": "mcp",
+        "importPath": "mcp_server.mcp_instance",
+        "description": "mcp_server.mcp_instance",
+        "isExtraImport": true,
+        "detail": "mcp_server.mcp_instance",
+        "documentation": {}
+    },
+    {
+        "label": "mcp",
+        "importPath": "mcp_server.mcp_instance",
+        "description": "mcp_server.mcp_instance",
+        "isExtraImport": true,
+        "detail": "mcp_server.mcp_instance",
+        "documentation": {}
+    },
+    {
+        "label": "mcp",
+        "importPath": "mcp_server.mcp_instance",
+        "description": "mcp_server.mcp_instance",
+        "isExtraImport": true,
+        "detail": "mcp_server.mcp_instance",
+        "documentation": {}
+    },
+    {
+        "label": "mcp",
+        "importPath": "mcp_server.mcp_instance",
+        "description": "mcp_server.mcp_instance",
+        "isExtraImport": true,
+        "detail": "mcp_server.mcp_instance",
+        "documentation": {}
+    },
+    {
+        "label": "mcp",
+        "importPath": "mcp_server.mcp_instance",
+        "description": "mcp_server.mcp_instance",
+        "isExtraImport": true,
+        "detail": "mcp_server.mcp_instance",
+        "documentation": {}
+    },
+    {
+        "label": "mcp",
+        "importPath": "mcp_server.mcp_instance",
+        "description": "mcp_server.mcp_instance",
+        "isExtraImport": true,
+        "detail": "mcp_server.mcp_instance",
+        "documentation": {}
+    },
+    {
+        "label": "GeminiFlash",
+        "importPath": "mcp_server.model.gemini_flash",
+        "description": "mcp_server.model.gemini_flash",
+        "isExtraImport": true,
+        "detail": "mcp_server.model.gemini_flash",
+        "documentation": {}
+    },
+    {
+        "label": "GeminiFlash",
+        "importPath": "mcp_server.model.gemini_flash",
+        "description": "mcp_server.model.gemini_flash",
+        "isExtraImport": true,
+        "detail": "mcp_server.model.gemini_flash",
+        "documentation": {}
+    },
+    {
+        "label": "GeminiFlash",
+        "importPath": "mcp_server.model.gemini_flash",
+        "description": "mcp_server.model.gemini_flash",
+        "isExtraImport": true,
+        "detail": "mcp_server.model.gemini_flash",
+        "documentation": {}
+    },
+    {
+        "label": "GeminiFlash",
+        "importPath": "mcp_server.model.gemini_flash",
+        "description": "mcp_server.model.gemini_flash",
+        "isExtraImport": true,
+        "detail": "mcp_server.model.gemini_flash",
+        "documentation": {}
+    },
+    {
+        "label": "GeminiFlash",
+        "importPath": "mcp_server.model.gemini_flash",
+        "description": "mcp_server.model.gemini_flash",
+        "isExtraImport": true,
+        "detail": "mcp_server.model.gemini_flash",
+        "documentation": {}
+    },
+    {
+        "label": "GeminiFlash",
+        "importPath": "mcp_server.model.gemini_flash",
+        "description": "mcp_server.model.gemini_flash",
+        "isExtraImport": true,
+        "detail": "mcp_server.model.gemini_flash",
+        "documentation": {}
+    },
+    {
+        "label": "random",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "random",
+        "description": "random",
+        "detail": "random",
+        "documentation": {}
+    },
+    {
+        "label": "datetime",
+        "importPath": "datetime",
+        "description": "datetime",
+        "isExtraImport": true,
+        "detail": "datetime",
+        "documentation": {}
+    },
+    {
+        "label": "timezone",
+        "importPath": "datetime",
+        "description": "datetime",
+        "isExtraImport": true,
+        "detail": "datetime",
+        "documentation": {}
+    },
+    {
+        "label": "datetime",
+        "importPath": "datetime",
+        "description": "datetime",
+        "isExtraImport": true,
+        "detail": "datetime",
+        "documentation": {}
+    },
+    {
+        "label": "timedelta",
+        "importPath": "datetime",
+        "description": "datetime",
+        "isExtraImport": true,
+        "detail": "datetime",
+        "documentation": {}
+    },
+    {
+        "label": "datetime",
+        "importPath": "datetime",
+        "description": "datetime",
+        "isExtraImport": true,
+        "detail": "datetime",
+        "documentation": {}
+    },
+    {
+        "label": "datetime",
+        "importPath": "datetime",
+        "description": "datetime",
+        "isExtraImport": true,
+        "detail": "datetime",
+        "documentation": {}
+    },
+    {
+        "label": "get_concept",
+        "importPath": "resources.concept_graph",
+        "description": "resources.concept_graph",
+        "isExtraImport": true,
+        "detail": "resources.concept_graph",
+        "documentation": {}
+    },
+    {
+        "label": "get_all_concepts",
+        "importPath": "resources.concept_graph",
+        "description": "resources.concept_graph",
+        "isExtraImport": true,
+        "detail": "resources.concept_graph",
+        "documentation": {}
+    },
+    {
+        "label": "CONCEPT_GRAPH",
+        "importPath": "resources.concept_graph",
+        "description": "resources.concept_graph",
+        "isExtraImport": true,
+        "detail": "resources.concept_graph",
+        "documentation": {}
+    },
+    {
+        "label": "re",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "re",
+        "description": "re",
+        "detail": "re",
+        "documentation": {}
+    },
+    {
+        "label": "SequenceMatcher",
+        "importPath": "difflib",
+        "description": "difflib",
+        "isExtraImport": true,
+        "detail": "difflib",
+        "documentation": {}
+    },
+    {
+        "label": "base64",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "base64",
+        "description": "base64",
+        "detail": "base64",
+        "documentation": {}
+    },
+    {
+        "label": "io",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "io",
+        "description": "io",
+        "detail": "io",
+        "documentation": {}
+    },
+    {
+        "label": "asyncio",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "asyncio",
+        "description": "asyncio",
+        "detail": "asyncio",
+        "documentation": {}
+    },
+    {
+        "label": "aiohttp",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "aiohttp",
+        "description": "aiohttp",
+        "detail": "aiohttp",
+        "documentation": {}
+    },
+    {
+        "label": "GeminiFlash",
+        "importPath": "model",
+        "description": "model",
+        "isExtraImport": true,
+        "detail": "model",
+        "documentation": {}
+    },
+    {
+        "label": "uuid",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "uuid",
+        "description": "uuid",
+        "detail": "uuid",
+        "documentation": {}
+    },
+    {
+        "label": "BlobServiceClient",
+        "importPath": "azure.storage.blob",
+        "description": "azure.storage.blob",
+        "isExtraImport": true,
+        "detail": "azure.storage.blob",
+        "documentation": {}
+    },
+    {
+        "label": "ContentSettings",
+        "importPath": "azure.storage.blob",
+        "description": "azure.storage.blob",
+        "isExtraImport": true,
+        "detail": "azure.storage.blob",
+        "documentation": {}
+    },
+    {
+        "label": "BlobServiceClient",
+        "importPath": "azure.storage.blob",
+        "description": "azure.storage.blob",
+        "isExtraImport": true,
+        "detail": "azure.storage.blob",
+        "documentation": {}
+    },
+    {
+        "label": "ContentSettings",
+        "importPath": "azure.storage.blob",
+        "description": "azure.storage.blob",
+        "isExtraImport": true,
+        "detail": "azure.storage.blob",
+        "documentation": {}
+    },
+    {
+        "label": "load_dotenv",
+        "importPath": "dotenv",
+        "description": "dotenv",
+        "isExtraImport": true,
+        "detail": "dotenv",
+        "documentation": {}
+    },
+    {
+        "label": "load_dotenv",
+        "importPath": "dotenv",
+        "description": "dotenv",
+        "isExtraImport": true,
+        "detail": "dotenv",
+        "documentation": {}
+    },
+    {
+        "label": "FastMCP",
+        "importPath": "mcp.server.fastmcp",
+        "description": "mcp.server.fastmcp",
+        "isExtraImport": true,
+        "detail": "mcp.server.fastmcp",
+        "documentation": {}
+    },
+    {
+        "label": "FastMCP",
+        "importPath": "mcp.server.fastmcp",
+        "description": "mcp.server.fastmcp",
+        "isExtraImport": true,
+        "detail": "mcp.server.fastmcp",
+        "documentation": {}
+    },
+    {
+        "label": "uvicorn",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "uvicorn",
+        "description": "uvicorn",
+        "detail": "uvicorn",
+        "documentation": {}
+    },
+    {
+        "label": "FastAPI",
+        "importPath": "fastapi",
+        "description": "fastapi",
+        "isExtraImport": true,
+        "detail": "fastapi",
+        "documentation": {}
+    },
+    {
+        "label": "HTTPException",
+        "importPath": "fastapi",
+        "description": "fastapi",
+        "isExtraImport": true,
+        "detail": "fastapi",
+        "documentation": {}
+    },
+    {
+        "label": "UploadFile",
+        "importPath": "fastapi",
+        "description": "fastapi",
+        "isExtraImport": true,
+        "detail": "fastapi",
+        "documentation": {}
+    },
+    {
+        "label": "File",
+        "importPath": "fastapi",
+        "description": "fastapi",
+        "isExtraImport": true,
+        "detail": "fastapi",
+        "documentation": {}
+    },
+    {
+        "label": "Form",
+        "importPath": "fastapi",
+        "description": "fastapi",
+        "isExtraImport": true,
+        "detail": "fastapi",
+        "documentation": {}
+    },
+    {
+        "label": "CORSMiddleware",
+        "importPath": "fastapi.middleware.cors",
+        "description": "fastapi.middleware.cors",
+        "isExtraImport": true,
+        "detail": "fastapi.middleware.cors",
+        "documentation": {}
+    },
+    {
+        "label": "concept_tools",
+        "importPath": "tools",
+        "description": "tools",
+        "isExtraImport": true,
+        "detail": "tools",
+        "documentation": {}
+    },
+    {
+        "label": "lesson_tools",
+        "importPath": "tools",
+        "description": "tools",
+        "isExtraImport": true,
+        "detail": "tools",
+        "documentation": {}
+    },
+    {
+        "label": "quiz_tools",
+        "importPath": "tools",
+        "description": "tools",
+        "isExtraImport": true,
+        "detail": "tools",
+        "documentation": {}
+    },
+    {
+        "label": "interaction_tools",
+        "importPath": "tools",
+        "description": "tools",
+        "isExtraImport": true,
+        "detail": "tools",
+        "documentation": {}
+    },
+    {
+        "label": "ocr_tools",
+        "importPath": "tools",
+        "description": "tools",
+        "isExtraImport": true,
+        "detail": "tools",
+        "documentation": {}
+    },
+    {
+        "label": "learning_path_tools",
+        "importPath": "tools",
+        "description": "tools",
+        "isExtraImport": true,
+        "detail": "tools",
+        "documentation": {}
+    },
+    {
+        "label": "concept_tools",
+        "importPath": "mcp_server.tools",
+        "description": "mcp_server.tools",
+        "isExtraImport": true,
+        "detail": "mcp_server.tools",
+        "documentation": {}
+    },
+    {
+        "label": "lesson_tools",
+        "importPath": "mcp_server.tools",
+        "description": "mcp_server.tools",
+        "isExtraImport": true,
+        "detail": "mcp_server.tools",
+        "documentation": {}
+    },
+    {
+        "label": "quiz_tools",
+        "importPath": "mcp_server.tools",
+        "description": "mcp_server.tools",
+        "isExtraImport": true,
+        "detail": "mcp_server.tools",
+        "documentation": {}
+    },
+    {
+        "label": "interaction_tools",
+        "importPath": "mcp_server.tools",
+        "description": "mcp_server.tools",
+        "isExtraImport": true,
+        "detail": "mcp_server.tools",
+        "documentation": {}
+    },
+    {
+        "label": "ocr_tools",
+        "importPath": "mcp_server.tools",
+        "description": "mcp_server.tools",
+        "isExtraImport": true,
+        "detail": "mcp_server.tools",
+        "documentation": {}
+    },
+    {
+        "label": "learning_path_tools",
+        "importPath": "mcp_server.tools",
+        "description": "mcp_server.tools",
+        "isExtraImport": true,
+        "detail": "mcp_server.tools",
+        "documentation": {}
+    },
+    {
+        "label": "concept_graph_tools",
+        "importPath": "mcp_server.tools",
+        "description": "mcp_server.tools",
+        "isExtraImport": true,
+        "detail": "mcp_server.tools",
+        "documentation": {}
+    },
+    {
+        "label": "assess_skill_tool",
+        "importPath": "tools.concept_tools",
+        "description": "tools.concept_tools",
+        "isExtraImport": true,
+        "detail": "tools.concept_tools",
+        "documentation": {}
+    },
+    {
+        "label": "generate_lesson_tool",
+        "importPath": "tools.lesson_tools",
+        "description": "tools.lesson_tools",
+        "isExtraImport": true,
+        "detail": "tools.lesson_tools",
+        "documentation": {}
+    },
+    {
+        "label": "generate_quiz_tool",
+        "importPath": "tools.quiz_tools",
+        "description": "tools.quiz_tools",
+        "isExtraImport": true,
+        "detail": "tools.quiz_tools",
+        "documentation": {}
+    },
+    {
+        "label": "setup",
+        "importPath": "setuptools",
+        "description": "setuptools",
+        "isExtraImport": true,
+        "detail": "setuptools",
+        "documentation": {}
+    },
+    {
+        "label": "find_packages",
+        "importPath": "setuptools",
+        "description": "setuptools",
+        "isExtraImport": true,
+        "detail": "setuptools",
+        "documentation": {}
+    },
+    {
+        "label": "unittest",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "unittest",
+        "description": "unittest",
+        "detail": "unittest",
+        "documentation": {}
+    },
+    {
+        "label": "patch",
+        "importPath": "unittest.mock",
+        "description": "unittest.mock",
+        "isExtraImport": true,
+        "detail": "unittest.mock",
+        "documentation": {}
+    },
+    {
+        "label": "MagicMock",
+        "importPath": "unittest.mock",
+        "description": "unittest.mock",
+        "isExtraImport": true,
+        "detail": "unittest.mock",
+        "documentation": {}
+    },
+    {
+        "label": "patch",
+        "importPath": "unittest.mock",
+        "description": "unittest.mock",
+        "isExtraImport": true,
+        "detail": "unittest.mock",
+        "documentation": {}
+    },
+    {
+        "label": "MagicMock",
+        "importPath": "unittest.mock",
+        "description": "unittest.mock",
+        "isExtraImport": true,
+        "detail": "unittest.mock",
+        "documentation": {}
+    },
+    {
+        "label": "patch",
+        "importPath": "unittest.mock",
+        "description": "unittest.mock",
+        "isExtraImport": true,
+        "detail": "unittest.mock",
+        "documentation": {}
+    },
+    {
+        "label": "MagicMock",
+        "importPath": "unittest.mock",
+        "description": "unittest.mock",
+        "isExtraImport": true,
+        "detail": "unittest.mock",
+        "documentation": {}
+    },
+    {
+        "label": "requests",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "requests",
+        "description": "requests",
+        "detail": "requests",
+        "documentation": {}
+    },
+    {
+        "label": "TutorXClient",
+        "importPath": "client",
+        "description": "client",
+        "isExtraImport": true,
+        "detail": "client",
+        "documentation": {}
+    },
+    {
+        "label": "assess_skill",
+        "importPath": "main",
+        "description": "main",
+        "isExtraImport": true,
+        "detail": "main",
+        "documentation": {}
+    },
+    {
+        "label": "generate_quiz",
+        "importPath": "main",
+        "description": "main",
+        "isExtraImport": true,
+        "detail": "main",
+        "documentation": {}
+    },
+    {
+        "label": "get_concept_graph",
+        "importPath": "main",
+        "description": "main",
+        "isExtraImport": true,
+        "detail": "main",
+        "documentation": {}
+    },
+    {
+        "label": "pytest",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "pytest",
+        "description": "pytest",
+        "detail": "pytest",
+        "documentation": {}
+    },
+    {
+        "label": "ClientSession",
+        "importPath": "mcp",
+        "description": "mcp",
+        "isExtraImport": true,
+        "detail": "mcp",
+        "documentation": {}
+    },
+    {
+        "label": "ClientSession",
+        "importPath": "mcp",
+        "description": "mcp",
+        "isExtraImport": true,
+        "detail": "mcp",
+        "documentation": {}
+    },
+    {
+        "label": "sse_client",
+        "importPath": "mcp.client.sse",
+        "description": "mcp.client.sse",
+        "isExtraImport": true,
+        "detail": "mcp.client.sse",
+        "documentation": {}
+    },
+    {
+        "label": "sse_client",
+        "importPath": "mcp.client.sse",
+        "description": "mcp.client.sse",
+        "isExtraImport": true,
+        "detail": "mcp.client.sse",
+        "documentation": {}
+    },
+    {
+        "label": "process_text_query",
+        "importPath": "utils.multimodal",
+        "description": "utils.multimodal",
+        "isExtraImport": true,
+        "detail": "utils.multimodal",
+        "documentation": {}
+    },
+    {
+        "label": "process_voice_input",
+        "importPath": "utils.multimodal",
+        "description": "utils.multimodal",
+        "isExtraImport": true,
+        "detail": "utils.multimodal",
+        "documentation": {}
+    },
+    {
+        "label": "process_handwriting",
+        "importPath": "utils.multimodal",
+        "description": "utils.multimodal",
+        "isExtraImport": true,
+        "detail": "utils.multimodal",
+        "documentation": {}
+    },
+    {
+        "label": "generate_question",
+        "importPath": "utils.assessment",
+        "description": "utils.assessment",
+        "isExtraImport": true,
+        "detail": "utils.assessment",
+        "documentation": {}
+    },
+    {
+        "label": "evaluate_student_answer",
+        "importPath": "utils.assessment",
+        "description": "utils.assessment",
+        "isExtraImport": true,
+        "detail": "utils.assessment",
+        "documentation": {}
+    },
+    {
+        "label": "gradio",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "gradio",
+        "description": "gradio",
+        "detail": "gradio",
+        "documentation": {}
+    },
+    {
+        "label": "numpy",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "numpy",
+        "description": "numpy",
+        "detail": "numpy",
+        "documentation": {}
+    },
+    {
+        "label": "sseclient",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "sseclient",
+        "description": "sseclient",
+        "detail": "sseclient",
+        "documentation": {}
+    },
+    {
+        "label": "upload_to_azure",
+        "importPath": "mcp_server.utils.azure_upload",
+        "description": "mcp_server.utils.azure_upload",
+        "isExtraImport": true,
+        "detail": "mcp_server.utils.azure_upload",
+        "documentation": {}
+    },
+    {
+        "label": "api_app",
+        "importPath": "mcp_server",
+        "description": "mcp_server",
+        "isExtraImport": true,
+        "detail": "mcp_server",
+        "documentation": {}
+    },
+    {
+        "label": "mcp",
+        "importPath": "mcp_server",
+        "description": "mcp_server",
+        "isExtraImport": true,
+        "detail": "mcp_server",
+        "documentation": {}
+    },
+    {
+        "label": "argparse",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "argparse",
+        "description": "argparse",
+        "detail": "argparse",
+        "documentation": {}
+    },
+    {
+        "label": "socket",
+        "kind": 6,
+        "isExtraImport": true,
+        "importPath": "socket",
+        "description": "socket",
+        "detail": "socket",
+        "documentation": {}
+    },
+    {
+        "label": "bin_dir",
+        "kind": 5,
+        "importPath": ".venv.Scripts.activate_this",
+        "description": ".venv.Scripts.activate_this",
+        "peekOfCode": "bin_dir = os.path.dirname(abs_file)\nbase = bin_dir[: -len(\"Scripts\") - 1]  # strip away the bin part from the __file__, plus the path separator\n# prepend bin to PATH (this file is inside the bin directory)\nos.environ[\"PATH\"] = os.pathsep.join([bin_dir, *os.environ.get(\"PATH\", \"\").split(os.pathsep)])\nos.environ[\"VIRTUAL_ENV\"] = base  # virtual env is right above bin directory\nos.environ[\"VIRTUAL_ENV_PROMPT\"] = \"tutorx-mcp\" or os.path.basename(base)  # noqa: SIM222\n# add the virtual environments libraries to the host python import mechanism\nprev_length = len(sys.path)\nfor lib in \"..\\\\Lib\\\\site-packages\".split(os.pathsep):\n    path = os.path.realpath(os.path.join(bin_dir, lib))",
+        "detail": ".venv.Scripts.activate_this",
+        "documentation": {}
+    },
+    {
+        "label": "base",
+        "kind": 5,
+        "importPath": ".venv.Scripts.activate_this",
+        "description": ".venv.Scripts.activate_this",
+        "peekOfCode": "base = bin_dir[: -len(\"Scripts\") - 1]  # strip away the bin part from the __file__, plus the path separator\n# prepend bin to PATH (this file is inside the bin directory)\nos.environ[\"PATH\"] = os.pathsep.join([bin_dir, *os.environ.get(\"PATH\", \"\").split(os.pathsep)])\nos.environ[\"VIRTUAL_ENV\"] = base  # virtual env is right above bin directory\nos.environ[\"VIRTUAL_ENV_PROMPT\"] = \"tutorx-mcp\" or os.path.basename(base)  # noqa: SIM222\n# add the virtual environments libraries to the host python import mechanism\nprev_length = len(sys.path)\nfor lib in \"..\\\\Lib\\\\site-packages\".split(os.pathsep):\n    path = os.path.realpath(os.path.join(bin_dir, lib))\n    site.addsitedir(path)",
+        "detail": ".venv.Scripts.activate_this",
+        "documentation": {}
+    },
+    {
+        "label": "os.environ[\"PATH\"]",
+        "kind": 5,
+        "importPath": ".venv.Scripts.activate_this",
+        "description": ".venv.Scripts.activate_this",
+        "peekOfCode": "os.environ[\"PATH\"] = os.pathsep.join([bin_dir, *os.environ.get(\"PATH\", \"\").split(os.pathsep)])\nos.environ[\"VIRTUAL_ENV\"] = base  # virtual env is right above bin directory\nos.environ[\"VIRTUAL_ENV_PROMPT\"] = \"tutorx-mcp\" or os.path.basename(base)  # noqa: SIM222\n# add the virtual environments libraries to the host python import mechanism\nprev_length = len(sys.path)\nfor lib in \"..\\\\Lib\\\\site-packages\".split(os.pathsep):\n    path = os.path.realpath(os.path.join(bin_dir, lib))\n    site.addsitedir(path)\nsys.path[:] = sys.path[prev_length:] + sys.path[0:prev_length]\nsys.real_prefix = sys.prefix",
+        "detail": ".venv.Scripts.activate_this",
+        "documentation": {}
+    },
+    {
+        "label": "os.environ[\"VIRTUAL_ENV\"]",
+        "kind": 5,
+        "importPath": ".venv.Scripts.activate_this",
+        "description": ".venv.Scripts.activate_this",
+        "peekOfCode": "os.environ[\"VIRTUAL_ENV\"] = base  # virtual env is right above bin directory\nos.environ[\"VIRTUAL_ENV_PROMPT\"] = \"tutorx-mcp\" or os.path.basename(base)  # noqa: SIM222\n# add the virtual environments libraries to the host python import mechanism\nprev_length = len(sys.path)\nfor lib in \"..\\\\Lib\\\\site-packages\".split(os.pathsep):\n    path = os.path.realpath(os.path.join(bin_dir, lib))\n    site.addsitedir(path)\nsys.path[:] = sys.path[prev_length:] + sys.path[0:prev_length]\nsys.real_prefix = sys.prefix\nsys.prefix = base",
+        "detail": ".venv.Scripts.activate_this",
+        "documentation": {}
+    },
+    {
+        "label": "os.environ[\"VIRTUAL_ENV_PROMPT\"]",
+        "kind": 5,
+        "importPath": ".venv.Scripts.activate_this",
+        "description": ".venv.Scripts.activate_this",
+        "peekOfCode": "os.environ[\"VIRTUAL_ENV_PROMPT\"] = \"tutorx-mcp\" or os.path.basename(base)  # noqa: SIM222\n# add the virtual environments libraries to the host python import mechanism\nprev_length = len(sys.path)\nfor lib in \"..\\\\Lib\\\\site-packages\".split(os.pathsep):\n    path = os.path.realpath(os.path.join(bin_dir, lib))\n    site.addsitedir(path)\nsys.path[:] = sys.path[prev_length:] + sys.path[0:prev_length]\nsys.real_prefix = sys.prefix\nsys.prefix = base",
+        "detail": ".venv.Scripts.activate_this",
+        "documentation": {}
+    },
+    {
+        "label": "prev_length",
+        "kind": 5,
+        "importPath": ".venv.Scripts.activate_this",
+        "description": ".venv.Scripts.activate_this",
+        "peekOfCode": "prev_length = len(sys.path)\nfor lib in \"..\\\\Lib\\\\site-packages\".split(os.pathsep):\n    path = os.path.realpath(os.path.join(bin_dir, lib))\n    site.addsitedir(path)\nsys.path[:] = sys.path[prev_length:] + sys.path[0:prev_length]\nsys.real_prefix = sys.prefix\nsys.prefix = base",
+        "detail": ".venv.Scripts.activate_this",
+        "documentation": {}
+    },
+    {
+        "label": "sys.path[:]",
+        "kind": 5,
+        "importPath": ".venv.Scripts.activate_this",
+        "description": ".venv.Scripts.activate_this",
+        "peekOfCode": "sys.path[:] = sys.path[prev_length:] + sys.path[0:prev_length]\nsys.real_prefix = sys.prefix\nsys.prefix = base",
+        "detail": ".venv.Scripts.activate_this",
+        "documentation": {}
+    },
+    {
+        "label": "sys.real_prefix",
+        "kind": 5,
+        "importPath": ".venv.Scripts.activate_this",
+        "description": ".venv.Scripts.activate_this",
+        "peekOfCode": "sys.real_prefix = sys.prefix\nsys.prefix = base",
+        "detail": ".venv.Scripts.activate_this",
+        "documentation": {}
+    },
+    {
+        "label": "sys.prefix",
+        "kind": 5,
+        "importPath": ".venv.Scripts.activate_this",
+        "description": ".venv.Scripts.activate_this",
+        "peekOfCode": "sys.prefix = base",
+        "detail": ".venv.Scripts.activate_this",
+        "documentation": {}
+    },
+    {
+        "label": "cmp",
+        "kind": 2,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "def cmp(a, b):\n    return (a > b) - (a < b)\nfrom builtins import zip\nfrom builtins import str\nimport os\nimport os.path as op\nimport sys\nfrom xml.etree import cElementTree as ET\nimport pyxnat\nPROJ_ATTRS = [",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "copy_attrs",
+        "kind": 2,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "def copy_attrs(src_obj, dest_obj, attr_list):\n    \"\"\" Copies list of attributes form source to destination\"\"\"\n    src_attrs = src_obj.attrs.mget(attr_list)\n    src_list = dict(list(zip(attr_list, src_attrs)))\n    # NOTE: For some reason need to set te again b/c a bug somewhere sets te\n    # to sequence name\n    te_key = 'xnat:mrScanData/parameters/te'\n    if te_key in src_list:\n        src_list[te_key] = src_obj.attrs.get(te_key)\n    dest_obj.attrs.mset(src_list)",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "copy_attributes",
+        "kind": 2,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "def copy_attributes(src_obj, dest_obj):\n    '''Copy attributes from src to dest'''\n    src_type = src_obj.datatype()\n    types = {'xnat:projectData': PROJ_ATTRS,\n             'xnat:subjectData': SUBJ_ATTRS,\n             'xnat:mrSessionData': MR_EXP_ATTRS,\n             'xnat:petSessionData': PET_EXP_ATTRS,\n             'xnat:ctSessionData': CT_EXP_ATTRS,\n             'xnat:mrScanData': MR_SCAN_ATTRS,\n             'xnat:petScanData': PET_SCAN_ATTRS,",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "subj_compare",
+        "kind": 2,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "def subj_compare(item1, item2):\n    '''Compare sort of items'''\n    return cmp(item1.label(), item2.label())\ndef copy_file(src_f, dest_r, cache_d):\n    '''\n    Copy file from XNAT file source to XNAT resource destination,\n    using local cache in between'''\n    f_label = src_f.label()\n    loc_f = cache_d + '/' + f_label\n    # Make subdirectories",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "copy_file",
+        "kind": 2,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "def copy_file(src_f, dest_r, cache_d):\n    '''\n    Copy file from XNAT file source to XNAT resource destination,\n    using local cache in between'''\n    f_label = src_f.label()\n    loc_f = cache_d + '/' + f_label\n    # Make subdirectories\n    loc_d = op.dirname(loc_f)\n    if not op.exists(loc_d):\n        os.makedirs(loc_d)",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "copy_res_zip",
+        "kind": 2,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "def copy_res_zip(src_r, dest_r, cache_d):\n    '''\n    Copy a resource from XNAT source to XNAT destination using local cache\n    in between\n    '''\n    try:\n        # Download zip of resource\n        print('INFO:Downloading resource as zip...')\n        cache_z = src_r.get(cache_d, extract=False)\n        # Upload zip of resource",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "is_empty_resource",
+        "kind": 2,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "def is_empty_resource(_res):\n    '''Check if resource contains any files'''\n    f_count = 0\n    for f_in in _res.files().fetchall('obj'):\n        f_count += 1\n        break\n    return f_count == 0\n# copy_project and copy_subject are untested\n# def copy_project(src_proj, dst_proj, proj_cache_dir):\n#     '''Copy XNAT project from source to destination'''",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "copy_session",
+        "kind": 2,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "def copy_session(src_sess, dst_sess, sess_cache_dir):\n    '''Copy XNAT session from source to destination'''\n    print('INFO:uploading session attributes as xml')\n    # Write xml to file\n    if not op.exists(sess_cache_dir):\n        os.makedirs(sess_cache_dir)\n    sess_xml = src_sess.get()\n    xml_path = op.join(sess_cache_dir, 'sess.xml')\n    write_xml(sess_xml, xml_path)\n    sess_type = src_sess.datatype()",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "copy_scan",
+        "kind": 2,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "def copy_scan(src_scan, dst_scan, scan_cache_dir):\n    '''Copy scan from source XNAT to destination XNAT'''\n    scan_type = src_scan.datatype()\n    if scan_type == '':\n        scan_type = 'xnat:otherDicomScanData'\n    dst_scan.create(scans=scan_type)\n    copy_attributes(src_scan, dst_scan)\n    # Process each resource of scan\n    for src_res in src_scan.resources().fetchall('obj'):\n        res_label = src_res.label()",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "copy_res",
+        "kind": 2,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "def copy_res(src_res, dst_res, res_cache_dir, use_zip=False):\n    '''Copy resource from source XNAT to destination XNAT'''\n    # Create cache dir\n    if not op.exists(res_cache_dir):\n        os.makedirs(res_cache_dir)\n    # Prepare resource and check for empty\n    is_empty = False\n    print(dst_res._uri)\n    if not dst_res.exists():\n        dst_res.create()",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "write_xml",
+        "kind": 2,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "def write_xml(xml_str, file_path, clean_tags=True):\n    \"\"\"Writing XML.\"\"\"\n    root = ET.fromstring(xml_str)\n    # We only want the tags and attributes relevant to root, no children\n    if clean_tags:\n        # Remove ID\n        if 'ID' in root.attrib:\n            del root.attrib['ID']\n        # Remove sharing tags\n        tag = '{http://nrg.wustl.edu/xnat}sharing'",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "create_parser",
+        "kind": 2,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "def create_parser():\n    import argparse\n    \"\"\"Parse commandline arguments.\"\"\"\n    arg_parser = argparse.ArgumentParser(\n        description='Downloads a given experiment/session from an XNAT instance '\n                    'and uploads it to an independent one. Only DICOM resources '\n                    'will be imported.',\n        formatter_class=argparse.RawTextHelpFormatter)\n    arg_parser.add_argument(\n        '--h1', '--source_config', dest='source_config',",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "main",
+        "kind": 2,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "def main(args):\n    x1 = pyxnat.Interface(config=args.source_config)\n    x2 = pyxnat.Interface(config=args.dest_config)\n    columns = ['subject_label', 'label']\n    e1 = x1.array.experiments(experiment_id=args.experiment_id,\n                              columns=columns).data[0]\n    p = x2.select.project(args.project_id)\n    s = p.subject(e1['subject_label'])\n    if not s.exists():\n        s.create()",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "PROJ_ATTRS",
+        "kind": 5,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "PROJ_ATTRS = [\n    'xnat:projectData/name',\n    'xnat:projectData/description',\n    'xnat:projectData/keywords',\n]\nSUBJ_ATTRS = [\n    'xnat:subjectData/group',\n    'xnat:subjectData/src',\n    'xnat:subjectData/investigator/firstname',\n    'xnat:subjectData/investigator/lastname',",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "SUBJ_ATTRS",
+        "kind": 5,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "SUBJ_ATTRS = [\n    'xnat:subjectData/group',\n    'xnat:subjectData/src',\n    'xnat:subjectData/investigator/firstname',\n    'xnat:subjectData/investigator/lastname',\n    'xnat:subjectData/demographics[@xsi:type=xnat:demographicData]/dob',\n    'xnat:subjectData/demographics[@xsi:type=xnat:demographicData]/yob',\n    'xnat:subjectData/demographics[@xsi:type=xnat:demographicData]/age',\n    'xnat:subjectData/demographics[@xsi:type=xnat:demographicData]/gender',\n    'xnat:subjectData/demographics[@xsi:type=xnat:demographicData]/handedness',",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "MR_EXP_ATTRS",
+        "kind": 5,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "MR_EXP_ATTRS = [\n    'xnat:experimentData/date',\n    'xnat:experimentData/visit_id',\n    'xnat:experimentData/time',\n    'xnat:experimentData/note',\n    'xnat:experimentData/investigator/firstname',\n    'xnat:experimentData/investigator/lastname',\n    'xnat:imageSessionData/scanner/manufacturer',\n    'xnat:imageSessionData/scanner/model',\n    'xnat:imageSessionData/operator',",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "OTHER_DICOM_SCAN_ATTRS",
+        "kind": 5,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "OTHER_DICOM_SCAN_ATTRS = [\n    'xnat:imageScanData/type',\n    'xnat:imageScanData/UID',\n    'xnat:imageScanData/note',\n    'xnat:imageScanData/quality',\n    'xnat:imageScanData/condition',\n    'xnat:imageScanData/series_description',\n    'xnat:imageScanData/documentation',\n    'xnat:imageScanData/frames',\n    'xnat:imageScanData/startTime',",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "MR_SCAN_ATTRS",
+        "kind": 5,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "MR_SCAN_ATTRS = [\n    'xnat:imageScanData/type',\n    'xnat:imageScanData/UID',\n    'xnat:imageScanData/note',\n    'xnat:imageScanData/quality',\n    'xnat:imageScanData/condition',\n    'xnat:imageScanData/series_description',\n    'xnat:imageScanData/documentation',\n    'xnat:imageScanData/frames',\n    'xnat:imageScanData/startTime',",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "SC_SCAN_ATTRS",
+        "kind": 5,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "SC_SCAN_ATTRS = [\n    'xnat:imageScanData/type',\n    'xnat:imageScanData/UID',\n    'xnat:imageScanData/note',\n    'xnat:imageScanData/quality',\n    'xnat:imageScanData/condition',\n    'xnat:imageScanData/series_description',\n    'xnat:imageScanData/documentation',\n    'xnat:imageScanData/frames',\n    'xnat:imageScanData/scanner/manufacturer',",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "PET_EXP_ATTRS",
+        "kind": 5,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "PET_EXP_ATTRS = [\n    'xnat:experimentData/date',\n    'xnat:experimentData/visit_id',\n    'xnat:experimentData/time',\n    'xnat:experimentData/note',\n    'xnat:experimentData/investigator/firstname',\n    'xnat:experimentData/investigator/lastname',\n    'xnat:imageSessionData/scanner/manufacturer',\n    'xnat:imageSessionData/scanner/model',\n    'xnat:imageSessionData/operator',",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "CT_EXP_ATTRS",
+        "kind": 5,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "CT_EXP_ATTRS = [\n    'xnat:experimentData/date',\n    'xnat:experimentData/visit_id',\n    'xnat:experimentData/time',\n    'xnat:experimentData/note',\n    'xnat:experimentData/investigator/firstname',\n    'xnat:experimentData/investigator/lastname',\n    'xnat:imageSessionData/scanner/manufacturer',\n    'xnat:imageSessionData/scanner/model',\n    'xnat:imageSessionData/operator',",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "PET_SCAN_ATTRS",
+        "kind": 5,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "PET_SCAN_ATTRS = [\n    'xnat:imageScanData/type',\n    'xnat:imageScanData/UID',\n    'xnat:imageScanData/note',\n    'xnat:imageScanData/quality',\n    'xnat:imageScanData/condition',\n    'xnat:imageScanData/series_description',\n    'xnat:imageScanData/documentation',\n    'xnat:imageScanData/frames',\n    'xnat:imageScanData/scanner/manufacturer',",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "CT_SCAN_ATTRS",
+        "kind": 5,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "CT_SCAN_ATTRS = [\n    'xnat:imageScanData/type',\n    'xnat:imageScanData/UID',\n    'xnat:imageScanData/note',\n    'xnat:imageScanData/quality',\n    'xnat:imageScanData/condition',\n    'xnat:imageScanData/series_description',\n    'xnat:imageScanData/documentation',\n    'xnat:imageScanData/frames',\n    'xnat:imageScanData/scanner/manufacturer',",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "PROC_ATTRS",
+        "kind": 5,
+        "importPath": ".venv.Scripts.sessionmirror",
+        "description": ".venv.Scripts.sessionmirror",
+        "peekOfCode": "PROC_ATTRS = [\n    'proc:genProcData/validation/status',\n    'proc:genProcData/procstatus',\n    'proc:genProcData/proctype',\n    'proc:genProcData/procversion',\n    'proc:genProcData/walltimeused',\n    'proc:genProcData/memused'\n]\ndef copy_attrs(src_obj, dest_obj, attr_list):\n    \"\"\" Copies list of attributes form source to destination\"\"\"",
+        "detail": ".venv.Scripts.sessionmirror",
+        "documentation": {}
+    },
+    {
+        "label": "ModelError",
+        "kind": 6,
+        "importPath": "mcp_server.model.gemini_flash",
+        "description": "mcp_server.model.gemini_flash",
+        "peekOfCode": "class ModelError(Exception):\n    \"\"\"Custom exception for model-related errors\"\"\"\n    pass\ndef fallback_to_15_flash(method: Callable[..., T]) -> Callable[..., T]:\n    \"\"\"\n    Decorator to automatically fall back to 1.5 if 2.0 fails.\n    Only applies when the instance's version is '2.0'.\n    \"\"\"\n    @wraps(method)\n    async def wrapper(self: 'GeminiFlash', *args: Any, **kwargs: Any) -> T:",
+        "detail": "mcp_server.model.gemini_flash",
+        "documentation": {}
+    },
+    {
+        "label": "GeminiFlash",
+        "kind": 6,
+        "importPath": "mcp_server.model.gemini_flash",
+        "description": "mcp_server.model.gemini_flash",
+        "peekOfCode": "class GeminiFlash:\n    \"\"\"\n    Google Gemini Flash model implementation with automatic fallback from 2.0 to 1.5.\n    \"\"\"\n    SUPPORTED_VERSIONS = ['2.0', '1.5']\n    def __init__(self, version: str = '2.0', api_key: Optional[str] = None, _is_fallback: bool = False):\n        \"\"\"\n        Initialize the Gemini Flash model.\n        Args:\n            version: Model version ('2.0' or '1.5')",
+        "detail": "mcp_server.model.gemini_flash",
+        "documentation": {}
+    },
+    {
+        "label": "fallback_to_15_flash",
+        "kind": 2,
+        "importPath": "mcp_server.model.gemini_flash",
+        "description": "mcp_server.model.gemini_flash",
+        "peekOfCode": "def fallback_to_15_flash(method: Callable[..., T]) -> Callable[..., T]:\n    \"\"\"\n    Decorator to automatically fall back to 1.5 if 2.0 fails.\n    Only applies when the instance's version is '2.0'.\n    \"\"\"\n    @wraps(method)\n    async def wrapper(self: 'GeminiFlash', *args: Any, **kwargs: Any) -> T:\n        if self.version != '2.0' or not self._should_fallback:\n            return await method(self, *args, **kwargs)\n        try:",
+        "detail": "mcp_server.model.gemini_flash",
+        "documentation": {}
+    },
+    {
+        "label": "logger",
+        "kind": 5,
+        "importPath": "mcp_server.model.gemini_flash",
+        "description": "mcp_server.model.gemini_flash",
+        "peekOfCode": "logger = logging.getLogger(__name__)\nT = TypeVar('T')\nclass ModelError(Exception):\n    \"\"\"Custom exception for model-related errors\"\"\"\n    pass\ndef fallback_to_15_flash(method: Callable[..., T]) -> Callable[..., T]:\n    \"\"\"\n    Decorator to automatically fall back to 1.5 if 2.0 fails.\n    Only applies when the instance's version is '2.0'.\n    \"\"\"",
+        "detail": "mcp_server.model.gemini_flash",
+        "documentation": {}
+    },
+    {
+        "label": "T",
+        "kind": 5,
+        "importPath": "mcp_server.model.gemini_flash",
+        "description": "mcp_server.model.gemini_flash",
+        "peekOfCode": "T = TypeVar('T')\nclass ModelError(Exception):\n    \"\"\"Custom exception for model-related errors\"\"\"\n    pass\ndef fallback_to_15_flash(method: Callable[..., T]) -> Callable[..., T]:\n    \"\"\"\n    Decorator to automatically fall back to 1.5 if 2.0 fails.\n    Only applies when the instance's version is '2.0'.\n    \"\"\"\n    @wraps(method)",
+        "detail": "mcp_server.model.gemini_flash",
+        "documentation": {}
+    },
+    {
+        "label": "get_concept",
+        "kind": 2,
+        "importPath": "mcp_server.resources.concept_graph",
+        "description": "mcp_server.resources.concept_graph",
+        "peekOfCode": "def get_concept(concept_id: str) -> Dict[str, Any]:\n    \"\"\"Get a specific concept by ID or return None if not found.\"\"\"\n    return CONCEPT_GRAPH.get(concept_id)\ndef get_all_concepts() -> Dict[str, Any]:\n    \"\"\"Get all concepts in the graph.\"\"\"\n    return {\"concepts\": list(CONCEPT_GRAPH.values())}\ndef get_concept_graph() -> Dict[str, Any]:\n    \"\"\"Get the complete concept graph.\"\"\"\n    return CONCEPT_GRAPH",
+        "detail": "mcp_server.resources.concept_graph",
+        "documentation": {}
+    },
+    {
+        "label": "get_all_concepts",
+        "kind": 2,
+        "importPath": "mcp_server.resources.concept_graph",
+        "description": "mcp_server.resources.concept_graph",
+        "peekOfCode": "def get_all_concepts() -> Dict[str, Any]:\n    \"\"\"Get all concepts in the graph.\"\"\"\n    return {\"concepts\": list(CONCEPT_GRAPH.values())}\ndef get_concept_graph() -> Dict[str, Any]:\n    \"\"\"Get the complete concept graph.\"\"\"\n    return CONCEPT_GRAPH",
+        "detail": "mcp_server.resources.concept_graph",
+        "documentation": {}
+    },
+    {
+        "label": "get_concept_graph",
+        "kind": 2,
+        "importPath": "mcp_server.resources.concept_graph",
+        "description": "mcp_server.resources.concept_graph",
+        "peekOfCode": "def get_concept_graph() -> Dict[str, Any]:\n    \"\"\"Get the complete concept graph.\"\"\"\n    return CONCEPT_GRAPH",
+        "detail": "mcp_server.resources.concept_graph",
+        "documentation": {}
+    },
+    {
+        "label": "CONCEPT_GRAPH",
+        "kind": 5,
+        "importPath": "mcp_server.resources.concept_graph",
+        "description": "mcp_server.resources.concept_graph",
+        "peekOfCode": "CONCEPT_GRAPH = {\n    \"python\": {\n        \"id\": \"python\",\n        \"name\": \"Python Programming\",\n        \"description\": \"Fundamentals of Python programming language\",\n        \"prerequisites\": [],\n        \"related\": [\"functions\", \"oop\", \"data_structures\"]\n    },\n    \"functions\": {\n        \"id\": \"functions\",",
+        "detail": "mcp_server.resources.concept_graph",
+        "documentation": {}
+    },
+    {
+        "label": "get_curriculum_standards",
+        "kind": 2,
+        "importPath": "mcp_server.resources.curriculum_standards",
+        "description": "mcp_server.resources.curriculum_standards",
+        "peekOfCode": "def get_curriculum_standards(country_code: str = \"us\") -> Dict[str, Any]:\n    \"\"\"\n    Get curriculum standards for a specific country.\n    Args:\n        country_code: ISO country code (e.g., 'us', 'uk', 'in', 'sg', 'ca')\n    Returns:\n        Dictionary containing curriculum standards for the specified country\n    \"\"\"\n    country_code = country_code.lower()\n    if country_code not in CURRICULUM_STANDARDS:",
+        "detail": "mcp_server.resources.curriculum_standards",
+        "documentation": {}
+    },
+    {
+        "label": "CURRICULUM_STANDARDS",
+        "kind": 5,
+        "importPath": "mcp_server.resources.curriculum_standards",
+        "description": "mcp_server.resources.curriculum_standards",
+        "peekOfCode": "CURRICULUM_STANDARDS = {\n    \"us\": {\n        \"name\": \"Common Core State Standards (US)\",\n        \"subjects\": {\n            \"math\": {\n                \"k-5\": [\"Counting & Cardinality\", \"Operations & Algebraic Thinking\", \"Number & Operations\"],\n                \"6-8\": [\"Ratios & Proportional Relationships\", \"The Number System\", \"Expressions & Equations\"],\n                \"9-12\": [\"Number & Quantity\", \"Algebra\", \"Functions\", \"Modeling\", \"Geometry\", \"Statistics & Probability\"]\n            },\n            \"ela\": {",
+        "detail": "mcp_server.resources.curriculum_standards",
+        "documentation": {}
+    },
+    {
+        "label": "current_dir",
+        "kind": 5,
+        "importPath": "mcp_server.tools.concept_graph_tools",
+        "description": "mcp_server.tools.concept_graph_tools",
+        "peekOfCode": "current_dir = Path(__file__).parent\nparent_dir = current_dir.parent.parent\nsys.path.insert(0, str(parent_dir))\nimport sys\nimport os\nfrom pathlib import Path\n# Add the parent directory to the Python path\ncurrent_dir = Path(__file__).parent\nparent_dir = current_dir.parent\nsys.path.insert(0, str(parent_dir))",
+        "detail": "mcp_server.tools.concept_graph_tools",
+        "documentation": {}
+    },
+    {
+        "label": "parent_dir",
+        "kind": 5,
+        "importPath": "mcp_server.tools.concept_graph_tools",
+        "description": "mcp_server.tools.concept_graph_tools",
+        "peekOfCode": "parent_dir = current_dir.parent.parent\nsys.path.insert(0, str(parent_dir))\nimport sys\nimport os\nfrom pathlib import Path\n# Add the parent directory to the Python path\ncurrent_dir = Path(__file__).parent\nparent_dir = current_dir.parent\nsys.path.insert(0, str(parent_dir))\n# Import from local resources",
+        "detail": "mcp_server.tools.concept_graph_tools",
+        "documentation": {}
+    },
+    {
+        "label": "current_dir",
+        "kind": 5,
+        "importPath": "mcp_server.tools.concept_graph_tools",
+        "description": "mcp_server.tools.concept_graph_tools",
+        "peekOfCode": "current_dir = Path(__file__).parent\nparent_dir = current_dir.parent\nsys.path.insert(0, str(parent_dir))\n# Import from local resources\nfrom resources import concept_graph\n# Import MCP\nfrom mcp_server.mcp_instance import mcp\nfrom mcp_server.model.gemini_flash import GeminiFlash\nMODEL = GeminiFlash()\[email protected]()",
+        "detail": "mcp_server.tools.concept_graph_tools",
+        "documentation": {}
+    },
+    {
+        "label": "parent_dir",
+        "kind": 5,
+        "importPath": "mcp_server.tools.concept_graph_tools",
+        "description": "mcp_server.tools.concept_graph_tools",
+        "peekOfCode": "parent_dir = current_dir.parent\nsys.path.insert(0, str(parent_dir))\n# Import from local resources\nfrom resources import concept_graph\n# Import MCP\nfrom mcp_server.mcp_instance import mcp\nfrom mcp_server.model.gemini_flash import GeminiFlash\nMODEL = GeminiFlash()\[email protected]()\nasync def get_concept_graph_tool(concept_id: Optional[str] = None) -> dict:",
+        "detail": "mcp_server.tools.concept_graph_tools",
+        "documentation": {}
+    },
+    {
+        "label": "MODEL",
+        "kind": 5,
+        "importPath": "mcp_server.tools.concept_graph_tools",
+        "description": "mcp_server.tools.concept_graph_tools",
+        "peekOfCode": "MODEL = GeminiFlash()\[email protected]()\nasync def get_concept_graph_tool(concept_id: Optional[str] = None) -> dict:\n    \"\"\"\n    Get the complete concept graph or a specific concept, fully LLM-driven.\n    For a specific concept, use Gemini to generate a JSON object with explanation, related concepts, prerequisites, and summary.\n    For the full graph, use Gemini to generate a JSON object with a list of all concepts and their relationships.\n    \"\"\"\n    if concept_id:\n        prompt = (",
+        "detail": "mcp_server.tools.concept_graph_tools",
+        "documentation": {}
+    },
+    {
+        "label": "current_dir",
+        "kind": 5,
+        "importPath": "mcp_server.tools.concept_tools",
+        "description": "mcp_server.tools.concept_tools",
+        "peekOfCode": "current_dir = Path(__file__).parent\nparent_dir = current_dir.parent.parent\nsys.path.insert(0, str(parent_dir))\nimport sys\nimport os\nfrom pathlib import Path\n# Add the parent directory to the Python path\ncurrent_dir = Path(__file__).parent\nparent_dir = current_dir.parent\nsys.path.insert(0, str(parent_dir))",
+        "detail": "mcp_server.tools.concept_tools",
+        "documentation": {}
+    },
+    {
+        "label": "parent_dir",
+        "kind": 5,
+        "importPath": "mcp_server.tools.concept_tools",
+        "description": "mcp_server.tools.concept_tools",
+        "peekOfCode": "parent_dir = current_dir.parent.parent\nsys.path.insert(0, str(parent_dir))\nimport sys\nimport os\nfrom pathlib import Path\n# Add the parent directory to the Python path\ncurrent_dir = Path(__file__).parent\nparent_dir = current_dir.parent\nsys.path.insert(0, str(parent_dir))\n# Import from local resources",
+        "detail": "mcp_server.tools.concept_tools",
+        "documentation": {}
+    },
+    {
+        "label": "current_dir",
+        "kind": 5,
+        "importPath": "mcp_server.tools.concept_tools",
+        "description": "mcp_server.tools.concept_tools",
+        "peekOfCode": "current_dir = Path(__file__).parent\nparent_dir = current_dir.parent\nsys.path.insert(0, str(parent_dir))\n# Import from local resources\nfrom resources.concept_graph import get_concept, get_all_concepts\n# Import MCP\nfrom mcp_server.mcp_instance import mcp\nfrom mcp_server.model.gemini_flash import GeminiFlash\nMODEL = GeminiFlash()\[email protected]()",
+        "detail": "mcp_server.tools.concept_tools",
+        "documentation": {}
+    },
+    {
+        "label": "parent_dir",
+        "kind": 5,
+        "importPath": "mcp_server.tools.concept_tools",
+        "description": "mcp_server.tools.concept_tools",
+        "peekOfCode": "parent_dir = current_dir.parent\nsys.path.insert(0, str(parent_dir))\n# Import from local resources\nfrom resources.concept_graph import get_concept, get_all_concepts\n# Import MCP\nfrom mcp_server.mcp_instance import mcp\nfrom mcp_server.model.gemini_flash import GeminiFlash\nMODEL = GeminiFlash()\[email protected]()\nasync def get_concept_tool(concept_id: str = None) -> dict:",
+        "detail": "mcp_server.tools.concept_tools",
+        "documentation": {}
+    },
+    {
+        "label": "MODEL",
+        "kind": 5,
+        "importPath": "mcp_server.tools.concept_tools",
+        "description": "mcp_server.tools.concept_tools",
+        "peekOfCode": "MODEL = GeminiFlash()\[email protected]()\nasync def get_concept_tool(concept_id: str = None) -> dict:\n    \"\"\"\n    Get a specific concept or all concepts from the knowledge graph, fully LLM-driven.\n    If a concept_id is provided, use Gemini to generate a JSON object with explanation, key points, and example.\n    \"\"\"\n    if not concept_id:\n        return {\"error\": \"concept_id is required for LLM-driven mode\"}\n    prompt = (",
+        "detail": "mcp_server.tools.concept_tools",
+        "documentation": {}
+    },
+    {
+        "label": "calculate_similarity",
+        "kind": 2,
+        "importPath": "mcp_server.tools.interaction_tools",
+        "description": "mcp_server.tools.interaction_tools",
+        "peekOfCode": "def calculate_similarity(text1: str, text2: str) -> float:\n    \"\"\"Calculate the similarity ratio between two texts.\"\"\"\n    return 0.0  # No longer used, LLM-driven\[email protected]()\nasync def text_interaction(query: str, student_id: str) -> dict:\n    \"\"\"\n    Process a text query from a student and provide an educational response, fully LLM-driven.\n    Use Gemini to generate a JSON object with a response and suggested actions/resources.\n    \"\"\"\n    prompt = (",
+        "detail": "mcp_server.tools.interaction_tools",
+        "documentation": {}
+    },
+    {
+        "label": "MODEL",
+        "kind": 5,
+        "importPath": "mcp_server.tools.interaction_tools",
+        "description": "mcp_server.tools.interaction_tools",
+        "peekOfCode": "MODEL = GeminiFlash()\ndef calculate_similarity(text1: str, text2: str) -> float:\n    \"\"\"Calculate the similarity ratio between two texts.\"\"\"\n    return 0.0  # No longer used, LLM-driven\[email protected]()\nasync def text_interaction(query: str, student_id: str) -> dict:\n    \"\"\"\n    Process a text query from a student and provide an educational response, fully LLM-driven.\n    Use Gemini to generate a JSON object with a response and suggested actions/resources.\n    \"\"\"",
+        "detail": "mcp_server.tools.interaction_tools",
+        "documentation": {}
+    },
+    {
+        "label": "get_prerequisites",
+        "kind": 2,
+        "importPath": "mcp_server.tools.learning_path_tools",
+        "description": "mcp_server.tools.learning_path_tools",
+        "peekOfCode": "def get_prerequisites(concept_id: str, visited: Optional[set] = None) -> List[Dict[str, Any]]:\n    \"\"\"\n    Get all prerequisites for a concept recursively.\n    Args:\n        concept_id: ID of the concept to get prerequisites for\n        visited: Set of already visited concepts to avoid cycles\n    Returns:\n        List of prerequisite concepts in order\n    \"\"\"\n    if visited is None:",
+        "detail": "mcp_server.tools.learning_path_tools",
+        "documentation": {}
+    },
+    {
+        "label": "generate_learning_path",
+        "kind": 2,
+        "importPath": "mcp_server.tools.learning_path_tools",
+        "description": "mcp_server.tools.learning_path_tools",
+        "peekOfCode": "def generate_learning_path(concept_ids: List[str], student_level: str = \"beginner\") -> Dict[str, Any]:\n    \"\"\"\n    Generate a personalized learning path for a student.\n    Args:\n        concept_ids: List of concept IDs to include in the learning path\n        student_level: Student's current level (beginner, intermediate, advanced)\n    Returns:\n        Dictionary containing the learning path\n    \"\"\"\n    if not concept_ids:",
+        "detail": "mcp_server.tools.learning_path_tools",
+        "documentation": {}
+    },
+    {
+        "label": "current_dir",
+        "kind": 5,
+        "importPath": "mcp_server.tools.learning_path_tools",
+        "description": "mcp_server.tools.learning_path_tools",
+        "peekOfCode": "current_dir = Path(__file__).parent\nparent_dir = current_dir.parent.parent\nsys.path.insert(0, str(parent_dir))\nimport sys\nimport os\nfrom pathlib import Path\n# Add the parent directory to the Python path\ncurrent_dir = Path(__file__).parent\nparent_dir = current_dir.parent\nsys.path.insert(0, str(parent_dir))",
+        "detail": "mcp_server.tools.learning_path_tools",
+        "documentation": {}
+    },
+    {
+        "label": "parent_dir",
+        "kind": 5,
+        "importPath": "mcp_server.tools.learning_path_tools",
+        "description": "mcp_server.tools.learning_path_tools",
+        "peekOfCode": "parent_dir = current_dir.parent.parent\nsys.path.insert(0, str(parent_dir))\nimport sys\nimport os\nfrom pathlib import Path\n# Add the parent directory to the Python path\ncurrent_dir = Path(__file__).parent\nparent_dir = current_dir.parent\nsys.path.insert(0, str(parent_dir))\n# Import from local resources",
+        "detail": "mcp_server.tools.learning_path_tools",
+        "documentation": {}
+    },
+    {
+        "label": "current_dir",
+        "kind": 5,
+        "importPath": "mcp_server.tools.learning_path_tools",
+        "description": "mcp_server.tools.learning_path_tools",
+        "peekOfCode": "current_dir = Path(__file__).parent\nparent_dir = current_dir.parent\nsys.path.insert(0, str(parent_dir))\n# Import from local resources\nfrom resources.concept_graph import CONCEPT_GRAPH\n# Import MCP\nfrom mcp_server.mcp_instance import mcp\nfrom mcp_server.model.gemini_flash import GeminiFlash\nMODEL = GeminiFlash()\ndef get_prerequisites(concept_id: str, visited: Optional[set] = None) -> List[Dict[str, Any]]:",
+        "detail": "mcp_server.tools.learning_path_tools",
+        "documentation": {}
+    },
+    {
+        "label": "parent_dir",
+        "kind": 5,
+        "importPath": "mcp_server.tools.learning_path_tools",
+        "description": "mcp_server.tools.learning_path_tools",
+        "peekOfCode": "parent_dir = current_dir.parent\nsys.path.insert(0, str(parent_dir))\n# Import from local resources\nfrom resources.concept_graph import CONCEPT_GRAPH\n# Import MCP\nfrom mcp_server.mcp_instance import mcp\nfrom mcp_server.model.gemini_flash import GeminiFlash\nMODEL = GeminiFlash()\ndef get_prerequisites(concept_id: str, visited: Optional[set] = None) -> List[Dict[str, Any]]:\n    \"\"\"",
+        "detail": "mcp_server.tools.learning_path_tools",
+        "documentation": {}
+    },
+    {
+        "label": "MODEL",
+        "kind": 5,
+        "importPath": "mcp_server.tools.learning_path_tools",
+        "description": "mcp_server.tools.learning_path_tools",
+        "peekOfCode": "MODEL = GeminiFlash()\ndef get_prerequisites(concept_id: str, visited: Optional[set] = None) -> List[Dict[str, Any]]:\n    \"\"\"\n    Get all prerequisites for a concept recursively.\n    Args:\n        concept_id: ID of the concept to get prerequisites for\n        visited: Set of already visited concepts to avoid cycles\n    Returns:\n        List of prerequisite concepts in order\n    \"\"\"",
+        "detail": "mcp_server.tools.learning_path_tools",
+        "documentation": {}
+    },
+    {
+        "label": "MODEL",
+        "kind": 5,
+        "importPath": "mcp_server.tools.lesson_tools",
+        "description": "mcp_server.tools.lesson_tools",
+        "peekOfCode": "MODEL = GeminiFlash()\[email protected]()\nasync def generate_lesson_tool(topic: str, grade_level: int, duration_minutes: int) -> dict:\n    \"\"\"\n    Generate a lesson plan for the given topic, grade level, and duration, fully LLM-driven.\n    Use Gemini to generate a JSON object with objectives, activities, materials, assessment, differentiation, and homework.\n    \"\"\"\n    prompt = (\n        f\"Generate a detailed lesson plan as a JSON object for the topic '{topic}', grade {grade_level}, duration {duration_minutes} minutes. \"\n        f\"Include fields: objectives (list), activities (list), materials (list), assessment (dict), differentiation (dict), and homework (dict).\"",
+        "detail": "mcp_server.tools.lesson_tools",
+        "documentation": {}
+    },
+    {
+        "label": "MODEL",
+        "kind": 5,
+        "importPath": "mcp_server.tools.ocr_tools",
+        "description": "mcp_server.tools.ocr_tools",
+        "peekOfCode": "MODEL = GeminiFlash()\nasync def mistral_ocr_request(document_url: str) -> dict:\n    \"\"\"\n    Send OCR request to Mistral OCR service using document URL.\n    Args:\n        document_url: URL of the document to process\n    Returns:\n        OCR response from Mistral\n    \"\"\"\n    try:",
+        "detail": "mcp_server.tools.ocr_tools",
+        "documentation": {}
+    },
+    {
+        "label": "result",
+        "kind": 5,
+        "importPath": "mcp_server.tools.ocr_tools",
+        "description": "mcp_server.tools.ocr_tools",
+        "peekOfCode": "result = await mistral_document_ocr(\"https://example.com/document.pdf\")\n# For image document  \nresult = await mistral_document_ocr(\"https://example.com/image.jpg\")\n\"\"\"",
+        "detail": "mcp_server.tools.ocr_tools",
+        "documentation": {}
+    },
+    {
+        "label": "result",
+        "kind": 5,
+        "importPath": "mcp_server.tools.ocr_tools",
+        "description": "mcp_server.tools.ocr_tools",
+        "peekOfCode": "result = await mistral_document_ocr(\"https://example.com/image.jpg\")\n\"\"\"",
+        "detail": "mcp_server.tools.ocr_tools",
+        "documentation": {}
+    },
+    {
+        "label": "PROMPT_TEMPLATE",
+        "kind": 5,
+        "importPath": "mcp_server.tools.quiz_tools",
+        "description": "mcp_server.tools.quiz_tools",
+        "peekOfCode": "PROMPT_TEMPLATE = (Path(__file__).parent.parent / \"prompts\" / \"quiz_generation.txt\").read_text(encoding=\"utf-8\")\n# Initialize Gemini model\nMODEL = GeminiFlash()\[email protected]()\nasync def generate_quiz_tool(concept: str, difficulty: str = \"medium\") -> dict:\n    \"\"\"\n    Generate a quiz based on a concept and difficulty using Gemini, fully LLM-driven.\n    The JSON should include a list of questions, each with options and the correct answer.\n    \"\"\"\n    try:",
+        "detail": "mcp_server.tools.quiz_tools",
+        "documentation": {}
+    },
+    {
+        "label": "MODEL",
+        "kind": 5,
+        "importPath": "mcp_server.tools.quiz_tools",
+        "description": "mcp_server.tools.quiz_tools",
+        "peekOfCode": "MODEL = GeminiFlash()\[email protected]()\nasync def generate_quiz_tool(concept: str, difficulty: str = \"medium\") -> dict:\n    \"\"\"\n    Generate a quiz based on a concept and difficulty using Gemini, fully LLM-driven.\n    The JSON should include a list of questions, each with options and the correct answer.\n    \"\"\"\n    try:\n        if not concept or not isinstance(concept, str):\n            return {\"error\": \"concept must be a non-empty string\"}",
+        "detail": "mcp_server.tools.quiz_tools",
+        "documentation": {}
+    },
+    {
+        "label": "upload_to_azure",
+        "kind": 2,
+        "importPath": "mcp_server.utils.azure_upload",
+        "description": "mcp_server.utils.azure_upload",
+        "peekOfCode": "def upload_to_azure(file_path: str, content_type: str = None) -> str:\n    \"\"\"\n    Upload a file to Azure Blob Storage and return the public URL.\n    Args:\n        file_path: Path to the file to upload.\n        content_type: Optional MIME type (e.g., 'application/pdf'). If not provided, guessed from extension.\n    Returns:\n        The public URL of the uploaded blob.\n    \"\"\"\n    if not AZURE_CONNECTION_STRING or not AZURE_CONTAINER_NAME:",
+        "detail": "mcp_server.utils.azure_upload",
+        "documentation": {}
+    },
+    {
+        "label": "AZURE_CONNECTION_STRING",
+        "kind": 5,
+        "importPath": "mcp_server.utils.azure_upload",
+        "description": "mcp_server.utils.azure_upload",
+        "peekOfCode": "AZURE_CONNECTION_STRING = os.getenv(\"AZURE_CONNECTION_STRING\")\nAZURE_CONTAINER_NAME = os.getenv(\"AZURE_CONTAINER_NAME\")\ndef upload_to_azure(file_path: str, content_type: str = None) -> str:\n    \"\"\"\n    Upload a file to Azure Blob Storage and return the public URL.\n    Args:\n        file_path: Path to the file to upload.\n        content_type: Optional MIME type (e.g., 'application/pdf'). If not provided, guessed from extension.\n    Returns:\n        The public URL of the uploaded blob.",
+        "detail": "mcp_server.utils.azure_upload",
+        "documentation": {}
+    },
+    {
+        "label": "AZURE_CONTAINER_NAME",
+        "kind": 5,
+        "importPath": "mcp_server.utils.azure_upload",
+        "description": "mcp_server.utils.azure_upload",
+        "peekOfCode": "AZURE_CONTAINER_NAME = os.getenv(\"AZURE_CONTAINER_NAME\")\ndef upload_to_azure(file_path: str, content_type: str = None) -> str:\n    \"\"\"\n    Upload a file to Azure Blob Storage and return the public URL.\n    Args:\n        file_path: Path to the file to upload.\n        content_type: Optional MIME type (e.g., 'application/pdf'). If not provided, guessed from extension.\n    Returns:\n        The public URL of the uploaded blob.\n    \"\"\"",
+        "detail": "mcp_server.utils.azure_upload",
+        "documentation": {}
+    },
+    {
+        "label": "mcp",
+        "kind": 5,
+        "importPath": "mcp_server.mcp_instance",
+        "description": "mcp_server.mcp_instance",
+        "peekOfCode": "mcp = FastMCP(\n    \"TutorX\",\n    dependencies=[\"mcp[cli]>=1.9.3\"],\n    cors_origins=[\"*\"]\n)",
+        "detail": "mcp_server.mcp_instance",
+        "documentation": {}
+    },
+    {
+        "label": "current_dir",
+        "kind": 5,
+        "importPath": "mcp_server.server",
+        "description": "mcp_server.server",
+        "peekOfCode": "current_dir = Path(__file__).parent\nsys.path.insert(0, str(current_dir))\nimport uvicorn\nfrom fastapi import FastAPI, HTTPException, UploadFile, File, Form\nfrom fastapi.middleware.cors import CORSMiddleware\nfrom mcp.server.fastmcp import FastMCP\n# Import all tools to register them with MCP\nfrom tools import (\n    concept_tools,\n    lesson_tools,",
+        "detail": "mcp_server.server",
+        "documentation": {}
+    },
+    {
+        "label": "api_app",
+        "kind": 5,
+        "importPath": "mcp_server.server",
+        "description": "mcp_server.server",
+        "peekOfCode": "api_app = FastAPI(\n    title=\"TutorX MCP Server\",\n    description=\"Model Context Protocol server for TutorX educational platform\",\n    version=\"1.0.0\"\n)\n# Add CORS middleware\napi_app.add_middleware(\n    CORSMiddleware,\n    allow_origins=[\"*\"],\n    allow_credentials=True,",
+        "detail": "mcp_server.server",
+        "documentation": {}
+    },
+    {
+        "label": "TestTutorXClient",
+        "kind": 6,
+        "importPath": "tests.test_client",
+        "description": "tests.test_client",
+        "peekOfCode": "class TestTutorXClient(unittest.TestCase):\n    \"\"\"Test cases for the TutorX MCP client\"\"\"\n    def setUp(self):\n        \"\"\"Set up test fixtures\"\"\"\n        self.client = TutorXClient(\"http://localhost:8000\")\n        self.student_id = \"test_student_123\"\n        self.concept_id = \"math_algebra_basics\"\n    @patch('client.requests.post')\n    def test_call_tool(self, mock_post):\n        \"\"\"Test _call_tool method\"\"\"",
+        "detail": "tests.test_client",
+        "documentation": {}
+    },
+    {
+        "label": "TestMCPServer",
+        "kind": 6,
+        "importPath": "tests.test_mcp_server",
+        "description": "tests.test_mcp_server",
+        "peekOfCode": "class TestMCPServer(unittest.TestCase):\n    \"\"\"Test cases for the TutorX MCP server\"\"\"\n    def setUp(self):\n        \"\"\"Set up test fixtures\"\"\"\n        self.student_id = \"test_student_123\"\n        self.concept_id = \"math_algebra_basics\"\n    def test_assess_skill(self):\n        \"\"\"Test assess_skill tool\"\"\"\n        result = assess_skill(self.student_id, self.concept_id)\n        # Verify the structure of the result",
+        "detail": "tests.test_mcp_server",
+        "documentation": {}
+    },
+    {
+        "label": "SERVER_URL",
+        "kind": 5,
+        "importPath": "tests.test_tools_integration",
+        "description": "tests.test_tools_integration",
+        "peekOfCode": "SERVER_URL = \"http://localhost:8000/sse\"  # Adjust if needed\[email protected]\nasync def test_get_concept_graph_tool():\n    async with sse_client(SERVER_URL) as (sse, write):\n        async with ClientSession(sse, write) as session:\n            await session.initialize()\n            result = await session.call_tool(\"get_concept_graph_tool\", {\"concept_id\": \"python\"})\n            assert result and \"error\" not in result\[email protected]\nasync def test_generate_quiz_tool():",
+        "detail": "tests.test_tools_integration",
+        "documentation": {}
+    },
+    {
+        "label": "TestMultimodalUtils",
+        "kind": 6,
+        "importPath": "tests.test_utils",
+        "description": "tests.test_utils",
+        "peekOfCode": "class TestMultimodalUtils(unittest.TestCase):\n    \"\"\"Test cases for multimodal utility functions\"\"\"\n    def test_process_text_query(self):\n        \"\"\"Test text query processing\"\"\"\n        # Test with a \"solve\" query\n        solve_query = \"Please solve this equation: 2x + 3 = 7\"\n        result = process_text_query(solve_query)\n        self.assertIsInstance(result, dict)\n        self.assertEqual(result[\"query\"], solve_query)\n        self.assertEqual(result[\"response_type\"], \"math_solution\")",
+        "detail": "tests.test_utils",
+        "documentation": {}
+    },
+    {
+        "label": "TestAssessmentUtils",
+        "kind": 6,
+        "importPath": "tests.test_utils",
+        "description": "tests.test_utils",
+        "peekOfCode": "class TestAssessmentUtils(unittest.TestCase):\n    \"\"\"Test cases for assessment utility functions\"\"\"\n    def test_generate_question_algebra_basics(self):\n        \"\"\"Test question generation for algebra basics\"\"\"\n        concept_id = \"math_algebra_basics\"\n        difficulty = 2\n        question = generate_question(concept_id, difficulty)\n        self.assertIsInstance(question, dict)\n        self.assertIn(\"id\", question)\n        self.assertEqual(question[\"concept_id\"], concept_id)",
+        "detail": "tests.test_utils",
+        "documentation": {}
+    },
+    {
+        "label": "upload_to_azure",
+        "kind": 2,
+        "importPath": "utils.azure_upload",
+        "description": "utils.azure_upload",
+        "peekOfCode": "def upload_to_azure(file_path: str, content_type: str = None) -> str:\n    \"\"\"\n    Upload a file to Azure Blob Storage and return the public URL.\n    Args:\n        file_path: Path to the file to upload.\n        content_type: Optional MIME type (e.g., 'application/pdf'). If not provided, guessed from extension.\n    Returns:\n        The public URL of the uploaded blob.\n    \"\"\"\n    if not AZURE_CONNECTION_STRING or not AZURE_CONTAINER_NAME:",
+        "detail": "utils.azure_upload",
+        "documentation": {}
+    },
+    {
+        "label": "AZURE_CONNECTION_STRING",
+        "kind": 5,
+        "importPath": "utils.azure_upload",
+        "description": "utils.azure_upload",
+        "peekOfCode": "AZURE_CONNECTION_STRING = os.getenv(\"AZURE_CONNECTION_STRING\")\nAZURE_CONTAINER_NAME = os.getenv(\"AZURE_CONTAINER_NAME\")\ndef upload_to_azure(file_path: str, content_type: str = None) -> str:\n    \"\"\"\n    Upload a file to Azure Blob Storage and return the public URL.\n    Args:\n        file_path: Path to the file to upload.\n        content_type: Optional MIME type (e.g., 'application/pdf'). If not provided, guessed from extension.\n    Returns:\n        The public URL of the uploaded blob.",
+        "detail": "utils.azure_upload",
+        "documentation": {}
+    },
+    {
+        "label": "AZURE_CONTAINER_NAME",
+        "kind": 5,
+        "importPath": "utils.azure_upload",
+        "description": "utils.azure_upload",
+        "peekOfCode": "AZURE_CONTAINER_NAME = os.getenv(\"AZURE_CONTAINER_NAME\")\ndef upload_to_azure(file_path: str, content_type: str = None) -> str:\n    \"\"\"\n    Upload a file to Azure Blob Storage and return the public URL.\n    Args:\n        file_path: Path to the file to upload.\n        content_type: Optional MIME type (e.g., 'application/pdf'). If not provided, guessed from extension.\n    Returns:\n        The public URL of the uploaded blob.\n    \"\"\"",
+        "detail": "utils.azure_upload",
+        "documentation": {}
+    },
+    {
+        "label": "SERVER_URL",
+        "kind": 5,
+        "importPath": "app",
+        "description": "app",
+        "peekOfCode": "SERVER_URL = \"http://localhost:8000/sse\"  # Ensure this is the SSE endpoint\n# Utility functions\nasync def load_concept_graph(concept_id: str = None):\n    \"\"\"\n    Load and visualize the concept graph for a given concept ID.\n    If no concept_id is provided, returns the first available concept.\n    Uses call_resource for concept graph retrieval (not a tool).\n    Returns:\n        tuple: (figure, concept_details, related_concepts) or (None, error_dict, [])\n    \"\"\"",
+        "detail": "app",
+        "documentation": {}
+    },
+    {
+        "label": "run_server",
+        "kind": 2,
+        "importPath": "main",
+        "description": "main",
+        "peekOfCode": "def run_server():\n    \"\"\"Run the MCP server with the configured settings.\"\"\"\n    print(f\"Starting TutorX MCP server on {SERVER_HOST}:{SERVER_PORT}...\")\n    print(f\"MCP transport: {SERVER_TRANSPORT}\")\n    print(f\"API docs: http://{SERVER_HOST}:{SERVER_PORT}/docs\")\n    print(f\"MCP endpoint: http://{SERVER_HOST}:{SERVER_PORT}/mcp\")\n    # Configure uvicorn to run the FastAPI app\n    uvicorn.run(\n        \"server:api_app\",\n        host=SERVER_HOST,",
+        "detail": "main",
+        "documentation": {}
+    },
+    {
+        "label": "SERVER_HOST",
+        "kind": 5,
+        "importPath": "main",
+        "description": "main",
+        "peekOfCode": "SERVER_HOST = os.getenv(\"MCP_HOST\", \"0.0.0.0\")\nSERVER_PORT = int(os.getenv(\"MCP_PORT\", \"8001\"))\nSERVER_TRANSPORT = os.getenv(\"MCP_TRANSPORT\", \"sse\")\ndef run_server():\n    \"\"\"Run the MCP server with the configured settings.\"\"\"\n    print(f\"Starting TutorX MCP server on {SERVER_HOST}:{SERVER_PORT}...\")\n    print(f\"MCP transport: {SERVER_TRANSPORT}\")\n    print(f\"API docs: http://{SERVER_HOST}:{SERVER_PORT}/docs\")\n    print(f\"MCP endpoint: http://{SERVER_HOST}:{SERVER_PORT}/mcp\")\n    # Configure uvicorn to run the FastAPI app",
+        "detail": "main",
+        "documentation": {}
+    },
+    {
+        "label": "SERVER_PORT",
+        "kind": 5,
+        "importPath": "main",
+        "description": "main",
+        "peekOfCode": "SERVER_PORT = int(os.getenv(\"MCP_PORT\", \"8001\"))\nSERVER_TRANSPORT = os.getenv(\"MCP_TRANSPORT\", \"sse\")\ndef run_server():\n    \"\"\"Run the MCP server with the configured settings.\"\"\"\n    print(f\"Starting TutorX MCP server on {SERVER_HOST}:{SERVER_PORT}...\")\n    print(f\"MCP transport: {SERVER_TRANSPORT}\")\n    print(f\"API docs: http://{SERVER_HOST}:{SERVER_PORT}/docs\")\n    print(f\"MCP endpoint: http://{SERVER_HOST}:{SERVER_PORT}/mcp\")\n    # Configure uvicorn to run the FastAPI app\n    uvicorn.run(",
+        "detail": "main",
+        "documentation": {}
+    },
+    {
+        "label": "SERVER_TRANSPORT",
+        "kind": 5,
+        "importPath": "main",
+        "description": "main",
+        "peekOfCode": "SERVER_TRANSPORT = os.getenv(\"MCP_TRANSPORT\", \"sse\")\ndef run_server():\n    \"\"\"Run the MCP server with the configured settings.\"\"\"\n    print(f\"Starting TutorX MCP server on {SERVER_HOST}:{SERVER_PORT}...\")\n    print(f\"MCP transport: {SERVER_TRANSPORT}\")\n    print(f\"API docs: http://{SERVER_HOST}:{SERVER_PORT}/docs\")\n    print(f\"MCP endpoint: http://{SERVER_HOST}:{SERVER_PORT}/mcp\")\n    # Configure uvicorn to run the FastAPI app\n    uvicorn.run(\n        \"server:api_app\",",
+        "detail": "main",
+        "documentation": {}
+    },
+    {
+        "label": "run_mcp_server",
+        "kind": 2,
+        "importPath": "run",
+        "description": "run",
+        "peekOfCode": "def run_mcp_server(host=\"0.0.0.0\", port=8001):\n    \"\"\"\n    Run the MCP server using uvicorn\n    Args:\n        host: Host to bind the server to\n        port: Port to run the server on\n    \"\"\"\n    print(f\"Starting TutorX MCP Server on {host}:{port}...\")\n    # Set environment variables\n    os.environ[\"MCP_HOST\"] = host",
+        "detail": "run",
+        "documentation": {}
+    },
+    {
+        "label": "run_gradio_interface",
+        "kind": 2,
+        "importPath": "run",
+        "description": "run",
+        "peekOfCode": "def run_gradio_interface(port=7860):\n    \"\"\"\n    Run the Gradio interface\n    Args:\n        port: Port to run the Gradio interface on\n    \"\"\"\n    print(f\"Starting TutorX Gradio Interface on port {port}...\")\n    try:\n        # Make sure the mcp-server directory is in the path\n        mcp_server_dir = str(Path(__file__).parent / \"mcp-server\")",
+        "detail": "run",
+        "documentation": {}
+    },
+    {
+        "label": "check_port_available",
+        "kind": 2,
+        "importPath": "run",
+        "description": "run",
+        "peekOfCode": "def check_port_available(port):\n    \"\"\"\n    Check if a port is available\n    Args:\n        port: Port number to check\n    Returns:\n        bool: True if port is available, False otherwise\n    \"\"\"\n    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:\n        return s.connect_ex(('localhost', port)) != 0",
+        "detail": "run",
+        "documentation": {}
+    },
+    {
+        "label": "run_tests",
+        "kind": 2,
+        "importPath": "run_tests",
+        "description": "run_tests",
+        "peekOfCode": "def run_tests():\n    \"\"\"Run all tests\"\"\"\n    print(\"Running TutorX-MCP Tests...\")\n    # First run unittest tests\n    unittest_loader = unittest.TestLoader()\n    test_directory = os.path.join(os.path.dirname(__file__), \"tests\")\n    test_suite = unittest_loader.discover(test_directory)\n    test_runner = unittest.TextTestRunner(verbosity=2)\n    unittest_result = test_runner.run(test_suite)\n    # Then run pytest tests (with coverage)",
+        "detail": "run_tests",
+        "documentation": {}
+    }
+]

app.py

@@ -37,8 +37,7 @@ async def load_concept_graph(concept_id: str = None):
         async with sse_client(SERVER_URL) as (sse, write):
             async with ClientSession(sse, write) as session:
                 await session.initialize()
-                # Use MCP resource call for concept graph
-                result = await session.call_resource("resources/read", {"uri": f"concept-graph://{concept_id}" if concept_id else "concept-graph://"})
+                result = await session.call_tool("get_concept_graph_tool", {"concept_id": concept_id} if concept_id else {})
                 print(f"[DEBUG] Server response: {result}")
                 if not result or not isinstance(result, dict):
                     error_msg = "Invalid server response"
@@ -68,16 +67,18 @@ async def load_concept_graph(concept_id: str = None):
                 related_concepts = []
                 if "related" in concept:
                     for rel_id in concept["related"]:
-                        rel_result = await session.call_tool("get_concept_graph", {"concept_id": rel_id})
+                        rel_result = await session.call_tool("get_concept_graph_tool", {"concept_id": rel_id})
                         if "error" not in rel_result:
-                            G.add_node(rel_id, label=rel_result["name"], type="related")
+                            rel_concept = rel_result.get("concept", {})
+                            G.add_node(rel_id, label=rel_concept.get("name", rel_id), type="related")
                             G.add_edge(concept["id"], rel_id, relationship="related_to")
-                            related_concepts.append([rel_id, rel_result.get("name", ""), rel_result.get("description", "")])
+                            related_concepts.append([rel_id, rel_concept.get("name", ""), rel_concept.get("description", "")])
                 if "prerequisites" in concept:
                     for prereq_id in concept["prerequisites"]:
-                        prereq_result = await session.call_tool("get_concept_graph", {"concept_id": prereq_id})
+                        prereq_result = await session.call_tool("get_concept_graph_tool", {"concept_id": prereq_id})
                         if "error" not in prereq_result:
-                            G.add_node(prereq_id, label=prereq_result["name"], type="prerequisite")
+                            prereq_concept = prereq_result.get("concept", {})
+                            G.add_node(prereq_id, label=prereq_concept.get("name", prereq_id), type="prerequisite")
                             G.add_edge(prereq_id, concept["id"], relationship="prerequisite_for")
                 plt.figure(figsize=(10, 8))
                 pos = nx.spring_layout(G)
@@ -97,13 +98,7 @@ async def load_concept_graph(concept_id: str = None):
                 nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=8)
                 plt.title(f"Concept Graph: {concept.get('name', concept_id)}")
                 plt.axis("off")
-                concept_details = {
-                    "id": concept.get("id", ""),
-                    "name": concept.get("name", ""),
-                    "description": concept.get("description", ""),
-                    "related_concepts_count": len(concept.get("related", [])),
-                    "prerequisites_count": len(concept.get("prerequisites", []))
-                }
+                concept_details = concept
                 return plt.gcf(), concept_details, related_concepts
     except Exception as e:
         import traceback
@@ -129,10 +124,11 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                 gr.Markdown("## Concept Graph Visualization")
                 with gr.Row():
                     with gr.Column(scale=3):
-                        concept_id = gr.Dropdown(
-                            label="Select a Concept",
-                            choices=["python", "functions", "oop", "data_structures"],
-                            value="python",
+                        # Change from dropdown to textbox for concept input
+                        concept_input_box = gr.Textbox(
+                            label="Enter Concept Name",
+                            placeholder="e.g., python, functions, oop, data_structures",
+                            lines=1,
                             interactive=True
                         )
                         load_concept_btn = gr.Button("Load Concept Graph", variant="primary")
@@ -154,14 +150,14 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                 # Button click handler
                 load_concept_btn.click(
                     fn=load_concept_graph,
-                    inputs=[concept_id],
+                    inputs=[concept_input_box],
                     outputs=[graph_output, concept_details, related_concepts]
                 )
                 
                 # Load default concept on tab click
                 concept_graph_tab.load(
                     fn=load_concept_graph,
-                    inputs=[concept_id],
+                    inputs=[concept_input_box],
                     outputs=[graph_output, concept_details, related_concepts]
                 )
             
@@ -196,7 +192,6 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                         difficulty = max(1, min(5, difficulty))
                     except (ValueError, TypeError):
                         difficulty = 3
-                    # Map numeric difficulty to string
                     if difficulty <= 2:
                         difficulty_str = "easy"
                     elif difficulty == 3:
@@ -247,59 +242,32 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                 outputs=[lesson_output]
             )
             
-            gr.Markdown("## Curriculum Standards")
-            
+            gr.Markdown("## Learning Path Generation")
             with gr.Row():
                 with gr.Column():
-                    country_input = gr.Dropdown(
-                        choices=["US", "UK"],
-                        label="Country",
-                        value="US"
-                    )
-                    standards_btn = gr.Button("Get Standards")
-                
+                    lp_student_id = gr.Textbox(label="Student ID", value=student_id)
+                    lp_concept_ids = gr.Textbox(label="Concept IDs (comma-separated)", placeholder="e.g., python,functions,oop")
+                    lp_student_level = gr.Dropdown(choices=["beginner", "intermediate", "advanced"], value="beginner", label="Student Level")
+                    lp_btn = gr.Button("Generate Learning Path")
                 with gr.Column():
-                    standards_output = gr.JSON(label="Curriculum Standards")
-            
-            async def get_standards_async(country):
+                    lp_output = gr.JSON(label="Learning Path")
+            async def on_generate_learning_path(student_id, concept_ids, student_level):
                 try:
-                    # Convert display text to lowercase for the API
-                    country_code = country.lower()
                     async with sse_client(SERVER_URL) as (sse, write):
                         async with ClientSession(sse, write) as session:
                             await session.initialize()
-                            response = await session.call_tool("get_curriculum_standards", {"country_code": country_code})
-                            
-                            # Format the response for better display
-                            if "standards" in response:
-                                formatted = {
-                                    "country": response["standards"]["name"],
-                                    "subjects": {},
-                                    "website": response["standards"].get("website", "")
-                                }
-                                
-                                # Format subjects and domains
-                                for subj_key, subj_info in response["standards"]["subjects"].items():
-                                    formatted["subjects"][subj_key] = {
-                                        "description": subj_info["description"],
-                                        "domains": subj_info["domains"]
-                                    }
-                                
-                                # Add grade levels or key stages if available
-                                if "grade_levels" in response["standards"]:
-                                    formatted["grade_levels"] = response["standards"]["grade_levels"]
-                                elif "key_stages" in response["standards"]:
-                                    formatted["key_stages"] = response["standards"]["key_stages"]
-                                    
-                                return formatted
-                            return response
+                            result = await session.call_tool("get_learning_path", {
+                                "student_id": student_id,
+                                "concept_ids": [c.strip() for c in concept_ids.split(",") if c.strip()],
+                                "student_level": student_level
+                            })
+                            return result
                 except Exception as e:
-                    return {"error": f"Failed to fetch standards: {str(e)}"}
-                
-            standards_btn.click(
-                fn=get_standards_async,
-                inputs=[country_input],
-                outputs=[standards_output]
+                    return {"error": str(e)}
+            lp_btn.click(
+                fn=on_generate_learning_path,
+                inputs=[lp_student_id, lp_concept_ids, lp_student_level],
+                outputs=[lp_output]
             )
         
         # Tab 3: Multi-Modal Interaction
@@ -326,40 +294,59 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                 outputs=[text_output]
             )
             
-            gr.Markdown("## PDF OCR and Summarization (Coming Soon)")
+            # Document OCR (PDF, images, etc.)
+            gr.Markdown("## Document OCR & LLM Analysis")
             with gr.Row():
                 with gr.Column():
-                    pdf_input = gr.File(label="Upload PDF", file_types=[".pdf"])
-                    ocr_btn = gr.Button("Extract Text")
-                
+                    doc_input = gr.File(label="Upload PDF or Document", file_types=[".pdf", ".jpg", ".jpeg", ".png"])
+                    doc_ocr_btn = gr.Button("Extract Text & Analyze")
                 with gr.Column():
-                    summary_output = gr.JSON(label="Summary")
-            
-            async def pdf_ocr_async(pdf_file):
-                if not pdf_file:
-                    return {"error": "No PDF file provided", "success": False}
+                    doc_output = gr.JSON(label="Document OCR & LLM Analysis")
+            async def upload_file_to_storage(file_path):
+                """Helper function to upload file to storage API"""
                 try:
-                    # Get the file path from the Gradio file object
-                    if isinstance(pdf_file, dict):
-                        file_path = pdf_file.get("path", "")
+                    url = "https://storage-bucket-api.vercel.app/upload"
+                    with open(file_path, 'rb') as f:
+                        files = {'file': (os.path.basename(file_path), f)}
+                        response = requests.post(url, files=files)
+                        response.raise_for_status()
+                        return response.json()
+                except Exception as e:
+                    return {"error": f"Error uploading file to storage: {str(e)}", "success": False}
+
+            async def document_ocr_async(file):
+                if not file:
+                    return {"error": "No file provided", "success": False}
+                try:
+                    if isinstance(file, dict):
+                        file_path = file.get("path", "")
                     else:
-                        file_path = pdf_file
-                    
+                        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("pdf_ocr", {"pdf_file": file_path})
+                            response = await session.call_tool("mistral_document_ocr", {"document_url": storage_url})
                             return response
                 except Exception as e:
-                    return {"error": f"Error processing PDF: {str(e)}", "success": False}
-                
-            ocr_btn.click(
-                fn=pdf_ocr_async,
-                inputs=[pdf_input],
-                outputs=[summary_output]
+                    return {"error": f"Error processing document: {str(e)}", "success": False}
+            doc_ocr_btn.click(
+                fn=document_ocr_async,
+                inputs=[doc_input],
+                outputs=[doc_output]
             )
         
         # Tab 4: Analytics
@@ -387,7 +374,7 @@ with gr.Blocks(title="TutorX Educational AI", theme=gr.themes.Soft()) as demo:
                 async with sse_client(SERVER_URL) as (sse, write):
                     async with ClientSession(sse, write) as session:
                         await session.initialize()
-                        response = await session.call_tool("check_submission_originality", {"submission": submission, "reference_sources": reference})
+                        response = await session.call_tool("check_submission_originality", {"submission": submission, "reference_sources": [reference] if isinstance(reference, str) else reference})
                         return response
                 
             plagiarism_btn.click(

mcp_server/server.py

@@ -110,22 +110,43 @@ async def check_originality_endpoint(request: dict):
         raise HTTPException(status_code=400, detail="submission (string) and reference_sources (array) are required")
     return await interaction_tools.check_submission_originality(submission, reference_sources)
 
-# API endpoints - PDF OCR
-@api_app.post("/api/pdf-ocr")
-async def pdf_ocr_endpoint(
-    file: UploadFile = File(...),
-    filename: str = Form(None)
+# API endpoints - Document OCR
+@api_app.post("/api/document-ocr")
+async def document_ocr_endpoint(
+    file: UploadFile = File(...)
 ):
     try:
-        pdf_data = await file.read()
-        pdf_b64 = base64.b64encode(pdf_data).decode('utf-8')
-        result = await ocr_tools.pdf_ocr({
-            "pdf_data": pdf_b64,
-            "filename": filename or file.filename
-        })
-        return result
+        # Save the uploaded file to a temporary location
+        import tempfile
+        import os
+        
+        # Get the file extension
+        file_extension = os.path.splitext(file.filename)[1].lower()
+        
+        # Create a temporary file with the same extension
+        with tempfile.NamedTemporaryFile(delete=False, suffix=file_extension) as temp_file:
+            content = await file.read()
+            temp_file.write(content)
+            temp_file_path = temp_file.name
+        
+        try:
+            # Upload the file to storage and get the URL
+            from mcp_server.utils.azure_upload import upload_to_azure
+            document_url = upload_to_azure(temp_file_path)
+            
+            # Process the document with OCR
+            result = await ocr_tools.mistral_document_ocr(document_url)
+            return result
+            
+        finally:
+            # Clean up the temporary file
+            try:
+                os.unlink(temp_file_path)
+            except:
+                pass
+                
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"Error processing document: {str(e)}")
 
 # API endpoints - Learning Path
 @api_app.post("/api/learning-path")

mcp_server/tools/__init__.py

@@ -10,7 +10,7 @@ from .concept_graph_tools import get_concept_graph_tool  # noqa
 from .lesson_tools import generate_lesson_tool  # noqa
 from .quiz_tools import generate_quiz_tool  # noqa
 from .interaction_tools import text_interaction, check_submission_originality  # noqa
-from .ocr_tools import pdf_ocr, image_to_text  # noqa
+from .ocr_tools import mistral_document_ocr  # noqa
 from .learning_path_tools import get_learning_path  # noqa
 
 __all__ = [
@@ -30,8 +30,7 @@ __all__ = [
     'check_submission_originality',
     
     # OCR tools
-    'pdf_ocr',
-    'image_to_text',
+    'mistral_document_ocr',
     
     # Learning path tools
     'get_learning_path',

mcp_server/tools/concept_graph_tools.py

@@ -5,6 +5,7 @@ from typing import Dict, Any, Optional
 import sys
 import os
 from pathlib import Path
+import json
 
 # Add the parent directory to the Python path
 current_dir = Path(__file__).parent
@@ -25,22 +26,29 @@ from resources import concept_graph
 
 # Import MCP
 from mcp_server.mcp_instance import mcp
+from mcp_server.model.gemini_flash import GeminiFlash
+
+MODEL = GeminiFlash()
 
 @mcp.tool()
-async def get_concept_graph_tool(concept_id: Optional[str] = None) -> Dict[str, Any]:
+async def get_concept_graph_tool(concept_id: Optional[str] = None) -> dict:
     """
-    Get the complete concept graph or a specific concept.
-    
-    Args:
-        concept_id: Optional concept ID to get a specific concept
-        
-    Returns:
-        Dictionary containing the concept graph or a specific concept
+    Get the complete concept graph or a specific concept, fully LLM-driven.
+    For a specific concept, use Gemini to generate a JSON object with explanation, related concepts, prerequisites, and summary.
+    For the full graph, use Gemini to generate a JSON object with a list of all concepts and their relationships.
     """
     if concept_id:
-        concept = concept_graph.get_concept(concept_id)
-        if not concept:
-            return {"error": f"Concept {concept_id} not found"}
-        return {"concept": concept}
-    
-    return {"concepts": list(concept_graph.get_concept_graph().values())}
+        prompt = (
+            f"Provide a JSON object for the concept '{concept_id}' with fields: explanation (string), related_concepts (list of strings), prerequisites (list of strings), and summary (string)."
+        )
+    else:
+        prompt = (
+            "Provide a JSON object with a list of all concepts in a knowledge graph. "
+            "Each concept should have fields: id, name, description, related_concepts (list), prerequisites (list)."
+        )
+    llm_response = await MODEL.generate_text(prompt)
+    try:
+        data = json.loads(llm_response)
+    except Exception:
+        data = {"llm_raw": llm_response, "error": "Failed to parse LLM output as JSON"}
+    return data

mcp_server/tools/concept_tools.py

@@ -7,6 +7,7 @@ from datetime import datetime, timezone
 import sys
 import os
 from pathlib import Path
+import json
 
 # Add the parent directory to the Python path
 current_dir = Path(__file__).parent
@@ -27,74 +28,42 @@ from resources.concept_graph import get_concept, get_all_concepts
 
 # Import MCP
 from mcp_server.mcp_instance import mcp
+from mcp_server.model.gemini_flash import GeminiFlash
+
+MODEL = GeminiFlash()
 
 @mcp.tool()
-async def get_concept_tool(concept_id: str = None) -> Dict[str, Any]:
+async def get_concept_tool(concept_id: str = None) -> dict:
     """
-    Get a specific concept or all concepts from the knowledge graph.
-    
-    Args:
-        concept_id: Optional concept ID to retrieve a specific concept
-        
-    Returns:
-        Dictionary containing the requested concept(s)
+    Get a specific concept or all concepts from the knowledge graph, fully LLM-driven.
+    If a concept_id is provided, use Gemini to generate a JSON object with explanation, key points, and example.
     """
-    if concept_id:
-        concept = get_concept(concept_id)
-        if not concept:
-            return {"error": f"Concept {concept_id} not found"}
-        return {"concept": concept}
-    return get_all_concepts()
+    if not concept_id:
+        return {"error": "concept_id is required for LLM-driven mode"}
+    prompt = (
+        f"Explain the concept '{concept_id}' in detail. "
+        f"Return a JSON object with fields: explanation (string), key_points (list of strings), and example (string)."
+    )
+    llm_response = await MODEL.generate_text(prompt)
+    try:
+        data = json.loads(llm_response)
+    except Exception:
+        data = {"llm_raw": llm_response, "error": "Failed to parse LLM output as JSON"}
+    return data
 
 @mcp.tool()
-async def assess_skill_tool(student_id: str, concept_id: str) -> Dict[str, Any]:
+async def assess_skill_tool(student_id: str, concept_id: str) -> dict:
     """
-    Assess a student's understanding of a specific concept.
-    
-    Args:
-        student_id: Unique identifier for the student
-        concept_id: ID of the concept to assess
-        
-    Returns:
-        Dictionary containing assessment results
+    Assess a student's understanding of a specific concept, fully LLM-driven.
+    Use Gemini to generate a JSON object with a score (0-1), feedback, and recommendations.
     """
-    # Get concept data
-    concept_data = get_concept(concept_id)
-    if not concept_data:
-        return {"error": f"Cannot assess skill: Concept {concept_id} not found"}
-    
-    concept_name = concept_data.get("name", concept_id)
-    
-    # Generate a score based on concept difficulty or random
-    score = random.uniform(0.2, 1.0)  # Random score between 0.2 and 1.0
-    
-    # Set timestamp with timezone
-    timestamp = datetime.now(timezone.utc).isoformat()
-    
-    # Generate feedback based on score
-    feedback = {
-        "strengths": [f"Good understanding of {concept_name} fundamentals"],
-        "areas_for_improvement": [f"Could work on advanced applications of {concept_name}"],
-        "recommendations": [
-            f"Review {concept_name} practice problems",
-            f"Watch tutorial videos on {concept_name}"
-        ]
-    }
-    
-    # Adjust feedback based on score
-    if score < 0.5:
-        feedback["strengths"] = [f"Basic understanding of {concept_name}"]
-        feedback["areas_for_improvement"] = [
-            f"Needs to strengthen fundamental knowledge of {concept_name}",
-            f"Practice more exercises on {concept_name}"
-        ]
-    
-    # Return assessment results
-    return {
-        "student_id": student_id,
-        "concept_id": concept_id,
-        "concept_name": concept_name,
-        "score": round(score, 2),  # Round to 2 decimal places
-        "timestamp": timestamp,
-        "feedback": feedback
-    }
+    prompt = (
+        f"A student (ID: {student_id}) is being assessed on the concept '{concept_id}'. "
+        f"Generate a JSON object with: score (float 0-1), feedback (string), and recommendations (list of strings)."
+    )
+    llm_response = await MODEL.generate_text(prompt)
+    try:
+        data = json.loads(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

@@ -5,123 +5,45 @@ import re
 from difflib import SequenceMatcher
 from typing import Dict, Any, List, Optional
 from mcp_server.mcp_instance import mcp
+from mcp_server.model.gemini_flash import GeminiFlash
+import json
+
+MODEL = GeminiFlash()
 
 def calculate_similarity(text1: str, text2: str) -> float:
     """Calculate the similarity ratio between two texts."""
-    return SequenceMatcher(None, text1, text2).ratio()
+    return 0.0  # No longer used, LLM-driven
 
 @mcp.tool()
-async def text_interaction(query: str, student_id: str) -> Dict[str, Any]:
+async def text_interaction(query: str, student_id: str) -> dict:
     """
-    Process a text query from a student and provide an educational response.
-    
-    Args:
-        query: The student's question or input text
-        student_id: Unique identifier for the student
-        
-    Returns:
-        Dictionary containing the response and metadata
+    Process a text query from a student and provide an educational response, fully LLM-driven.
+    Use Gemini to generate a JSON object with a response and suggested actions/resources.
     """
-    # Simple response generation based on keywords
-    query_lower = query.lower()
-    
-    # Check for greetings
-    if any(word in query_lower for word in ["hello", "hi", "hey"]):
-        return {
-            "response": f"Hello! I'm your TutorX assistant. How can I help you today, Student {student_id}?",
-            "suggested_actions": [
-                "Ask a question about programming",
-                "Request a lesson on a topic",
-                "Take a quiz"
-            ]
-        }
-    
-    # Check for help request
-    if "help" in query_lower or "confused" in query_lower:
-        return {
-            "response": "I'm here to help! Could you please tell me what specific topic or concept you're struggling with?",
-            "suggested_actions": [
-                "Explain functions in Python",
-                "What is object-oriented programming?",
-                "Help me debug my code"
-            ]
-        }
-    
-    # Default response for other queries
-    return {
-        "response": f"I understand you're asking about: {query}. Here's what I can tell you...",
-        "metadata": {
-            "student_id": student_id,
-            "query_type": "general_inquiry"
-        },
-        "suggested_resources": [
-            {"title": "Related Documentation", "url": "https://docs.python.org/3/"},
-            {"title": "Tutorial Video", "url": "https://www.youtube.com/"},
-            {"title": "Practice Exercises", "url": "https://www.hackerrank.com/"}
-        ]
-    }
+    prompt = (
+        f"A student (ID: {student_id}) asked: '{query}'. "
+        f"Return a JSON object with fields: response (string), suggested_actions (list of strings), and suggested_resources (list of strings)."
+    )
+    llm_response = await MODEL.generate_text(prompt)
+    try:
+        data = json.loads(llm_response)
+    except Exception:
+        data = {"llm_raw": llm_response, "error": "Failed to parse LLM output as JSON"}
+    return data
 
 @mcp.tool()
-async def check_submission_originality(submission: str, reference_sources: List[str]) -> Dict[str, Any]:
+async def check_submission_originality(submission: str, reference_sources: list) -> dict:
     """
-    Check a student's submission for potential plagiarism against reference sources.
-    
-    Args:
-        submission: The student's submission text
-        reference_sources: List of reference texts to check against
-        
-    Returns:
-        Dictionary with originality analysis results
+    Check a student's submission for potential plagiarism, fully LLM-driven.
+    Use Gemini to generate a JSON object with originality_score (0-1), is_original (bool), and recommendations (list of strings).
     """
-    if not submission or not reference_sources:
-        return {"error": "Both submission and reference_sources are required"}
-    
-    # Simple plagiarism check using string similarity
-    results = []
-    for i, source in enumerate(reference_sources, 1):
-        if not source:
-            continue
-            
-        similarity = calculate_similarity(submission, source)
-        results.append({
-            "source_index": i,
-            "similarity_score": round(similarity, 4),
-            "is_original": similarity < 0.7,  # Threshold for originality
-            "suspicious_sections": []
-        })
-    
-    # Check for exact matches
-    exact_matches = []
-    submission_words = submission.split()
-    for i in range(len(submission_words) - 4):  # Check 5-word sequences
-        seq = ' '.join(submission_words[i:i+5])
-        for j, source in enumerate(reference_sources):
-            if seq in source:
-                exact_matches.append({
-                    "source_index": j + 1,
-                    "matched_text": seq,
-                    "position": i
-                })
-    
-    # Calculate overall originality score (weighted average)
-    if results:
-        avg_similarity = sum(r["similarity_score"] for r in results) / len(results)
-        originality_score = max(0, 1 - avg_similarity)
-    else:
-        originality_score = 1.0
-    
-    return {
-        "originality_score": round(originality_score, 2),
-        "is_original": all(r["is_original"] for r in results) if results else True,
-        "sources_checked": len(reference_sources),
-        "source_comparisons": results,
-        "exact_matches": exact_matches,
-        "recommendations": [
-            "Paraphrase any sections with high similarity scores",
-            "Add proper citations for referenced material",
-            "Use your own words to explain concepts"
-        ] if any(not r["is_original"] for r in results) else [
-            "Good job! Your work appears to be original.",
-            "Remember to always cite your sources properly."
-        ]
-    }
+    prompt = (
+        f"Given the following student submission: '{submission}' and reference sources: {reference_sources}, "
+        f"return a JSON object with fields: originality_score (float 0-1), is_original (bool), and recommendations (list of strings)."
+    )
+    llm_response = await MODEL.generate_text(prompt)
+    try:
+        data = json.loads(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

@@ -7,6 +7,7 @@ from datetime import datetime, timedelta
 import sys
 import os
 from pathlib import Path
+import json
 
 # Add the parent directory to the Python path
 current_dir = Path(__file__).parent
@@ -27,6 +28,9 @@ from resources.concept_graph import CONCEPT_GRAPH
 
 # Import MCP
 from mcp_server.mcp_instance import mcp
+from mcp_server.model.gemini_flash import GeminiFlash
+
+MODEL = GeminiFlash()
 
 def get_prerequisites(concept_id: str, visited: Optional[set] = None) -> List[Dict[str, Any]]:
     """
@@ -143,20 +147,18 @@ def generate_learning_path(concept_ids: List[str], student_level: str = "beginne
     }
 
 @mcp.tool()
-async def get_learning_path(student_id: str, concept_ids: List[str], student_level: Optional[str] = None) -> Dict[str, Any]:
+async def get_learning_path(student_id: str, concept_ids: list, student_level: str = "beginner") -> dict:
     """
-    Generate a personalized learning path for a student.
-    
-    Args:
-        student_id: Unique identifier for the student
-        concept_ids: List of concept IDs to include in the learning path
-        student_level: Optional student level (beginner, intermediate, advanced)
-        
-    Returns:
-        Dictionary containing the learning path
+    Generate a personalized learning path for a student, fully LLM-driven.
+    Use Gemini to generate a JSON object with a list of steps, each with concept name, description, estimated time, and recommended resources.
     """
-    # In a real implementation, we would look up the student's level from their profile
-    if not student_level:
-        student_level = "beginner"  # Default level
-    
-    return generate_learning_path(concept_ids, student_level)
+    prompt = (
+        f"A student (ID: {student_id}) with level '{student_level}' needs a learning path for these concepts: {concept_ids}. "
+        f"Return a JSON object with a 'learning_path' field: a list of steps, each with concept_name, description, estimated_time_minutes, and resources (list)."
+    )
+    llm_response = await MODEL.generate_text(prompt)
+    try:
+        data = json.loads(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

@@ -3,121 +3,24 @@ Lesson generation tools for TutorX MCP.
 """
 from typing import Dict, Any, List
 from mcp_server.mcp_instance import mcp
+from mcp_server.model.gemini_flash import GeminiFlash
+import json
+
+MODEL = GeminiFlash()
 
 @mcp.tool()
-async def generate_lesson_tool(topic: str, grade_level: int, duration_minutes: int) -> Dict[str, Any]:
+async def generate_lesson_tool(topic: str, grade_level: int, duration_minutes: int) -> dict:
     """
-    Generate a lesson plan for the given topic, grade level, and duration.
-    
-    Args:
-        topic: The topic for the lesson
-        grade_level: The grade level (1-12)
-        duration_minutes: Duration of the lesson in minutes
-        
-    Returns:
-        Dictionary containing the generated lesson plan
+    Generate a lesson plan for the given topic, grade level, and duration, fully LLM-driven.
+    Use Gemini to generate a JSON object with objectives, activities, materials, assessment, differentiation, and homework.
     """
-    # Validate inputs
-    if not topic or not isinstance(topic, str):
-        return {"error": "Topic must be a non-empty string"}
-    
-    if not isinstance(grade_level, int) or grade_level < 1 or grade_level > 12:
-        return {"error": "Grade level must be an integer between 1 and 12"}
-    
-    if not isinstance(duration_minutes, (int, float)) or duration_minutes <= 0:
-        return {"error": "Duration must be a positive number"}
-    
-    # Calculate time allocation (example: 10% intro, 30% instruction, 40% practice, 20% review)
-    intro_time = max(5, duration_minutes * 0.1)  # At least 5 minutes
-    instruction_time = duration_minutes * 0.3
-    practice_time = duration_minutes * 0.4
-    review_time = duration_minutes - (intro_time + instruction_time + practice_time)
-    
-    # Generate learning objectives based on grade level and topic
-    difficulty = {
-        1: "basic",
-        2: "basic",
-        3: "basic",
-        4: "intermediate",
-        5: "intermediate",
-        6: "intermediate",
-        7: "advanced",
-        8: "advanced",
-        9: "advanced",
-        10: "expert",
-        11: "expert",
-        12: "expert"
-    }.get(grade_level, "intermediate")
-    
-    # Create lesson plan
-    lesson_plan = {
-        "topic": topic,
-        "grade_level": grade_level,
-        "duration_minutes": duration_minutes,
-        "difficulty": difficulty,
-        "objectives": [
-            f"Understand the {difficulty} concepts of {topic}",
-            f"Apply {topic} concepts to solve problems",
-            f"Analyze and evaluate {topic} in different contexts"
-        ],
-        "materials": [
-            "Whiteboard and markers",
-            "Printed worksheets",
-            "Example code snippets",
-            "Interactive coding environment"
-        ],
-        "activities": [
-            {
-                "type": "introduction",
-                "duration_minutes": intro_time,
-                "description": f"Introduce the topic of {topic} and its importance"
-            },
-            {
-                "type": "direct_instruction",
-                "duration_minutes": instruction_time,
-                "description": f"Teach the core concepts of {topic}"
-            },
-            {
-                "type": "guided_practice",
-                "duration_minutes": practice_time,
-                "description": "Work through examples together"
-            },
-            {
-                "type": "independent_practice",
-                "duration_minutes": practice_time,
-                "description": "Students work on exercises independently"
-            },
-            {
-                "type": "review",
-                "duration_minutes": review_time,
-                "description": "Review key concepts and answer questions"
-            }
-        ],
-        "assessment": {
-            "type": "formative",
-            "methods": ["Exit ticket", "Class participation", "Worksheet completion"]
-        },
-        "differentiation": {
-            "for_struggling_students": [
-                "Provide additional examples",
-                "Offer one-on-one support",
-                "Use visual aids"
-            ],
-            "for_advanced_students": [
-                "Provide extension activities",
-                "Challenge with advanced problems",
-                "Encourage to help peers"
-            ]
-        },
-        "homework": {
-            "description": f"Complete practice problems on {topic}",
-            "estimated_time_minutes": 20,
-            "resources": [
-                f"{topic} practice worksheet",
-                "Online practice problems",
-                "Reading assignment"
-            ]
-        }
-    }
-    
-    return lesson_plan
+    prompt = (
+        f"Generate a detailed lesson plan as a JSON object for the topic '{topic}', grade {grade_level}, duration {duration_minutes} minutes. "
+        f"Include fields: objectives (list), activities (list), materials (list), assessment (dict), differentiation (dict), and homework (dict)."
+    )
+    llm_response = await MODEL.generate_text(prompt)
+    try:
+        data = json.loads(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

@@ -1,166 +1,142 @@
 """
-OCR (Optical Character Recognition) tools for TutorX.
+OCR (Optical Character Recognition) tools for TutorX with Mistral OCR integration.
 """
-import base64
-import io
-import tempfile
-from typing import Dict, Any, Optional, Tuple
-# import fitz  # PyMuPDFuv run 
-import pytesseract
-from PIL import Image, ImageEnhance
-import numpy as np
+import os
+from typing import Dict, Any, Optional
 from mcp_server.mcp_instance import mcp
+from mcp_server.model.gemini_flash import GeminiFlash
+from mistralai import Mistral
 
-def preprocess_image(image: Image.Image) -> Image.Image:
-    """
-    Preprocess image to improve OCR accuracy.
-    
-    Args:
-        image: Input PIL Image
-        
-    Returns:
-        Preprocessed PIL Image
-    """
-    # Convert to grayscale
-    image = image.convert('L')
-    
-    # Enhance contrast
-    enhancer = ImageEnhance.Contrast(image)
-    image = enhancer.enhance(2.0)
-    
-    # Enhance sharpness
-    enhancer = ImageEnhance.Sharpness(image)
-    image = enhancer.enhance(2.0)
-    
-    return image
+# Initialize models
+MODEL = GeminiFlash()
+client = Mistral(api_key="5oHGQTYDGD3ecQZSqdLsr5ZL4nOsfGYj")
 
-def extract_text_from_image(image: Image.Image) -> str:
+async def mistral_ocr_request(document_url: str) -> dict:
     """
-    Extract text from an image using Tesseract OCR.
+    Send OCR request to Mistral OCR service using document URL.
     
     Args:
-        image: PIL Image to process
+        document_url: URL of the document to process
         
     Returns:
-        Extracted text
+        OCR response from Mistral
     """
     try:
-        # Preprocess the image
-        processed_image = preprocess_image(image)
+        # Process document with Mistral OCR
+        ocr_response = client.ocr.process(
+            model="mistral-ocr-latest",
+            document={
+                "type": "document_url",
+                "document_url": document_url
+            },
+            include_image_base64=True
+        )
         
-        # Use Tesseract to do OCR on the image
-        text = pytesseract.image_to_string(processed_image, lang='eng')
-        return text.strip()
-    except Exception as e:
-        raise RuntimeError(f"Error during OCR processing: {str(e)}")
-
-def extract_text_from_pdf(pdf_data: bytes) -> Tuple[str, int]:
-    """
-    Extract text from a PDF file.
-    
-    Args:
-        pdf_data: PDF file content as bytes
+        # Convert the response to a dictionary
+        if hasattr(ocr_response, 'model_dump'):
+            return ocr_response.model_dump()
+        return ocr_response or {}
         
-    Returns:
-        Tuple of (extracted_text, page_count)
-    """
-    try:
-        # Open the PDF file
-        with fitz.open(stream=pdf_data, filetype="pdf") as doc:
-            page_count = len(doc)
-            extracted_text = []
-            
-            # Extract text from each page
-            for page_num in range(page_count):
-                page = doc.load_page(page_num)
-                text = page.get_text()
-                
-                # If no text is found, try OCR
-                if not text.strip():
-                    pix = page.get_pixmap()
-                    img_data = pix.tobytes("png")
-                    img = Image.open(io.BytesIO(img_data))
-                    text = extract_text_from_image(img)
-                
-                extracted_text.append(text)
-            
-            return "\n\n".join(extracted_text), page_count
     except Exception as e:
-        raise RuntimeError(f"Error processing PDF: {str(e)}")
+        raise RuntimeError(f"Error processing document with Mistral OCR: {str(e)}")
 
 @mcp.tool()
-async def pdf_ocr(request: Dict[str, Any]) -> Dict[str, Any]:
+async def mistral_document_ocr(document_url: str) -> dict:
     """
-    Extract text from a PDF file using OCR.
+    Extract text from any document (PDF, image, etc.) using Mistral OCR service with document URL,
+    then use Gemini to summarize and extract key points as JSON.
     
-    Expected request format:
-    {
-        "pdf_data": "base64_encoded_pdf_data",
-        "filename": "document.pdf"  # Optional
-    }
+    Args:
+        document_url (str): URL of the document to process
     
     Returns:
-        Dictionary containing extracted text and metadata
+        Dictionary with OCR results and AI analysis
     """
     try:
-        # Get and validate input
-        pdf_data_b64 = request.get("pdf_data")
-        if not pdf_data_b64:
-            return {"error": "Missing required field: pdf_data"}
+        if not document_url:
+            return {"error": "Document URL is required"}
+        
+        # Extract filename from URL
+        filename = document_url.split('/')[-1] if '/' in document_url else "document"
+        
+        # Call Mistral OCR API
+        ocr_response = await mistral_ocr_request(document_url)
+        
+        # Extract text from Mistral response
+        extracted_text = ""
+        page_count = 0
         
-        # Decode base64 data
-        try:
-            pdf_data = base64.b64decode(pdf_data_b64)
-        except Exception as e:
-            return {"error": f"Invalid base64 data: {str(e)}"}
+        if "pages" in ocr_response and isinstance(ocr_response["pages"], list):
+            # Extract text from each page's markdown field
+            extracted_text = "\n\n".join(
+                page.get("markdown", "") 
+                for page in ocr_response["pages"] 
+                if isinstance(page, dict) and "markdown" in page
+            )
+            page_count = len(ocr_response["pages"])
         
-        # Extract text from PDF
-        extracted_text, page_count = extract_text_from_pdf(pdf_data)
+        # Count words and characters
+        word_count = len(extracted_text.split())
+        char_count = len(extracted_text)
         
-        # Prepare response
+        # Build result
         result = {
             "success": True,
-            "filename": request.get("filename", "document.pdf"),
-            "page_count": page_count,
+            "filename": filename,
+            "document_url": document_url,
             "extracted_text": extracted_text,
-            "character_count": len(extracted_text),
-            "word_count": len(extracted_text.split()),
-            "processing_time_ms": 0  # Could be calculated if needed
+            "character_count": char_count,
+            "word_count": word_count,
+            "page_count": page_count,
+            "mistral_response": ocr_response,
+            "processing_service": "Mistral OCR",
+            "llm_analysis": {
+                "error": None,
+                "summary": "",
+                "key_points": [],
+                "document_type": "unknown"
+            }
         }
         
-        return result
-        
-    except Exception as e:
-        return {"error": f"Error processing PDF: {str(e)}"}
+        # If we have text, try to analyze it with the LLM
+        if extracted_text.strip():
+            try:
+                # Use the LLM to analyze the extracted text
+                llm_prompt = f"""Analyze the following document and provide a brief summary, 3-5 key points, and the document type.
 
-@mcp.tool()
-async def image_to_text(image_data: str) -> Dict[str, Any]:
-    """
-    Extract text from an image using OCR.
-    
-    Args:
-        image_data: Base64 encoded image data
-        
-    Returns:
-        Dictionary containing extracted text and metadata
-    """
-    try:
-        # Decode base64 image data
-        image_bytes = base64.b64decode(image_data)
-        
-        # Open image
-        image = Image.open(io.BytesIO(image_bytes))
+Document:
+{extracted_text[:4000]}  # Limit to first 4000 chars to avoid context window issues
+"""
+                
+                # Await the coroutine
+                llm_response = await MODEL.generate_text(llm_prompt)
+                
+                # Parse the LLM response
+                if llm_response:
+                    # Try to parse as JSON if the response is in JSON format
+                    try:
+                        import json
+                        llm_data = json.loads(llm_response)
+                        result["llm_analysis"].update({
+                            "summary": llm_data.get("summary", ""),
+                            "key_points": llm_data.get("key_points", []),
+                            "document_type": llm_data.get("document_type", "document")
+                        })
+                    except (json.JSONDecodeError, AttributeError):
+                        # If not JSON, use the raw response as summary
+                        result["llm_analysis"].update({
+                            "summary": str(llm_response),
+                            "document_type": "document"
+                        })
+                    
+            except Exception as e:
+                result["llm_analysis"]["error"] = f"LLM analysis error: {str(e)}"
         
-        # Extract text
-        text = extract_text_from_image(image)
+        return result
         
-        return {
-            "success": True,
-            "extracted_text": text,
-            "character_count": len(text),
-            "word_count": len(text.split()),
-            "image_size": image.size,
-            "image_mode": image.mode
-        }
     except Exception as e:
-        return {"error": f"Error processing image: {str(e)}"}
+        return {
+            "success": False,
+            "error": f"Error processing document with Mistral OCR: {str(e)}",
+            "document_url": document_url
+        }

mcp_server/tools/quiz_tools.py

@@ -15,48 +15,26 @@ PROMPT_TEMPLATE = (Path(__file__).parent.parent / "prompts" / "quiz_generation.t
 MODEL = GeminiFlash()
 
 @mcp.tool()
-async def generate_quiz_tool(concept: str, difficulty: str = "medium") -> Dict[str, Any]:
+async def generate_quiz_tool(concept: str, difficulty: str = "medium") -> dict:
     """
-    Generate a quiz based on a concept and difficulty using Gemini.
-    
-    Args:
-        concept: The concept to generate a quiz about
-        difficulty: Difficulty level (easy, medium, hard)
-        
-    Returns:
-        Dict containing the generated quiz in JSON format
+    Generate a quiz based on a concept and difficulty using Gemini, fully LLM-driven.
+    The JSON should include a list of questions, each with options and the correct answer.
     """
     try:
-        # Validate inputs
         if not concept or not isinstance(concept, str):
             return {"error": "concept must be a non-empty string"}
-            
         valid_difficulties = ["easy", "medium", "hard"]
         if difficulty.lower() not in valid_difficulties:
             return {"error": f"difficulty must be one of {valid_difficulties}"}
-            
-        # Format the prompt
-        prompt = PROMPT_TEMPLATE.format(
-            concept=concept,
-            difficulty=difficulty.lower()
+        prompt = (
+            f"Generate a {difficulty} quiz on the concept '{concept}'. "
+            f"Return a JSON object with a 'questions' field: a list of questions, each with 'question', 'options' (list), and 'answer'."
         )
-        
-        # Generate quiz using Gemini
-        response = await MODEL.generate_text(prompt, temperature=0.7)
-        
-        # Try to parse the JSON response
+        llm_response = await MODEL.generate_text(prompt, temperature=0.7)
         try:
-            # Extract JSON from markdown code block if present
-            if '```json' in response:
-                json_str = response.split('```json')[1].split('```')[0].strip()
-            else:
-                json_str = response
-                
-            quiz_data = json.loads(json_str)
-            return quiz_data
-            
-        except json.JSONDecodeError as e:
-            return {"error": f"Failed to parse quiz response: {str(e)}", "raw_response": response}
-            
+            quiz_data = json.loads(llm_response)
+        except Exception:
+            quiz_data = {"llm_raw": llm_response, "error": "Failed to parse LLM output as JSON"}
+        return quiz_data
     except Exception as e:
         return {"error": f"Error generating quiz: {str(e)}"}

tests/ocr_app.py

@@ -0,0 +1,281 @@
+"""
+Gradio app for document OCR processing with Mistral OCR.
+
+Features:
+- File upload to storage API
+- Document processing using Mistral OCR
+- Display of OCR results
+"""
+
+import os
+import requests
+import gradio as gr
+import asyncio
+import json
+import tempfile
+from typing import Dict, Any, Optional
+from pathlib import Path
+
+# Mistral AI
+from mistralai import Mistral
+
+# API Configuration
+STORAGE_API_URL = "https://storage-bucket-api.vercel.app/upload"
+MISTRAL_API_KEY = "5oHGQTYDGD3ecQZSqdLsr5ZL4nOsfGYj"  # In production, use environment variables
+
+# Initialize Mistral client
+client = Mistral(api_key=MISTRAL_API_KEY)
+
+class MistralOCRProcessor:
+    """Handles document OCR processing using Mistral AI"""
+    
+    def __init__(self, client: Mistral = None):
+        self.client = client or Mistral(api_key=MISTRAL_API_KEY)
+    
+    async def process_document(self, document_path: str) -> Dict[str, Any]:
+        """
+        Process a document using Mistral OCR
+        
+        Args:
+            document_path: Local path to the document to process
+            
+        Returns:
+            Dict containing OCR results or error information
+        """
+        try:
+            # For local files, we need to upload to a temporary URL first
+            upload_result = await StorageManager().upload_file(document_path)
+            if not upload_result.get("success"):
+                return {
+                    "success": False,
+                    "result": None,
+                    "error": f"Upload failed: {upload_result.get('error')}"
+                }
+            
+            document_url = upload_result.get("storage_url")
+            if not document_url:
+                return {
+                    "success": False,
+                    "result": None,
+                    "error": "No storage URL returned from upload"
+                }
+            
+            # Process with Mistral OCR
+            ocr_response = self.client.ocr.process(
+                model="mistral-ocr-latest",
+                document={
+                    "type": "document_url",
+                    "document_url": document_url
+                },
+                include_image_base64=True
+            )
+            
+            # Convert response to dict if it's a Pydantic model
+            if hasattr(ocr_response, 'model_dump'):
+                result = ocr_response.model_dump()
+            else:
+                result = ocr_response
+                
+            return {
+                "success": True,
+                "result": result,
+                "document_url": document_url,
+                "error": None
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "result": None,
+                "error": f"OCR processing error: {str(e)}"
+            }
+
+class StorageManager:
+    """Handles file uploads to the storage service"""
+    
+    def __init__(self, api_url: str = STORAGE_API_URL):
+        self.api_url = api_url
+    
+    async def upload_file(self, file_path: str) -> Dict[str, Any]:
+        """
+        Upload a file to the storage service
+        
+        Args:
+            file_path: Path to the file to upload
+            
+        Returns:
+            Dict containing upload result or error information
+        """
+        try:
+            with open(file_path, 'rb') as f:
+                files = {'file': (os.path.basename(file_path), f)}
+                response = requests.post(self.api_url, files=files)
+                response.raise_for_status()
+                result = response.json()
+                
+                if not result.get('success'):
+                    raise Exception(result.get('message', 'Upload failed'))
+                    
+                return {
+                    "success": True,
+                    "storage_url": result.get('storage_url'),
+                    "original_filename": result.get('original_filename'),
+                    "file_size": result.get('file_size'),
+                    "error": None
+                }
+                
+        except Exception as e:
+            return {
+                "success": False,
+                "storage_url": None,
+                "original_filename": os.path.basename(file_path),
+                "file_size": os.path.getsize(file_path) if os.path.exists(file_path) else 0,
+                "error": f"Upload failed: {str(e)}"
+            }
+
+# Initialize processors
+ocr_processor = MistralOCRProcessor()
+storage_manager = StorageManager()
+
+async def process_document_ocr(file_path: str) -> Dict[str, Any]:
+    """
+    Process a document through the complete OCR pipeline
+    
+    Args:
+        file_path: Path to the document file
+        
+    Returns:
+        Dict containing processing results
+    """
+    # Process with Mistral OCR (handles upload internally)
+    result = await ocr_processor.process_document(file_path)
+    
+    if not result.get("success"):
+        return {
+            "success": False,
+            "upload": {"success": False},
+            "ocr": None,
+            "error": result.get("error", "Unknown error")
+        }
+    
+    # Get the original filename from the file path
+    original_filename = Path(file_path).name
+    file_size = os.path.getsize(file_path)
+    
+    return {
+        "success": True,
+        "upload": {
+            "success": True,
+            "storage_url": result.get("document_url"),
+            "original_filename": original_filename,
+            "file_size": file_size
+        },
+        "ocr": result.get("result"),
+        "error": None,
+        "storage_url": result.get("document_url")
+    }
+
+# Gradio Interface
+def create_gradio_interface():
+    """Create and return the Gradio interface"""
+    with gr.Blocks(title="Document OCR Processor", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# Document OCR Processor")
+        gr.Markdown("Upload a document (PDF, JPG, JPEG, PNG) to process with Mistral OCR")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                file_input = gr.File(label="Upload Document", type="filepath")
+                process_btn = gr.Button("Process Document", variant="primary")
+                
+                with gr.Accordion("Debug Info", open=False):
+                    status_text = gr.Textbox(label="Status", interactive=False)
+                    
+            with gr.Column(scale=3):
+                with gr.Tabs():
+                    with gr.TabItem("OCR Results"):
+                        ocr_output = gr.JSON(label="OCR Output")
+                    with gr.TabItem("Extracted Text"):
+                        text_output = gr.Textbox(label="Extracted Text", lines=20, max_lines=50)
+                    with gr.TabItem("Upload Info"):
+                        upload_info = gr.JSON(label="Upload Information")
+        
+        def update_status(message):
+            return message
+        
+        async def process_file(file_path):
+            try:
+                status = "Starting document processing..."
+                yield {status_text: update_status(status)}
+                
+                # Process the document
+                result = await process_document_ocr(file_path)
+                
+                if not result["success"]:
+                    error_msg = result.get('error', 'Unknown error')
+                    yield {
+                        status_text: update_status(f"❌ {error_msg}"),
+                        ocr_output: None,
+                        text_output: "",
+                        upload_info: None
+                    }
+                    return
+                
+                # Extract text from OCR result
+                extracted_text = ""
+                ocr_data = result.get("ocr", {})
+                
+                # Handle different OCR result formats
+                if isinstance(ocr_data, dict):
+                    if "text" in ocr_data:
+                        extracted_text = ocr_data["text"]
+                    elif "pages" in ocr_data and isinstance(ocr_data["pages"], list):
+                        extracted_text = "\n\n".join(
+                            page.get("text", "") 
+                            for page in ocr_data["pages"] 
+                            if page and isinstance(page, dict) and "text" in page
+                        )
+                
+                # Prepare upload info
+                upload_info_data = {
+                    "original_filename": result["upload"].get("original_filename"),
+                    "file_size": result["upload"].get("file_size"),
+                    "storage_url": result["upload"].get("storage_url"),
+                }
+                
+                yield {
+                    status_text: update_status("✅ Document processed successfully"),
+                    ocr_output: ocr_data,
+                    text_output: extracted_text,
+                    upload_info: upload_info_data
+                }
+                
+            except Exception as e:
+                import traceback
+                error_trace = traceback.format_exc()
+                error_msg = f"Unexpected error: {str(e)}"
+                yield {
+                    status_text: update_status(f"❌ {error_msg}"),
+                    ocr_output: None,
+                    text_output: "",
+                    upload_info: None
+                }
+        
+        # Connect the process button to the processing function
+        process_btn.click(
+            fn=process_file,
+            inputs=file_input,
+            outputs=[status_text, ocr_output, text_output, upload_info]
+        )
+        
+        # Auto-process when a file is uploaded
+        file_input.change(
+            fn=lambda x: "Ready to process. Click 'Process Document' to continue.",
+            inputs=file_input,
+            outputs=status_text
+        )
+    
+    return demo.launch(server_name="0.0.0.0", server_port=7860)
+
+if __name__ == "__main__":
+    # Create and launch the interface
+    create_gradio_interface()

tests/test_tools_integration.py

@@ -0,0 +1,107 @@
+import pytest
+import asyncio
+import base64
+import os
+from mcp import ClientSession
+from mcp.client.sse import sse_client
+
+SERVER_URL = "http://localhost:8000/sse"  # Adjust if needed
+
+@pytest.mark.asyncio
+async def test_get_concept_graph_tool():
+    async with sse_client(SERVER_URL) as (sse, write):
+        async with ClientSession(sse, write) as session:
+            await session.initialize()
+            result = await session.call_tool("get_concept_graph_tool", {"concept_id": "python"})
+            assert result and "error" not in result
+
+@pytest.mark.asyncio
+async def test_generate_quiz_tool():
+    async with sse_client(SERVER_URL) as (sse, write):
+        async with ClientSession(sse, write) as session:
+            await session.initialize()
+            result = await session.call_tool("generate_quiz_tool", {"concept": "python", "difficulty": "easy"})
+            assert result and "error" not in result
+
+@pytest.mark.asyncio
+async def test_generate_lesson_tool():
+    async with sse_client(SERVER_URL) as (sse, write):
+        async with ClientSession(sse, write) as session:
+            await session.initialize()
+            result = await session.call_tool("generate_lesson_tool", {"topic": "Algebra", "grade_level": 8, "duration_minutes": 45})
+            assert result and "error" not in result
+
+@pytest.mark.asyncio
+async def test_get_learning_path():
+    async with sse_client(SERVER_URL) as (sse, write):
+        async with ClientSession(sse, write) as session:
+            await session.initialize()
+            result = await session.call_tool("get_learning_path", {"student_id": "student_1", "concept_ids": ["python", "oop"], "student_level": "beginner"})
+            assert result and "error" not in result
+
+@pytest.mark.asyncio
+async def test_text_interaction():
+    async with sse_client(SERVER_URL) as (sse, write):
+        async with ClientSession(sse, write) as session:
+            await session.initialize()
+            result = await session.call_tool("text_interaction", {"query": "What is a function in Python?", "student_id": "student_1"})
+            assert result and "error" not in result
+
+@pytest.mark.asyncio
+async def test_check_submission_originality():
+    async with sse_client(SERVER_URL) as (sse, write):
+        async with ClientSession(sse, write) as session:
+            await session.initialize()
+            result = await session.call_tool("check_submission_originality", {"submission": "Python is a programming language.", "reference_sources": ["Python is a programming language.", "Java is another language."]})
+            assert result and "error" not in result
+
+@pytest.mark.asyncio
+async def test_pdf_ocr(tmp_path):
+    # Create a dummy PDF file
+    pdf_path = tmp_path / "test.pdf"
+    with open(pdf_path, "wb") as f:
+        f.write(b"%PDF-1.4 test pdf content")
+    with open(pdf_path, "rb") as f:
+        pdf_data = f.read()
+    pdf_b64 = base64.b64encode(pdf_data).decode("utf-8")
+    async with sse_client(SERVER_URL) as (sse, write):
+        async with ClientSession(sse, write) as session:
+            await session.initialize()
+            result = await session.call_tool("pdf_ocr", {"pdf_data": pdf_b64, "filename": "test.pdf"})
+            assert result and ("error" not in result or "Error processing PDF" in result.get("error", ""))
+
+@pytest.mark.asyncio
+async def test_image_to_text():
+    # Create a dummy image (1x1 pixel PNG)
+    import io
+    from PIL import Image
+    img = Image.new("RGB", (1, 1), color="white")
+    buf = io.BytesIO()
+    img.save(buf, format="PNG")
+    img_b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
+    async with sse_client(SERVER_URL) as (sse, write):
+        async with ClientSession(sse, write) as session:
+            await session.initialize()
+            result = await session.call_tool("image_to_text", {"image_data": img_b64})
+            assert result and "error" not in result
+
+@pytest.mark.asyncio
+async def test_get_concept_tool():
+    async with sse_client(SERVER_URL) as (sse, write):
+        async with ClientSession(sse, write) as session:
+            await session.initialize()
+            result = await session.call_tool("get_concept_tool", {"concept_id": "python"})
+            assert result and "error" not in result
+
+@pytest.mark.asyncio
+async def test_assess_skill_tool():
+    async with sse_client(SERVER_URL) as (sse, write):
+        async with ClientSession(sse, write) as session:
+            await session.initialize()
+            result = await session.call_tool("assess_skill_tool", {"student_id": "student_1", "concept_id": "python"})
+            assert result and "error" not in result
+
+if __name__ == "__main__":
+    import sys
+    import pytest
+    sys.exit(pytest.main([__file__])) 

tests/test_upload_ocr.py

@@ -0,0 +1,79 @@
+"""
+Test script for file upload and OCR functionality.
+
+This script tests the file upload to the storage API and verifies the OCR functionality with the returned storage URL.
+"""
+
+import os
+import requests
+import asyncio
+import argparse
+from pathlib import Path
+
+# Configuration
+STORAGE_API_URL = "https://storage-bucket-api.vercel.app/upload"
+
+async def upload_file_to_storage(file_path):
+    """Helper function to upload file to storage API"""
+    try:
+        with open(file_path, 'rb') as f:
+            files = {'file': (os.path.basename(file_path), f)}
+            print(f"Uploading {file_path} to storage...")
+            response = requests.post(STORAGE_API_URL, files=files)
+            response.raise_for_status()
+            result = response.json()
+            print("\nUpload successful! Response:")
+            print(f"- Success: {result.get('success')}")
+            print(f"- Message: {result.get('message')}")
+            print(f"- Original filename: {result.get('original_filename')}")
+            print(f"- Uploaded filename: {result.get('uploaded_filename')}")
+            print(f"- File size: {result.get('file_size')} bytes")
+            print(f"- Content type: {result.get('content_type')}")
+            print(f"- Storage URL: {result.get('storage_url')}")
+            return result
+    except Exception as e:
+        print(f"Error uploading file: {str(e)}")
+        if hasattr(e, 'response') and e.response is not None:
+            print(f"Server response: {e.response.text}")
+        return {"error": str(e), "success": False}
+
+async def test_ocr_with_storage_url(storage_url):
+    """Test OCR functionality with a storage URL"""
+    print(f"\nTesting OCR with URL: {storage_url}")
+    # This is a placeholder for the actual OCR test
+    # You would typically call your OCR service here
+    print("OCR test would process the document at:", storage_url)
+    print("OCR test completed (mock implementation)")
+    return {"success": True, "message": "OCR test completed (mock implementation)"}
+
+async def main():
+    parser = argparse.ArgumentParser(description='Test file upload and OCR functionality')
+    parser.add_argument('file_path', type=str, help='Path to the file to upload and test')
+    parser.add_argument('--test-ocr', action='store_true',
+                      help='Test OCR functionality with the uploaded file')
+    
+    args = parser.parse_args()
+    
+    # Verify file exists
+    if not os.path.exists(args.file_path):
+        print(f"Error: File not found: {args.file_path}")
+        return
+    
+    # Upload the file
+    upload_result = await upload_file_to_storage(args.file_path)
+    
+    if not upload_result.get('success'):
+        print("\nUpload failed. Cannot proceed with OCR test.")
+        return
+    
+    storage_url = upload_result.get('storage_url')
+    if not storage_url:
+        print("\nNo storage URL in upload response. Cannot test OCR functionality.")
+        return
+    
+    # Test OCR if requested
+    if args.test_ocr:
+        await test_ocr_with_storage_url(storage_url)
+
+if __name__ == "__main__":
+    asyncio.run(main())