Fix MCP server tools to return plain dictionaries

The MCP tools (list_models, get_models, run_query, create_chart) were
returning Pydantic model instances which included internal fields like
model_fields and model_config. This caused confusing output when using
the MCP server.

Changed all tools to return plain dictionaries instead of Pydantic
models. Updated tests to use dictionary access instead of attribute
access.

Author: nicosuave

sidemantic/mcp_server.py

@@ -91,7 +91,7 @@ def get_layer() -> SemanticLayer:
 
 
 @mcp.tool()
-def list_models() -> list[ModelInfo]:
+def list_models() -> list[dict[str, Any]]:
     """List all available models in the semantic layer.
 
     Models are the core building blocks of the semantic layer. Each model represents
@@ -111,20 +111,20 @@ def list_models() -> list[ModelInfo]:
     models = []
     for model_name, model in layer.graph.models.items():
         models.append(
-            ModelInfo(
-                name=model_name,
-                table=model.table,
-                dimensions=[d.name for d in model.dimensions],
-                metrics=[m.name for m in model.metrics],
-                relationships=len(model.relationships),
-            )
+            {
+                "name": model_name,
+                "table": model.table,
+                "dimensions": [d.name for d in model.dimensions],
+                "metrics": [m.name for m in model.metrics],
+                "relationships": len(model.relationships),
+            }
         )
 
     return models
 
 
 @mcp.tool()
-def get_models(model_names: list[str]) -> list[ModelDetail]:
+def get_models(model_names: list[str]) -> list[dict[str, Any]]:
     """Get detailed information about one or more models.
 
     Returns comprehensive details about models including:
@@ -209,17 +209,19 @@ def get_models(model_names: list[str]) -> list[ModelDetail]:
                 }
             )
 
-        details.append(
-            ModelDetail(
-                name=model_name,
-                table=model.table,
-                dimensions=dims,
-                metrics=metrics,
-                relationships=rels,
-                source_format=getattr(model, "_source_format", None),
-                source_file=getattr(model, "_source_file", None),
-            )
-        )
+        detail = {
+            "name": model_name,
+            "table": model.table,
+            "dimensions": dims,
+            "metrics": metrics,
+            "relationships": rels,
+        }
+        if source_format := getattr(model, "_source_format", None):
+            detail["source_format"] = source_format
+        if source_file := getattr(model, "_source_file", None):
+            detail["source_file"] = source_file
+
+        details.append(detail)
 
     return details
 
@@ -231,7 +233,7 @@ def run_query(
     where: str | None = None,
     order_by: list[str] | None = None,
     limit: int | None = None,
-) -> QueryResult:
+) -> dict[str, Any]:
     """Run a query against the semantic layer.
 
     Sidemantic automatically generates SQL from semantic references and handles joins between models.
@@ -306,11 +308,11 @@ def run_query(
     columns = [desc[0] for desc in result.description]
     row_dicts = [dict(zip(columns, row)) for row in rows]
 
-    return QueryResult(
-        sql=sql,
-        rows=row_dicts,
-        row_count=len(row_dicts),
-    )
+    return {
+        "sql": sql,
+        "rows": row_dicts,
+        "row_count": len(row_dicts),
+    }
 
 
 @mcp.tool()
@@ -324,7 +326,7 @@ def create_chart(
     title: str | None = None,
     width: int = 600,
     height: int = 400,
-) -> ChartResult:
+) -> dict[str, Any]:
     """Generate a beautiful chart from a semantic layer query.
 
     This tool combines query execution with intelligent chart generation, producing
@@ -431,12 +433,12 @@ def create_chart(
     vega_spec = chart_to_vega(chart)
     png_base64 = chart_to_base64_png(chart)
 
-    return ChartResult(
-        sql=sql,
-        vega_spec=vega_spec,
-        png_base64=png_base64,
-        row_count=len(row_dicts),
-    )
+    return {
+        "sql": sql,
+        "vega_spec": vega_spec,
+        "png_base64": png_base64,
+        "row_count": len(row_dicts),
+    }
 
 
 def _generate_chart_title(dimensions: list[str], metrics: list[str]) -> str:

tests/test_mcp_server.py

@@ -75,15 +75,15 @@ def test_list_models(demo_layer):
     models = list_models()
 
     assert len(models) == 1
-    assert models[0].name == "orders"
-    assert models[0].table == "orders_table"
-    assert len(models[0].dimensions) == 3
-    assert len(models[0].metrics) == 2
-    assert "order_id" in models[0].dimensions
-    assert "customer_name" in models[0].dimensions
-    assert "order_date" in models[0].dimensions
-    assert "total_revenue" in models[0].metrics
-    assert "order_count" in models[0].metrics
+    assert models[0]["name"] == "orders"
+    assert models[0]["table"] == "orders_table"
+    assert len(models[0]["dimensions"]) == 3
+    assert len(models[0]["metrics"]) == 2
+    assert "order_id" in models[0]["dimensions"]
+    assert "customer_name" in models[0]["dimensions"]
+    assert "order_date" in models[0]["dimensions"]
+    assert "total_revenue" in models[0]["metrics"]
+    assert "order_count" in models[0]["metrics"]
 
 
 def test_get_models(demo_layer):
@@ -92,24 +92,24 @@ def test_get_models(demo_layer):
 
     assert len(models) == 1
     model = models[0]
-    assert model.name == "orders"
-    assert model.table == "orders_table"
+    assert model["name"] == "orders"
+    assert model["table"] == "orders_table"
 
     # Check dimensions
-    assert len(model.dimensions) == 3
-    dim_names = [d["name"] for d in model.dimensions]
+    assert len(model["dimensions"]) == 3
+    dim_names = [d["name"] for d in model["dimensions"]]
     assert "order_id" in dim_names
     assert "customer_name" in dim_names
     assert "order_date" in dim_names
 
     # Check metrics
-    assert len(model.metrics) == 2
-    metric_names = [m["name"] for m in model.metrics]
+    assert len(model["metrics"]) == 2
+    metric_names = [m["name"] for m in model["metrics"]]
     assert "total_revenue" in metric_names
     assert "order_count" in metric_names
 
     # Check metric details
-    revenue_metric = next(m for m in model.metrics if m["name"] == "total_revenue")
+    revenue_metric = next(m for m in model["metrics"] if m["name"] == "total_revenue")
     assert revenue_metric["agg"] == "sum"
     assert revenue_metric["sql"] == "amount"
 
@@ -124,7 +124,7 @@ def test_get_models_multiple(demo_layer):
     """Test getting multiple models (only one exists)."""
     models = get_models(["orders", "nonexistent"])
     assert len(models) == 1
-    assert models[0].name == "orders"
+    assert models[0]["name"] == "orders"
 
 
 def test_run_query_basic(demo_layer):
@@ -134,13 +134,13 @@ def test_run_query_basic(demo_layer):
         metrics=["orders.total_revenue"],
     )
 
-    assert result.sql is not None
-    assert "SELECT" in result.sql.upper()
-    assert "customer_name" in result.sql
-    assert "SUM" in result.sql.upper()
+    assert result["sql"] is not None
+    assert "SELECT" in result["sql"].upper()
+    assert "customer_name" in result["sql"]
+    assert "SUM" in result["sql"].upper()
     # Should have 2 rows (Alice and Bob)
-    assert result.row_count == 2
-    assert len(result.rows) == 2
+    assert result["row_count"] == 2
+    assert len(result["rows"]) == 2
 
 
 def test_run_query_with_filter(demo_layer):
@@ -151,9 +151,9 @@ def test_run_query_with_filter(demo_layer):
         where="orders.customer_name = 'Alice'",
     )
 
-    assert result.sql is not None
-    assert "WHERE" in result.sql.upper()
-    assert "Alice" in result.sql
+    assert result["sql"] is not None
+    assert "WHERE" in result["sql"].upper()
+    assert "Alice" in result["sql"]
 
 
 def test_run_query_with_order_by(demo_layer):
@@ -164,8 +164,8 @@ def test_run_query_with_order_by(demo_layer):
         order_by=["orders.total_revenue desc"],
     )
 
-    assert result.sql is not None
-    assert "ORDER BY" in result.sql.upper()
+    assert result["sql"] is not None
+    assert "ORDER BY" in result["sql"].upper()
 
 
 def test_run_query_with_limit(demo_layer):
@@ -176,9 +176,9 @@ def test_run_query_with_limit(demo_layer):
         limit=10,
     )
 
-    assert result.sql is not None
-    assert "LIMIT" in result.sql.upper()
-    assert "10" in result.sql
+    assert result["sql"] is not None
+    assert "LIMIT" in result["sql"].upper()
+    assert "10" in result["sql"]
 
 
 def test_run_query_dimensions_only(demo_layer):
@@ -187,9 +187,9 @@ def test_run_query_dimensions_only(demo_layer):
         dimensions=["orders.customer_name", "orders.order_date"],
     )
 
-    assert result.sql is not None
-    assert "customer_name" in result.sql
-    assert "order_date" in result.sql
+    assert result["sql"] is not None
+    assert "customer_name" in result["sql"]
+    assert "order_date" in result["sql"]
 
 
 def test_run_query_metrics_only(demo_layer):
@@ -198,6 +198,6 @@ def test_run_query_metrics_only(demo_layer):
         metrics=["orders.total_revenue", "orders.order_count"],
     )
 
-    assert result.sql is not None
-    assert "SUM" in result.sql.upper()
-    assert "COUNT" in result.sql.upper()
+    assert result["sql"] is not None
+    assert "SUM" in result["sql"].upper()
+    assert "COUNT" in result["sql"].upper()