Upload 14 files

Dockerfile

@@ -0,0 +1,30 @@
+FROM python:3.11-slim
+
+# Set up a new user named "user" with user ID 1000
+RUN useradd -m -u 1000 user
+
+# Switch to the "user" user
+USER user
+
+# Set home to the user's home directory
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Set the working directory to the user's home directory
+WORKDIR $HOME/app
+
+# Try and run pip command after setting the user with `USER user` to avoid permission issues
+RUN pip install --no-cache-dir --upgrade pip
+
+# Copy requirements and install dependencies
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the application code
+COPY --chown=user app/ ./app/
+
+# Expose port 7860 (HF Spaces default)
+EXPOSE 7860
+
+# Run the application on port 7860
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,12 +1,27 @@
----
-title: Mdc Engine
-emoji: 🦀
-colorFrom: blue
-colorTo: green
-sdk: docker
-pinned: false
-license: lgpl-3.0
-short_description: This is the Multi-Desciplinery Content Engine
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Multi-Disciplinary Thinking Engine
+emoji: 🔀
+colorFrom: pink
+colorTo: purple
+sdk: docker
+app_port: 7860
+---
+
+# Multi-Disciplinary Thinking Engine
+
+Generates cross-domain learning experiences that connect concepts across disciplines.
+
+## Features
+
+- **Cross-Domain Mapping**: Links concepts across subjects
+- **Integrated Assessments**: Multi-disciplinary challenges
+- **Transfer Learning**: Reinforces concept portability
+- **Holistic Understanding**: Builds interconnected knowledge
+
+## API
+
+**Endpoint**: `POST /run`
+
+## Deployment
+
+This service is configured for Hugging Face Spaces deployment with Docker SDK.

app/api/routes.py

@@ -0,0 +1,53 @@
+from fastapi import APIRouter, Depends, HTTPException
+from app.contracts.dtos import (
+    MultiDisciplinaryRequest, MDTPlan, ToggleModeRequest, ToggleModeResponse,
+    SelectDisciplinesResponse, TransferCheckRequest, TransferCheckResponse,
+    UpdateMasteryRequest, UpdateMasteryResponse
+)
+from app.container import container
+from typing import List
+
+router = APIRouter()
+
+@router.post("/toggle-mode", response_model=ToggleModeResponse)
+async def toggle_mode(request: ToggleModeRequest):
+    controller = container.get("mode_controller")
+    if not controller:
+        raise HTTPException(status_code=500, detail="Service not available")
+    return controller.toggle_mode(request.learner_id, request.enabled)
+
+@router.post("/select-disciplines", response_model=SelectDisciplinesResponse)
+async def select_disciplines(concept_id: str, learner_profile: dict): # Simplified input for now
+    router_service = container.get("router_service")
+    if not router_service:
+        raise HTTPException(status_code=500, detail="Service not available")
+    disciplines = router_service.select_disciplines(concept_id, learner_profile)
+    return SelectDisciplinesResponse(concept_id=concept_id, ranked_disciplines=disciplines)
+
+@router.post("/plan", response_model=MDTPlan)
+async def build_mdt_plan(request: MultiDisciplinaryRequest):
+    stitcher_service = container.get("stitcher_service")
+    if not stitcher_service:
+        raise HTTPException(status_code=500, detail="Service not available")
+    return stitcher_service.build_mdt_plan(request)
+
+@router.post("/generate")
+async def generate_mdt_course(mdt_plan: MDTPlan):
+    adapter = container.get("learning_os_adapter")
+    if not adapter:
+        raise HTTPException(status_code=500, detail="Service not available")
+    return adapter.generate_mdt_course(mdt_plan)
+
+@router.post("/transfer-check", response_model=TransferCheckResponse)
+async def run_transfer_checks(request: TransferCheckRequest):
+    assessment_service = container.get("assessment_service")
+    if not assessment_service:
+        raise HTTPException(status_code=500, detail="Service not available")
+    return assessment_service.run_transfer_checks(request.learner_id, request.target_concept_id, request.disciplines)
+
+@router.post("/update-mastery", response_model=UpdateMasteryResponse)
+async def update_mastery(request: UpdateMasteryRequest):
+    assessment_service = container.get("assessment_service")
+    if not assessment_service:
+        raise HTTPException(status_code=500, detail="Service not available")
+    return assessment_service.update_mastery(request.learner_id, request.evidence)

app/container.py

@@ -0,0 +1,16 @@
+from typing import Dict, Any
+
+class Container(dict):
+    def __init__(self):
+        super().__init__()
+        self._services = {}
+
+    def register(self, name: str, service: Any):
+        self._services[name] = service
+        self[name] = service
+
+    def get(self, name: str) -> Any:
+        return self._services.get(name)
+
+# Global container instance
+container = Container()

app/contracts/dtos.py

@@ -0,0 +1,54 @@
+from pydantic import BaseModel, Field
+from typing import List, Dict, Optional, Any
+
+class Discipline(BaseModel):
+    name: str
+    role: str  # e.g., "core_model", "causal_story", "real_world_context"
+
+class LessonStep(BaseModel):
+    step: int
+    lens: str
+    objective: str
+    
+class MultiDisciplinaryRequest(BaseModel):
+    learner_id: str
+    target_concept_id: str
+    goal: str
+    level: str
+    time_budget_min: int
+    selected_disciplines: Optional[List[str]] = None
+    mode: str = "multidisciplinary"
+
+class MDTPlan(BaseModel):
+    target_concept_id: str
+    disciplines: List[Discipline]
+    lesson_outline: List[LessonStep]
+    generated_by: str = "LearningOS"
+    assets: List[str]
+
+class ToggleModeRequest(BaseModel):
+    learner_id: str
+    enabled: bool
+
+class ToggleModeResponse(BaseModel):
+    learner_id: str
+    mode_active: bool
+
+class SelectDisciplinesResponse(BaseModel):
+    concept_id: str
+    ranked_disciplines: List[str]
+
+class TransferCheckRequest(BaseModel):
+    learner_id: str
+    target_concept_id: str
+    disciplines: List[str]
+
+class TransferCheckResponse(BaseModel):
+    results: Dict[str, Any]
+
+class UpdateMasteryRequest(BaseModel):
+    learner_id: str
+    evidence: Dict[str, Any]
+
+class UpdateMasteryResponse(BaseModel):
+    mastery_deltas: Dict[str, float]

app/main.py

@@ -0,0 +1,24 @@
+from fastapi import FastAPI
+from app.api.routes import router
+from app.container import container
+
+app = FastAPI(title="Multi-Disciplinary Training Engine", version="1.0.0")
+app.include_router(router)
+
+@app.get("/")
+def read_root():
+    return {"status": "ok", "service": "multidisciplinary-engine"}
+
+from app.services.router_service import RouterService
+from app.services.stitcher_service import StitcherService
+from app.services.learning_os_adapter import LearningOSAdapter
+from app.services.mode_controller import ModeToggleController
+from app.services.assessment_service import AssessmentService
+
+@app.on_event("startup")
+async def startup():
+    container.register("router_service", RouterService())
+    container.register("stitcher_service", StitcherService())
+    container.register("learning_os_adapter", LearningOSAdapter())
+    container.register("mode_controller", ModeToggleController())
+    container.register("assessment_service", AssessmentService())

app/services/assessment_service.py

@@ -0,0 +1,22 @@
+from typing import List, Dict, Any
+from app.contracts.dtos import TransferCheckResponse, UpdateMasteryResponse
+
+class AssessmentService:
+    def run_transfer_checks(self, learner_id: str, target_concept_id: str, disciplines: List[str]) -> TransferCheckResponse:
+        # TODO: Implement logic to generate or retrieve transfer check questions
+        results = {
+            "concept": target_concept_id,
+            "checks": [
+                {"discipline": d, "question": f"Explain {target_concept_id} using {d} concepts", "status": "pending"}
+                for d in disciplines
+            ]
+        }
+        return TransferCheckResponse(results=results)
+
+    def update_mastery(self, learner_id: str, evidence: Dict[str, Any]) -> UpdateMasteryResponse:
+        # TODO: Implement logic to calculate mastery deltas based on evidence
+        mastery_deltas = {
+            "economics": 0.5,
+            "history": 0.2
+        }
+        return UpdateMasteryResponse(mastery_deltas=mastery_deltas)

app/services/learning_os_adapter.py

@@ -0,0 +1,21 @@
+import httpx
+from app.contracts.dtos import MDTPlan
+from typing import Dict, Any
+
+class LearningOSAdapter:
+    def __init__(self, base_url: str = "http://learning-os-api"):
+        self.base_url = base_url
+
+    def generate_mdt_course(self, mdt_plan: MDTPlan) -> Dict[str, Any]:
+        # TODO: Implement actual API call to Learning OS
+        # async with httpx.AsyncClient() as client:
+        #     response = await client.post(f"{self.base_url}/generate", json=mdt_plan.dict())
+        #     return response.json()
+        
+        # Mock response
+        return {
+            "status": "success",
+            "course_id": "course_123",
+            "assets": mdt_plan.assets,
+            "message": "Course generated successfully via Learning OS"
+        }

app/services/mode_controller.py

@@ -0,0 +1,14 @@
+from app.contracts.dtos import ToggleModeResponse
+
+class ModeToggleController:
+    def __init__(self):
+        # simple in-memory storage for MVP
+        self._learner_modes = {} 
+
+    def toggle_mode(self, learner_id: str, enabled: bool) -> ToggleModeResponse:
+        self._learner_modes[learner_id] = enabled
+        # In a real system, this would trigger UI events or update a persistent user profile
+        return ToggleModeResponse(
+            learner_id=learner_id,
+            mode_active=enabled
+        )

app/services/router_service.py

@@ -0,0 +1,15 @@
+from typing import List, Dict
+
+class RouterService:
+    def select_disciplines(self, concept_id: str, learner_profile: dict) -> List[str]:
+        # TODO: Implement actual logic to rank disciplines based on concept and learner profile
+        # For now, return hardcoded disciplines as per MVP rules
+        # "Limit to 2–3 supporting disciplines"
+        # "Always include: Core lens, Story lens, Application lens"
+        
+        # Mock logic
+        if "inflation" in concept_id.lower():
+            return ["economics", "history", "geography"]
+        
+        # Default fallback
+        return ["science", "history", "mathematics"]

app/services/stitcher_service.py

@@ -0,0 +1,27 @@
+from typing import List
+from app.contracts.dtos import MultiDisciplinaryRequest, MDTPlan, Discipline, LessonStep
+
+class StitcherService:
+    def build_mdt_plan(self, request: MultiDisciplinaryRequest) -> MDTPlan:
+        # TODO: Implement AI logic to weave disciplines together
+        
+        # Mock implementation based on MVP rules
+        disciplines = [
+            Discipline(name=d, role="core_model" if i==0 else "causal_story" if i==1 else "real_world_context")
+            for i, d in enumerate(request.selected_disciplines or ["economics", "history", "geography"])
+        ]
+        
+        lesson_outline = [
+            LessonStep(step=1, lens=disciplines[0].name, objective=f"Define {request.target_concept_id} + mechanisms"),
+            LessonStep(step=2, lens=disciplines[1].name, objective="Case study explanation"),
+            LessonStep(step=3, lens=disciplines[2].name, objective="Real world context and application"),
+            LessonStep(step=4, lens="integration", objective="Apply to learner’s context")
+        ]
+        
+        return MDTPlan(
+            target_concept_id=request.target_concept_id,
+            disciplines=disciplines,
+            lesson_outline=lesson_outline,
+            generated_by="LearningOS",
+            assets=["lesson://generated-id-1", "quiz://generated-id-1"] # Mock assets
+        )

requirements.txt

@@ -0,0 +1,5 @@
+fastapi==0.115.0
+uvicorn[standard]==0.30.6
+pydantic==2.8.2
+pydantic-settings==2.4.0
+httpx==0.27.2

swagger_tests.json

@@ -0,0 +1,14 @@
+[
+    {
+        "name": "Build MDT Plan",
+        "endpoint": "/plan",
+        "payload": {
+            "learner_id": "learner_123",
+            "target_concept_id": "Evolution",
+            "goal": "Understand natural selection through biological and historical lenses.",
+            "level": "intermediate",
+            "time_budget_min": 60,
+            "mode": "multidisciplinary"
+        }
+    }
+]

tests/test_api.py

@@ -0,0 +1,52 @@
+from fastapi.testclient import TestClient
+from app.main import app
+
+client = TestClient(app)
+
+def test_read_root():
+    response = client.get("/")
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok", "service": "multidisciplinary-engine"}
+
+def test_toggle_mode():
+    response = client.post("/toggle-mode", json={"learner_id": "L1", "enabled": True})
+    assert response.status_code == 200
+    assert response.json()["mode_active"] is True
+    assert response.json()["learner_id"] == "L1"
+
+def test_select_disciplines():
+    response = client.post("/select-disciplines?concept_id=inflation", json={"learner_id": "L1"}) # passing learner_profile as body
+    assert response.status_code == 200
+    data = response.json()
+    assert "economics" in data["ranked_disciplines"]
+    assert "history" in data["ranked_disciplines"]
+
+def test_build_plan():
+    # Helper to enable mode first if needed (though service currently stateless/mocked)
+    req_data = {
+        "learner_id": "L1",
+        "target_concept_id": "inflation",
+        "goal": "understand",
+        "level": "beginner",
+        "time_budget_min": 30,
+        "selected_disciplines": ["economics", "history", "geography"]
+    }
+    response = client.post("/plan", json=req_data)
+    assert response.status_code == 200
+    data = response.json()
+    assert data["target_concept_id"] == "inflation"
+    assert len(data["lesson_outline"]) > 0
+    assert data["generated_by"] == "LearningOS"
+
+def test_generate_course():
+    # Mock plan
+    plan = {
+        "target_concept_id": "inflation",
+        "disciplines": [{"name": "eco", "role": "core"}],
+        "lesson_outline": [{"step": 1, "lens": "eco", "objective": "test"}],
+        "generated_by": "LearningOS",
+        "assets": []
+    }
+    response = client.post("/generate", json=plan)
+    assert response.status_code == 200
+    assert response.json()["status"] == "success"