Merge pull request #28 from eduNEXT/fmo/laiser

feat: using the laiser API to create skills

Author: Henrrypg

backend/openedx_ai_badges/processors/badge_processor.py

@@ -3,8 +3,11 @@
 """
 import json
 import logging
+import time
 from pathlib import Path
 
+import requests
+from django.conf import settings
 from openedx_ai_extensions.processors import LLMProcessor
 
 logger = logging.getLogger(__name__)
@@ -97,3 +100,105 @@ def generate_skills(self):
         prompt = self.fill_prompt(prompt)
         result = self._call_completion_wrapper(system_role=prompt)
         return result
+
+    def generate_skills_laiser_api(self):
+        """
+        Submit course context to the LAiSER API and poll for extracted skills.
+
+        Resolves base_url and api_key from processor config or Django settings.
+        POSTs context to /laiser, polls /result until a terminal state, then
+        normalizes the result array into the internal skills alignment format.
+        """
+        base_url = (self.config.get("base_url") or getattr(settings, "LAISER_API_BASE_URL", "")).rstrip("/")
+        api_key = self.config.get("api_key") or getattr(settings, "LAISER_API_KEY", "")
+
+        if not base_url or not api_key:
+            logger.error("LAiSER API is not configured. Check LAISER_API_BASE_URL or LAISER_API_KEY")
+            return {"error": "LAiSER API incorrectly configured"}
+
+        try:
+            submit_response = requests.post(
+                f"{base_url}/laiser",
+                json={"inputText": self.context},
+                headers={"x-api-key": api_key, "Content-Type": "application/json"},
+                timeout=30,
+            )
+            submit_response.raise_for_status()
+            submit_data = submit_response.json()
+        except requests.exceptions.RequestException as exc:
+            logger.error("LAiSER API submit failed: %s", exc)
+            return {"error": str(exc)}
+        except ValueError as exc:
+            logger.error("LAiSER API submit returned non-JSON: %s", exc)
+            return {"error": f"Invalid JSON from LAiSER submit: {exc}"}
+
+        job_id = submit_data.get("jobId")
+        if not job_id:
+            logger.error("LAiSER API submit response missing jobId: %s", submit_data)
+            return {"error": "No jobId in LAiSER submit response"}
+
+        result = self._poll_laiser_job(base_url, api_key, job_id)
+        if "error" in result:
+            return result
+
+        skills = [self._normalize_laiser_skill(s) for s in result.get("result", [])]
+        return {"response": json.dumps({"skills": skills}), "status": "success"}
+
+    def _poll_laiser_job(self, base_url, api_key, job_id):
+        """Poll GET /result until the job reaches a terminal state or timeout."""
+        timeout = getattr(settings, "LAISER_API_TIMEOUT_SECONDS", 90)
+        poll_interval = getattr(settings, "LAISER_API_POLL_INTERVAL_SECONDS", 2)
+        elapsed = 0
+        while elapsed < timeout:
+            time.sleep(poll_interval)
+            elapsed += poll_interval
+
+            try:
+                response = requests.get(
+                    f"{base_url}/result",
+                    params={"jobId": job_id},
+                    headers={"x-api-key": api_key},
+                    timeout=30,
+                )
+                response.raise_for_status()
+                data = response.json()
+            except requests.exceptions.RequestException as exc:
+                logger.error("LAiSER API poll failed (jobId=%s): %s", job_id, exc)
+                return {"error": str(exc)}
+            except ValueError as exc:
+                logger.error("LAiSER API poll returned non-JSON (jobId=%s): %s", job_id, exc)
+                return {"error": f"Invalid JSON from LAiSER poll: {exc}"}
+
+            status = data.get("status")
+            if status in ("QUEUED", "RUNNING"):
+                continue
+
+            if status != "SUCCEEDED":
+                logger.error("LAiSER API job terminal failure (jobId=%s): status=%s", job_id, status)
+                return {"error": f"LAiSER job failed with status: {status}"}
+
+            return data
+
+        logger.error("LAiSER API timed out after %ds, jobId=%s", timeout, job_id)
+        return {"error": f"LAiSER API timed out after {timeout} seconds"}
+
+    @staticmethod
+    def _normalize_laiser_skill(skill: dict) -> dict:
+        """Map a LAiSER API result entry to the internal skills alignment format."""
+        source = (skill.get("Taxonomy Source") or "").lower()
+        target_type_map = {
+            "esco": "ESCO:Skill",
+            "ukos": "UKOS:Skill",
+            "onet_tech": "ONET:Skill",
+        }
+        return {
+            "type": "Alignment",
+            "skill_tag": skill.get("Raw Skill", ""),
+            "target_name": skill.get("Taxonomy Skill", ""),
+            "target_description": skill.get("Taxonomy Description", ""),
+            "target_url": skill.get("Source URL", ""),
+            "target_type": target_type_map.get(source, source),
+            "correlation_coefficient": skill.get("Correlation Coefficient", 0),
+            "task_abilities": [],
+            "knowledge_required": [],
+        }

backend/openedx_ai_badges/settings/common.py

@@ -45,3 +45,11 @@ def plugin_settings(settings):
     settings.MIT_SLM_OLLAMA_URL = ""
     settings.MIT_SLM_OLLAMA_TOKEN = ""
     settings.MIT_DCC_BADGE_API_HEALTH_URL = "http://mit-slm:8000/health"
+
+    # -------------------------
+    # LAiSER API
+    # -------------------------
+    settings.LAISER_API_BASE_URL = ""
+    settings.LAISER_API_KEY = ""
+    settings.LAISER_API_TIMEOUT_SECONDS = 90
+    settings.LAISER_API_POLL_INTERVAL_SECONDS = 2

backend/openedx_ai_badges/settings/production.py

@@ -42,3 +42,20 @@ def plugin_settings(settings):
         settings.OPENEDX_AI_BADGES_MAX_IMAGE_SIZE_BYTES = settings.ENV_TOKENS.get(
             "OPENEDX_AI_BADGES_MAX_IMAGE_SIZE_BYTES", settings.OPENEDX_AI_BADGES_MAX_IMAGE_SIZE_BYTES
         )
+
+    # -------------------------
+    # LAiSER API
+    # -------------------------
+    if hasattr(settings, "ENV_TOKENS"):
+        settings.LAISER_API_BASE_URL = settings.ENV_TOKENS.get(
+            "LAISER_API_BASE_URL", settings.LAISER_API_BASE_URL
+        )
+        settings.LAISER_API_KEY = settings.ENV_TOKENS.get(
+            "LAISER_API_KEY", settings.LAISER_API_KEY
+        )
+        settings.LAISER_API_TIMEOUT_SECONDS = settings.ENV_TOKENS.get(
+            "LAISER_API_TIMEOUT_SECONDS", settings.LAISER_API_TIMEOUT_SECONDS
+        )
+        settings.LAISER_API_POLL_INTERVAL_SECONDS = settings.ENV_TOKENS.get(
+            "LAISER_API_POLL_INTERVAL_SECONDS", settings.LAISER_API_POLL_INTERVAL_SECONDS
+        )

backend/openedx_ai_badges/workflows/orchestrators.py

@@ -263,7 +263,8 @@ def regenerate(self, input_data):
         }
 
         if skills_requested:
-            self._set_status_message("Generating skills alignment...")
+            skills_fn = self.profile.processor_config.get("SkillsProcessor", {}).get("function", "generate_skills")
+            self._set_status_message(f'Generating skills alignment using "{skills_fn}"...')
             skills = self._get_skills(course_context, input_data, regenerate=True)
             if isinstance(skills, dict) and 'error' in skills:
                 return skills
@@ -471,7 +472,8 @@ def run(self, input_data):
         }
 
         if skills_enabled:
-            self._set_status_message("Generating skills alignment...")
+            skills_fn = self.profile.processor_config.get("SkillsProcessor", {}).get("function", "generate_skills")
+            self._set_status_message(f'Generating skills alignment using "{skills_fn}"...')
             skills = self._get_skills(course_context, input_data)
             if isinstance(skills, dict) and 'error' in skills:
                 return skills

backend/openedx_ai_badges/workflows/profiles/badges_base.json

@@ -10,8 +10,9 @@
           "provider": "openai",
       },
       "SkillsProcessor": {
+          // "function": "generate_skills_laiser_api",  // make sure to configure the api key and remove the provider
           "function": "generate_skills",
-          "provider": "openai",
+          "provider": "openai"
       }
   },
   "actuator_config": {