[ENH] Enrich get_available_tags with rich metadata (description, value_type, applies_to) (#37)

#### Reference Issues/PRs

Fixes #30.

#### What does this implement/fix? Explain your changes.

Currently, `get_available_tags()` returns only a flat list of tag name
strings with no additional context. This causes LLMs to frequently
select the wrong tag or wrong value when filtering estimators (e.g.,
using `"capability:multivariate": true` instead of the correct
`"scitype:y": "multivariate"`).

This PR enhances `get_available_tags()` to return rich metadata for each
tag by leveraging `sktime.registry.all_tags()`. Each tag entry now
includes:

- **`tag`**: the tag name (e.g., `"scitype:y"`)
- **`description`**: human-readable explanation (e.g., `"The scitype of
the target variable y"`)
- **`value_type`**: expected value type (e.g., `"str"`, `"bool"`)
- **`applies_to`**: list of estimator types the tag applies to (e.g.,
`["forecaster", "classifier"]`)

**Files changed:**
- `src/sktime_mcp/registry/interface.py` — Updated
`get_available_tags()` to return rich metadata from
`sktime.registry.all_tags()`
- `src/sktime_mcp/server.py` — Updated tool description to reflect new
output format

Output now after changes (trucated) :
```log
{
  "success": true,
  "tags": [
    {
      "tag": "capability:multivariate",
      "description": "does the object natively support time series with 2 or more variables?",
      "value_type": "bool",
      "applies_to": ["classifier", "clusterer", "early_classifier", "metric", "param_est", "regressor", "transformer"]
    },
    {
      "tag": "capability:pred_int",
      "description": "does the forecaster implement predict_interval or predict_quantiles?",
      "value_type": "bool",
      "applies_to": ["forecaster"]
    },
    {
      "tag": "scitype:y",
      "description": "The scitype of the target variable y",
      "value_type": "str",
      "applies_to": ["forecaster", "classifier", "regressor"]
    }
  ]
}
```

#### Does your contribution introduce a new dependency? If yes, which
one?

No. This uses `sktime.registry.all_tags()` which is already part of the
existing `sktime` dependency.

#### What should a reviewer concentrate their feedback on?

- Whether the updated tool description in `server.py` is clear enough
for LLM consumption

#### Any other comments?

This change is fully backward-compatible at the tool level — the
response key is still `"tags"`, but each entry is now a dict instead of
a string. No new dependencies are introduced.

#### PR checklist

##### For all contributions
- [ ] I've added myself to the [list of
contributors](https://github.com/alan-turing-institute/sktime/blob/main/.all-contributorsrc).
- [ ] Optionally, I've updated sktime's
[CODEOWNERS](https://github.com/alan-turing-institute/sktime/blob/main/CODEOWNERS)
to receive notifications about future changes to these files.
- [ ] I've added unit tests and made sure they pass locally.

##### For new estimators
- N/A

Author: amruth6002

src/sktime_mcp/registry/interface.py

@@ -256,10 +256,47 @@ def get_available_tasks(self) -> List[str]:
         """Get list of available task types."""
         return list(self.TASK_MAP.values())
 
-    def get_available_tags(self) -> List[str]:
-        """Get list of all available tags across all estimators."""
+    def get_available_tags(self) -> List[Dict[str, Any]]:
+        """Get rich metadata for all available tags using sktime's registry.
+
+        Returns a list of dicts, each containing:
+        - tag: the tag name (e.g., "scitype:y")
+        - description: human-readable explanation of what the tag means
+        - value_type: the expected value type (e.g., "bool", "str")
+        - applies_to: list of estimator types this tag applies to
+        """
         self._ensure_loaded()
-        return sorted(list(self._all_tags))
+
+        try:
+            from sktime.registry import all_tags
+            tags_df = all_tags(as_dataframe=True)
+        except ImportError:
+            # Fallback to old behaviour if all_tags is not available
+            return [{"tag": t} for t in sorted(self._all_tags)]
+
+        result = []
+        for _, row in tags_df.iterrows():
+            # Normalize scitype to a list for consistency
+            scitype = row.get("scitype", [])
+            if isinstance(scitype, str):
+                scitype = [scitype]
+            elif not isinstance(scitype, list):
+                scitype = list(scitype) if hasattr(scitype, '__iter__') else [str(scitype)]
+
+            # Convert value_type to a JSON-safe string representation
+            value_type = row.get("type", "")
+            if not isinstance(value_type, str):
+                value_type = str(value_type)
+
+            result.append({
+                "tag": row["name"],
+                "description": row.get("description", ""),
+                "value_type": value_type,
+                "applies_to": scitype,
+            })
+
+        result.sort(key=lambda x: x["tag"])
+        return result
 
     def search_estimators(self, query: str) -> List[EstimatorNode]:
         """

src/sktime_mcp/server.py

@@ -248,7 +248,12 @@ async def list_tools() -> List[Tool]:
         ),
         Tool(
             name="get_available_tags",
-            description="List all queryable capability tags",
+            description=(
+                "List all queryable capability tags with rich metadata. "
+                "Returns tag name, description, expected value type, and which "
+                "estimator types the tag applies to. ALWAYS call this before "
+                "using tags in list_estimators to ensure correct tag names and values."
+            ),
             inputSchema={"type": "object", "properties": {}},
         ),
         Tool(