<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Sara Alonso B on Medium]]></title>
        <description><![CDATA[Stories by Sara Alonso B on Medium]]></description>
        <link>https://medium.com/@salonsobernardo?source=rss-935c672d2fb0------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*8gIA1Z4Vu4XJzYzlkPxt1w.jpeg</url>
            <title>Stories by Sara Alonso B on Medium</title>
            <link>https://medium.com/@salonsobernardo?source=rss-935c672d2fb0------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 15:46:33 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@salonsobernardo/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Spark, PySpark, Spark SQL, Scala… ¿y Apache qué pinta?]]></title>
            <link>https://medium.com/@salonsobernardo/spark-pyspark-spark-sql-scala-y-apache-qu%C3%A9-pinta-1b9af3398b83?source=rss-935c672d2fb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/1b9af3398b83</guid>
            <category><![CDATA[spark]]></category>
            <category><![CDATA[apache-spark]]></category>
            <category><![CDATA[pyspark]]></category>
            <category><![CDATA[microsoft-fabric]]></category>
            <category><![CDATA[notebook]]></category>
            <dc:creator><![CDATA[Sara Alonso B]]></dc:creator>
            <pubDate>Mon, 26 Oct 2026 21:34:14 GMT</pubDate>
            <atom:updated>2026-10-26T21:34:14.214Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>Guía para no liarse: quién es quién en la familia Spark, y cuándo usar cada uno</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/687/1*YPRMOCM2_mxLQ7WApzmpNg@2x.jpeg" /><figcaption>Imagen generada con IA</figcaption></figure><h3>Vale, confieso: yo también me lío</h3><p>¡Hola! 😻</p><p>Spark, PySpark, Spark SQL, Apache esto, Apache lo otro… Llevo meses picando notebooks en Fabric y, aun me entran dudas de qué es qué😅. Y si me pasa a mí, que vivo últimamente dentro de un Lakehouse, estoy segurísima de que no soy la única.</p><p>Así que aquí va el post que me habría gustado leer el primer día: qué es cada palabro, cómo encajan entre sí y, lo más importante, cuál usar en cada momento. Spoiler: es mucho más sencillo de lo que parece.</p><h3>Apache no es una tecnología</h3><p>“Apache” no es una herramienta: es la <a href="https://www.apache.org/"><strong>Apache Software Foundation</strong></a>, una fundación sin ánimo de lucro que apadrina proyectos open source. Spark es uno de ellos, pero también Kafka, Airflow, Hadoop y un montón más.</p><p>Piensa en ella como el apellido de la familia. Cuando alguien dice “Apache Spark”, te está diciendo “Spark, el de los Apache”.</p><h3>Apache Spark: el motor</h3><p>Spark es el <strong>motor de procesamiento distribuido</strong>. En vez de procesar todos tus datos en un solo ordenador, los trocea y los reparte entre varias máquinas (un clúster) que trabajan en paralelo.</p><p>Por dentro está escrito en Scala y corre sobre la JVM, pero eso a ti casi nunca te va a importar. Lo que importa es esto: <strong>Spark es el que hace el trabajo</strong>. Todo lo demás que vamos a ver son formas de darle órdenes.</p><p>Cuando en Fabric abres un notebook y tarda un ratito en arrancar, lo que está haciendo es levantar una sesión de Spark.</p><p><strong>La analogía que a mí me lo aclaró todo: Spark es una empresa de mudanzas.</strong> 📦</p><blockquote>¿Por qué una mudanza? Porque hace poco más de un año hice la gran mudanza de Madrid a Asturias, así que experiencia (grata, gratísima 😂) en el tema tengo de sobra. Vamos a aprovecharla.</blockquote><p>Si te mudas de un estudio, cargas el coche tú sola y listo. Pero si es un piso de cinco habitaciones o tienes mas trastos de los que pensabas (mi caso), llamas a una empresa. Llega un <strong>coordinador</strong> (el <em>driver</em>) que mira el inventario, reparte el trabajo y manda a varios <strong>mozos</strong> (los <em>executors</em>) a cargar a la vez, cada uno con su lote de cajas (las <em>particiones</em>). Al final, el coordinador comprueba que ha llegado todo. Eso es Spark: repartir el trabajo para que acabe antes.</p><h3>Python vs PySpark: no son lo mismo</h3><p><strong>Python</strong> es el lenguaje y punto. Por sí solo no reparte nada: si cargas datos con pandas, todo vive en la memoria de una única máquina.</p><p><strong>PySpark</strong> es el puente: la librería de Python para hablar con Spark. Tú escribes en Python, pero quien ejecuta es Spark, en distribuido.</p><pre>df = spark.read.table(&quot;ventas&quot;)<br>df.filter(df.pais == &quot;ES&quot;).groupBy(&quot;mes&quot;).sum(&quot;importe&quot;)</pre><p>Esto parece Python normal, pero esa tabla podría tener mil millones de filas y no pasaría nada: el trabajo lo hacen los executors de Spark, no tu notebook.</p><p>Siguiendo con la mudanza: <strong>Python es el idioma</strong> en el que hablas tú, y <strong>PySpark es el formulario</strong> con el que contratas a la empresa. Tú no cargas ni una caja: dices qué hay que mover y adónde, y ellos se encargan.</p><h3>Spark SQL: lo mismo, pero en SQL</h3><p><strong>Spark SQL</strong> es el módulo de Spark para consultar datos con SQL de toda la vida. Si vienes de bases de datos o de Power BI, aquí te vas a sentir en casa.</p><p>Y aquí viene lo que me dejó a cuadros: un groupBy() en PySpark y un GROUP BY en Spark SQL <strong>acaban en el mismo plan de ejecución</strong>. Los dos pasan por Catalyst, el optimizador de Spark, así que rinden igual. No hay uno &quot;más rápido&quot;: elige el que te resulte más legible en cada momento.</p><p>En la práctica yo los mezclo sin pudor. SQL para agregaciones y joins que se leen mejor así, PySpark para la lógica, las transformaciones encadenadas y la escritura.</p><p>En versión mudanza: da igual que pidas el presupuesto por WhatsApp (PySpark) o por email (SQL), el plan que recibe el equipo es el mismo. Y <strong>Catalyst</strong> es el coordinador con ojo clínico que revisa tu lista antes de empezar. Por ejemplo, si pides empaquetarlo todo y luego tirar lo que no quieres, él le da la vuelta: primero se tira y luego se empaqueta, para no cargar cajas que van directas al contenedor. Eso, en Spark, es filtrar lo antes posible.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*swVapd4XfvzV5fuzXPd8Tg.png" /></figure><h3>El mapa completo</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o8urmGnAjidLkvDAIpYqkA.png" /></figure><p>Se lee de arriba abajo: Apache es el paraguas, Spark es el motor y la fila de abajo son las formas de darle órdenes. Python va aparte, con línea discontinua, porque es el lenguaje sobre el que se construye PySpark, no una pieza de Spark.</p><p>Ojo, que es tentador llamarlas “librerías” a las cuatro, y no lo son. La palabra buena es <strong>APIs</strong>: formas de hablarle a Spark.</p><ul><li><strong>PySpark</strong> y <strong>SparkR</strong> sí son librerías: hacen de puente entre Python o R y el motor.</li><li><strong>Scala</strong> no es una librería, es un lenguaje. Spark está escrito en Scala, así que no necesita puente: es su API nativa.</li><li><strong>Spark SQL</strong> tampoco conecta un lenguaje externo. Es un módulo del propio Spark que entiende SQL. Y dato curioso: los DataFrames que usas en PySpark viven en ese mismo módulo.</li></ul><h3>pandas o PySpark: ¿cuándo cada uno?</h3><p>La pregunta del millón. La respuesta corta: depende de <strong>cuánto pesan tus datos</strong> y de <strong>dónde viven</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RELoOf6jxcCfzPF0GrcmPg.png" /></figure><p>Ojo con un detalle: pandas suele necesitar en RAM varias veces el tamaño de los datos. Ese CSV de 2 GB te puede pedir bastante más memoria de la que crees.</p><p>Y la trampa clásica: df.toPandas(). Se trae <strong>todo</strong> al driver, que es una sola máquina. Úsalo solo después de filtrar o agregar, nunca con la tabla entera.</p><p>¿Te gusta la sintaxis de pandas pero tienes muchos datos? Existe pyspark.pandas: escribes casi como en pandas y por debajo ejecuta Spark.</p><p><strong>En versión mudanza:</strong> pandas es mudarte con tu coche y, PySpark, contratar el camión. Para cuatro cajas no llamas a una empresa (tarda en llegar y te sale carísimo). Para un piso entero, en tu coche no te cabe ni el sofá. Y toPandas() es intentar meter todo lo que traía el camión en tu coche: si es poquito, genial; si es mucho, no cierra el maletero.</p><h3>¿Y Scala y SparkR?</h3><p>También puedes hablarle a Spark en <strong>Scala</strong>, su lenguaje nativo, o en R con <strong>SparkR</strong>. Existen y funcionan, pero para el día a día en Fabric, PySpark y Spark SQL te cubren de sobra.</p><h3>En Fabric, en la vida real</h3><p>Un notebook de Fabric arranca una sesión de Spark y tú decides en qué idioma le hablas, incluso celda a celda.</p><p><strong>Celda SQL pura</strong>, con el magic %%sql. Ideal para explorar, porque te pinta la tabla y hasta un gráfico:</p><pre>%%sql<br>SELECT pais, SUM(importe) AS total<br>FROM ventas<br>GROUP BY pais<br>ORDER BY total DESC</pre><p><strong>SQL desde PySpark</strong>, con spark.sql(). Te devuelve un DataFrame, así que puedes seguir en Python y guardar:</p><pre>df = spark.sql(&quot;SELECT pais, SUM(importe) AS total FROM ventas GROUP BY pais&quot;)<br>df.write.mode(&quot;overwrite&quot;).saveAsTable(&quot;gold_ventas_pais&quot;)</pre><p><strong>El puente entre mundos</strong>: registra un DataFrame como vista temporal y consúltalo en SQL. La vista vive solo mientras dure la sesión.</p><pre>df_clientes.createOrReplaceTempView(&quot;clientes_tmp&quot;)</pre><p>Y un truco: si lo que vas a procesar es pequeñito, no hace falta Spark. Un notebook de Python puro (sin Spark) con pandas arranca antes y gasta menos capacidad.</p><h3>¿Y esto cómo sería en Power Query?</h3><p>Si vienes de Power BI como yo, esta parte te va a sonar muchísimo. Lo que haces en el editor de Power Query a golpe de clic tiene su equivalente casi directo en Spark.</p><p>Ejemplo: ventas de España agrupadas por mes, en M:</p><pre>let<br>    Filtrado = Table.SelectRows(Origen, each [pais] = &quot;ES&quot;),<br>    Agrupado = Table.Group(Filtrado, {&quot;mes&quot;}, {{&quot;importe&quot;, each List.Sum([importe]), type number}})<br>in<br>    Agrupado</pre><p>En PySpark:</p><pre>from pyspark.sql import functions as F<br>df.filter(df.pais == &quot;ES&quot;).groupBy(&quot;mes&quot;).agg(F.sum(&quot;importe&quot;).alias(&quot;importe&quot;))</pre><p>Y en Spark SQL:</p><pre>%%sql<br>SELECT mes, SUM(importe) AS importe<br>FROM ventas<br>WHERE pais = &#39;ES&#39;<br>GROUP BY mes</pre><p>Tres idiomas, mismo pedido: el filtro es Table.SelectRows, .filter() o WHERE, y la agrupación es Table.Group, .groupBy().agg() o GROUP BY.</p><p>La chuleta de traducción, para tenerla a mano:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1018/1*nFatyWXy6ddSGEBpPm5L9w.png" /></figure><p>Y dos parecidos que me encantan:</p><ul><li><strong>Los pasos aplicados son como las transformaciones de Spark.</strong> Se van apuntando en orden, pero no se ejecutan hasta que de verdad necesitas el resultado.</li><li><strong>El plegado de consultas (query folding) es primo hermano de Catalyst.</strong> En los dos casos, el motor reorganiza tus pasos para filtrar lo antes posible y no mover datos de más.</li></ul><p>La gran diferencia es dónde se ejecuta. Power Query trabaja en una sola máquina (como pandas), así que va genial para preparar datos para un modelo. Spark reparte el trabajo, así que cuando el volumen crece o montas una arquitectura medallion, es el que toma el relevo. En versión mudanza: Power Query es tu coche, organizadísimo y con todo bien etiquetado, y Spark, el camión con su equipo.</p><h3>Mini glosario para no perderse</h3><p>Palabros que te vas a encontrar sí o sí en cuanto abras un notebook:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3lwilzVhXSL4eSM0fqqw7Q.png" /></figure><h3>Resumiendo, que es gerundio (siempre me ha encantado esta expresión)</h3><ul><li><strong>Apache</strong> es la familia, no una tecnología.</li><li><strong>Spark</strong> es el motor que hace el trabajo.</li><li><strong>PySpark</strong>, <strong>Spark SQL</strong>, <strong>Scala</strong> y <strong>SparkR</strong> son formas de hablarle.</li><li><strong>Python</strong> es solo el lenguaje sobre el que se construye PySpark.</li></ul><p>Si te quedas con una sola idea, que sea esta: <em>Spark es el motor; lo demás son idiomas para darle órdenes.</em> A partir de ahí, todo encaja.</p><p>Esto es solo una guía para no volvernos locos con las palabrejas. Si queréis profundizar en Fabric, notebooks y Spark, mi amiga <a href="https://www.monicamesa.es/"><strong>Mónica Mesa</strong></a> está haciendo una serie buenísima sobre el tema, y encima con analogía de croquetas y patatas. Seguidla en su blog, que no os vais a arrepentir, y si no entendeis nada al menos os entrarán ganas de comer croquetas.</p><p>Y si os quedan ganas de más, mi compi <a href="https://www.linkedin.com/in/erikarosalesp/"><strong>Erika Rosales</strong></a> y yo daremos una charla sobre todo esto en el eventazo online de <a href="https://christmaspowerdataplatform.com/"><strong>Christmas Power Data Platform</strong></a><strong> </strong>el finde del 11 de diciembre (pregúntame para mas info). ¡Nos vemos allí! 🎄</p><p>¿Vosotros/as también os liabais? Si conocéis a alguien que sigue llamando “Apache” a todo, pasadle el post 😉.</p><p>¿Qué os ha parecido? ¡Os leo!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lS-3CL7oRPQxpbcFLG6PmQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1b9af3398b83" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Para financieros de Power BI: Matrices para tus comparativas y grupos de cálculo como interruptores]]></title>
            <link>https://medium.com/@salonsobernardo/para-financieros-de-power-bi-matrices-para-tus-comparativas-y-grupos-de-c%C3%A1lculo-como-interruptores-725b32a7866d?source=rss-935c672d2fb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/725b32a7866d</guid>
            <category><![CDATA[calculation-group]]></category>
            <category><![CDATA[finance]]></category>
            <category><![CDATA[power-bi]]></category>
            <dc:creator><![CDATA[Sara Alonso B]]></dc:creator>
            <pubDate>Thu, 15 Oct 2026 15:01:02 GMT</pubDate>
            <atom:updated>2026-10-15T15:01:02.875Z</atom:updated>
            <content:encoded><![CDATA[<p>¡Atención, financieros! 📊 Si alguna vez has creado una medida llamada Ingresos Budget YTD Dif %… este post es para vosotros.</p><p>Hoy vengo con un patrón que me ha salvado la vida (y el modelo) en un proyecto hotelero: cómo usar grupos de cálculo como interruptores para montar comparativas tipo Real vs. Presupuesto, Real vs. Año Anterior, LTM… sin duplicar ni una sola medida.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yvjJRDdiLuuwYz_JyxTLLQ.png" /><figcaption>Imagen generada con IA</figcaption></figure><h3>El problema de verdad</h3><p>Tienes GOP, y de repente necesitas GOP Budget, GOP LY, GOP YTD, GOP YTD Budget, Dif GOP vs Budget, Dif % GOP vs Budget... Y lo mismo para EBITDA, para Gasto Personal, para ADR, etc</p><p>Con 20 KPIs y 4 o 5 vistas comparativas por KPI acabas con más de 100 medidas (y sus descripciones) que son básicamente variaciones sobre lo mismo. El modelo se llena, la carpeta de medidas es un caos, y cuando alguien nuevo entra al proyecto no sabe por dónde empezar.</p><p>Lo que quería era escribir cada KPI <strong>una sola vez</strong> y que la comparativa fuera una capa encima, no una medida nueva.</p><h3>La solución: una tabla eje + un grupo de cálculo</h3><p>Tiene dos piezas.</p><h4>Pieza 1: una tabla desconectada como “eje” de la matriz</h4><p>Una tabla pequeña, sin relaciones con nada, que define las columnas de la matriz:</p><pre>Matriz Comparativa Budget =<br>DATATABLE(<br>    &quot;Periodo&quot;, STRING,<br>    &quot;Comparativa&quot;, STRING,<br>    &quot;Orden&quot;, INTEGER,<br>    {<br>        { &quot;Mensual&quot;,   &quot;REAL&quot;,  1 },<br>        { &quot;Mensual&quot;,   &quot;PPTO&quot;,  2 },<br>        { &quot;Mensual&quot;,   &quot;DIF&quot;,   3 },<br>        { &quot;Mensual&quot;,   &quot;DIF %&quot;, 4 },<br>        { &quot;Acumulado&quot;, &quot;REAL&quot;,  5 },<br>        { &quot;Acumulado&quot;, &quot;PPTO&quot;,  6 },<br>        { &quot;Acumulado&quot;, &quot;DIF&quot;,   7 },<br>        { &quot;Acumulado&quot;, &quot;DIF %&quot;, 8 }<br>    }<br>)</pre><p>Periodo y Comparativa van a las <strong>columnas</strong> de la matriz. Los KPIs van a las <strong>filas</strong> (con la opción <em>Mostrar valores en filas</em>). La columna Orden no es decorativa: sin ella las columnas aparecen en orden alfabético y DIF % sale antes que REAL. Acuérdate de configurar <em>Ordenar por columna</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nRKp36WfaOUkuDL9FFhuWw.png" /></figure><p>Verás en la imagen que para cada KPI ahora mismo nos devuelve el mismo valor en todas las columnas, en la columna “PPTO” de Mensual tendría que aparecer los mismos valores de la tabla de abajo (KPIs que he creado solo a modo validación), para el periodo seleccionado. Esto es lo que vamos a solucionar con el grupo de cálculo.</p><p>En este caso, queremos comparar KPIs reales vs el PPTO o Budget. En lugar de crear 8 medidas, nos basta una sola.</p><h4>Pieza 2: un grupo de cálculo con un único elemento</h4><p>Vamos a crear “Aplicar Matriz Comparativa Budget”, que es un grupo de cálculo con <strong>un solo elemento</strong>, Aplicar, que lee qué celda del eje se está evaluando y transforma la medida en consecuencia.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/290/1*Y4mxFrJL4Pb2ARiUlj-pSw.png" /></figure><p>El DAX sería así, a modo de ejemplo con los KPIs de <em>GOP</em>, <em>Gastos EBITDA</em> y <em>Gasto Personal</em>, con su versión Budget.</p><p>Con los gastos en negativo (sé que ese detalle os gusta a los financieros😉).</p><pre>Aplicar = <br>VAR EsAcumulado =<br>    SELECTEDVALUE ( &#39;Matriz Comparativa Budget&#39;[Periodo] ) = &quot;Acumulado&quot;<br><br>VAR TipoComparativa =<br>    SELECTEDVALUE ( &#39;Matriz Comparativa Budget&#39;[Comparativa] )<br><br>VAR EsGasto =<br>    ISSELECTEDMEASURE (<br>        [Gasto Personal],<br>        [Gastos EBITDA]<br>    )<br><br>VAR ValorReal =<br>    IF (<br>        EsAcumulado,<br>        CALCULATE (<br>            SELECTEDMEASURE (),<br>            DATESYTD ( dim_date[Date] )<br>        ),<br>        SELECTEDMEASURE ()<br>    )<br><br>VAR ValorBudget =<br>    SWITCH (<br>        TRUE (),<br>        ISSELECTEDMEASURE ( [GOP] ),<br>            IF (<br>                EsAcumulado,<br>                CALCULATE ( [GOP Budget], DATESYTD ( dim_date[Date] ) ),<br>                [GOP Budget]<br>            ),<br>        ISSELECTEDMEASURE ( [Gastos EBITDA] ),<br>            IF (<br>                EsAcumulado,<br>                CALCULATE ( [Gastos EBITDA Budget], DATESYTD ( dim_date[Date] ) ),<br>                [Gastos EBITDA Budget]<br>            ),<br>        ISSELECTEDMEASURE ( [Gasto Personal] ),<br>            IF (<br>                EsAcumulado,<br>                CALCULATE ( [Gasto Personal Budget], DATESYTD ( dim_date[Date] ) ),<br>                [Gasto Personal Budget]<br>            ),<br>        BLANK ()<br>    )<br><br>VAR ValorRealNormalizado =<br>-- En negativo, es un gasto<br>    IF (<br>        EsGasto &amp;&amp; NOT ISBLANK ( ValorReal ),<br>        -ABS ( ValorReal ),<br>        ValorReal<br>    )<br><br>VAR ValorBudgetNormalizado =<br>-- En negativo, es un gasto<br>    IF (<br>        EsGasto &amp;&amp; NOT ISBLANK ( ValorBudget ),<br>        -ABS ( ValorBudget ),<br>        ValorBudget<br>    )<br><br>RETURN<br>    SWITCH (<br>        TipoComparativa,<br>        &quot;REAL&quot;, ValorRealNormalizado,<br>        &quot;PPTO&quot;, ValorBudgetNormalizado,<br>        &quot;DIF&quot;,<br>            IF (<br>                NOT ISBLANK ( ValorBudgetNormalizado ),<br>                ValorRealNormalizado - ValorBudgetNormalizado<br>            ),<br>        &quot;DIF %&quot;,<br>            IF (<br>                NOT ISBLANK ( ValorBudgetNormalizado ),<br>                DIVIDE (<br>                    ValorRealNormalizado - ValorBudgetNormalizado,<br>                    ABS ( ValorBudgetNormalizado )<br>                )<br>            ),<br>        SELECTEDMEASURE ()<br>    )</pre><blockquote><em>⚠️ </em><strong><em>Ojo:</em></strong><em> cada vez que añadas un KPI nuevo con presupuesto, tienes que venir aquí y añadir su caso en el </em><em>SWITCH(en este ejemplo ponemos solo 3 KPIs). Si no lo haces, la columna PPTO saldrá en blanco para ese KPI — y la diferencia también. Es intencionado (mejor en blanco que una diferencia falsa), pero hay que saberlo de antemano.</em></blockquote><blockquote><strong><em>TIP:</em></strong><em> Ayúdate de la IA con PBI Modelling MCP Server.</em></blockquote><p>Y el formato dinámico, que es obligatorio. Sin él, la columna de % te va a salir como 0,0734 €:</p><pre>IF (<br>    SELECTEDVALUE ( &#39;Matriz Comparativa Budget&#39;[Comparativa] ) = &quot;DIF %&quot;,<br>    &quot;0.00%&quot;,<br>    SELECTEDMEASUREFORMATSTRING ()<br>)</pre><p>El resultado: <strong>una sola matriz</strong>, todos los KPIs en filas, 8 columnas. Cero medidas de comparativa escritas a mano.</p><p><em>Ejemplo real en Tabular Editor:</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D_LziffcyVYLOhqeMYYh6A.png" /></figure><p>Veamos como queda en nuestra matriz de Power BI, ahora que aplicamos el grupo de cálculo como interruptor:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sERknnhlLjvem0W55RgyiQ.png" /><figcaption>Colocamos el grupo de cálculo en el panel de filtros, como filtro del visual</figcaption></figure><p>Ahora vemos que nos muestra datos diferentes en la matriz comparativa, y además validamos con la tabla de abajo que los resultados son correctos. El grupo de cálculo como interruptor en la matriz ha funcionado correctamente.</p><h3>El mismo patrón, otras preguntas</h3><p>Una vez montado, añadir comparativas nuevas es trivial. Tenemos actualmente tres en producción:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jYvqxzpL_FMxsV5TKFOeJA.png" /></figure><p>Aquí os dejo el código de las otras dos matrices comparativas con sus grupos de cálculo como “interruptores”:</p><ul><li>“Matriz Comparativa LY” y “Aplicar Matriz Comparativa LY”:</li></ul><pre>Matriz Comparativa LY = DATATABLE(<br>    &quot;Periodo&quot;, STRING,<br>    &quot;Comparativa&quot;, STRING,<br>    &quot;Orden Periodo&quot;, INTEGER,<br>    &quot;Orden Comparativa&quot;, INTEGER,<br>    {<br>        { &quot;Mensual&quot;, &quot;REAL&quot;, 1, 1 },<br>        { &quot;Mensual&quot;, &quot;REAL LY&quot;, 1, 2 },<br>        { &quot;Mensual&quot;, &quot;DIF LY&quot;, 1, 3 },<br>        { &quot;Mensual&quot;, &quot;DIF % LY&quot;, 1, 4 },<br>        { &quot;Acumulado&quot;, &quot;REAL&quot;, 2, 1 },<br>        { &quot;Acumulado&quot;, &quot;REAL LY&quot;, 2, 2 },<br>        { &quot;Acumulado&quot;, &quot;DIF LY&quot;, 2, 3 },<br>        { &quot;Acumulado&quot;, &quot;DIF % LY&quot;, 2, 4 }<br>    }<br>)</pre><pre>Aplicar = <br>VAR EsAcumulado =<br>    SELECTEDVALUE ( &#39;Matriz Comparativa LY&#39;[Periodo] ) = &quot;Acumulado&quot;<br><br>VAR TipoComparativa =<br>    SELECTEDVALUE ( &#39;Matriz Comparativa LY&#39;[Comparativa] )<br><br>VAR EsGasto =<br>    ISSELECTEDMEASURE (<br>        [Gasto Personal],<br>        [Gastos EBITDA]<br>    )<br><br>VAR ValorReal =<br>    IF (<br>        EsAcumulado,<br>        CALCULATE (<br>            SELECTEDMEASURE (),<br>            DATESYTD ( dim_date[Date] )<br>        ),<br>        SELECTEDMEASURE ()<br>    )<br><br>VAR ValorLY =<br>    IF (<br>        EsAcumulado,<br>        CALCULATE (<br>            SELECTEDMEASURE (),<br>            SAMEPERIODLASTYEAR (<br>                DATESYTD ( dim_date[Date] )<br>            )<br>        ),<br>        CALCULATE (<br>            SELECTEDMEASURE (),<br>            SAMEPERIODLASTYEAR ( dim_date[Date] )<br>        )<br>    )<br><br>VAR ValorRealNormalizado =<br>    IF (<br>        EsGasto &amp;&amp; NOT ISBLANK ( ValorReal ),<br>        -ABS ( ValorReal ),<br>        ValorReal<br>    )<br><br>VAR ValorLYNormalizado =<br>    IF (<br>        EsGasto &amp;&amp; NOT ISBLANK ( ValorLY ),<br>        -ABS ( ValorLY ),<br>        ValorLY<br>    )<br><br>RETURN<br>    SWITCH (<br>        TipoComparativa,<br>        &quot;REAL&quot;, ValorRealNormalizado,<br>        &quot;REAL LY&quot;, ValorLYNormalizado,<br>        &quot;DIF LY&quot;,<br>            IF (<br>                NOT ISBLANK ( ValorLYNormalizado ),<br>                ValorRealNormalizado - ValorLYNormalizado<br>            ),<br>        &quot;DIF % LY&quot;,<br>            IF (<br>                NOT ISBLANK ( ValorLYNormalizado ),<br>                DIVIDE (<br>                    ValorRealNormalizado - ValorLYNormalizado,<br>                    ABS ( ValorLYNormalizado )<br>                )<br>            ),<br>        SELECTEDMEASURE ()<br>    )</pre><ul><li>“Matriz Comparativa LTM” y “Aplicar Matriz Comparativa LTM” (Last 12 months):</li></ul><pre>Matriz Comparativa LTM = DATATABLE(<br>    &quot;Comparativa&quot;, STRING,<br>    &quot;Orden Comparativa&quot;, INTEGER,<br>    {<br>        { &quot;REAL LTM&quot;, 1 },<br>        { &quot;LY AÑO COMPLETO&quot;, 2 },<br>        { &quot;PPTO&quot;, 3 },<br>        { &quot;DIF LY AÑO COMPLETO&quot;, 4 },<br>        { &quot;DIF LY AÑO COMPLETO %&quot;, 5 },<br>        { &quot;DIF PPTO&quot;, 6 },<br>        { &quot;DIF PPTO %&quot;, 7 }<br>    }<br>)</pre><pre>Aplicar = <br>VAR TipoComparativa =<br>    SELECTEDVALUE ( &#39;Matriz Comparativa LTM&#39;[Comparativa] )<br><br>VAR FechaFin =<br>    MAX ( dim_date[Date] )<br><br>VAR AnioSel =<br>    YEAR ( FechaFin )<br><br>VAR PeriodoLTM =<br>    CALCULATETABLE (<br>        DATESINPERIOD (<br>            dim_date[Date],<br>            FechaFin,<br>            -12,<br>            MONTH<br>        ),<br>        REMOVEFILTERS ( dim_date )<br>    )<br><br>VAR PeriodoLY =<br>    CALCULATETABLE (<br>        DATESBETWEEN (<br>            dim_date[Date],<br>            DATE ( AnioSel - 1, 1, 1 ),<br>            DATE ( AnioSel - 1, 12, 31 )<br>        ),<br>        REMOVEFILTERS ( dim_date )<br>    )<br><br>VAR PeriodoPPTO =<br>    CALCULATETABLE (<br>        DATESBETWEEN (<br>            dim_date[Date],<br>            DATE ( AnioSel, 1, 1 ),<br>            DATE ( AnioSel, 12, 31 )<br>        ),<br>        REMOVEFILTERS ( dim_date )<br>    )<br><br>VAR EsGasto =<br>    ISSELECTEDMEASURE (<br>        [Gasto Personal],<br>        [Gastos EBITDA]<br>    )<br><br>VAR ValorLTM =<br>    CALCULATE (<br>        SELECTEDMEASURE (),<br>        REMOVEFILTERS ( dim_date ),<br>        PeriodoLTM<br>    )<br><br>VAR ValorLY =<br>    CALCULATE (<br>        SELECTEDMEASURE (),<br>        REMOVEFILTERS ( dim_date ),<br>        PeriodoLY<br>    )<br><br>VAR ValorBudget =<br>    CALCULATE (<br>        SWITCH (<br>            TRUE (),<br>            ISSELECTEDMEASURE ( [GOP] ),<br>                [GOP Budget],<br>            ISSELECTEDMEASURE ( [Gastos EBITDA] ),<br>                [Gastos EBITDA Budget],<br>            ISSELECTEDMEASURE ( [Gasto Personal] ),<br>                [Gasto Personal Budget],<br>            BLANK ()<br>        ),<br>        REMOVEFILTERS ( dim_date ),<br>        PeriodoPPTO<br>    )<br><br>VAR ValorLTMNormalizado =<br>    IF (<br>        EsGasto &amp;&amp; NOT ISBLANK ( ValorLTM ),<br>        -ABS ( ValorLTM ),<br>        ValorLTM<br>    )<br><br>VAR ValorLYNormalizado =<br>    IF (<br>        EsGasto &amp;&amp; NOT ISBLANK ( ValorLY ),<br>        -ABS ( ValorLY ),<br>        ValorLY<br>    )<br><br>VAR ValorBudgetNormalizado =<br>    IF (<br>        EsGasto &amp;&amp; NOT ISBLANK ( ValorBudget ),<br>        -ABS ( ValorBudget ),<br>        ValorBudget<br>    )<br><br>RETURN<br>    SWITCH (<br>        TipoComparativa,<br>        &quot;REAL LTM&quot;, ValorLTMNormalizado,<br>        &quot;LY AÑO COMPLETO&quot;, ValorLYNormalizado,<br>        &quot;PPTO&quot;, ValorBudgetNormalizado,<br>        &quot;DIF LY AÑO COMPLETO&quot;,<br>            IF (<br>                NOT ISBLANK ( ValorLYNormalizado ),<br>                ValorLTMNormalizado - ValorLYNormalizado<br>            ),<br>        &quot;DIF LY AÑO COMPLETO %&quot;,<br>            IF (<br>                NOT ISBLANK ( ValorLYNormalizado ),<br>                DIVIDE (<br>                    ValorLTMNormalizado - ValorLYNormalizado,<br>                    ABS ( ValorLYNormalizado )<br>                )<br>            ),<br>        &quot;DIF PPTO&quot;,<br>            IF (<br>                NOT ISBLANK ( ValorBudgetNormalizado ),<br>                ValorLTMNormalizado - ValorBudgetNormalizado<br>            ),<br>        &quot;DIF PPTO %&quot;,<br>            IF (<br>                NOT ISBLANK ( ValorBudgetNormalizado ),<br>                DIVIDE (<br>                    ValorLTMNormalizado - ValorBudgetNormalizado,<br>                    ABS ( ValorBudgetNormalizado )<br>                )<br>            ),<br>        SELECTEDMEASURE ()<br>    )</pre><p>Ejemplo en Power BI de las 3 comparativas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dLR3VhIqCLMRuM2JRxRSCQ.png" /></figure><h3>¿Dónde se crean estos grupos de cálculo?</h3><p>Buena pregunta, porque durante años la respuesta era “solo en Tabular Editor”.</p><ul><li><strong>Power BI Desktop (desde principios de 2026):</strong> ya puedes crearlos de forma nativa desde la vista de modelo, sin herramientas externas.</li><li><strong>Tabular Editor:</strong> sigue siendo la opción más potente para lógica compleja. Conecta directamente con el modelo y tienes más control sobre la estructura.</li><li><strong>Con el MCP de Power BI Modelling:</strong> esta fue mi opción aquí. Cuando el SWITCH empieza a tener 15 o 20 casos con lógica de acumulado, escribirlo a mano es tedioso y propenso a errores. Le di contexto al agente con la estructura del modelo, me generó el DAX completo, revisión final mía. Si tienes el MCP configurado, para este tipo de código repetitivo es una pasada.</li></ul><h3>Importante: La precedencia</h3><p>Si convives con varios grupos de cálculo, define bien el orden de precedence. El de mayor precedencia se aplica primero y puede pisar al siguiente sin avisar — y no da error, simplemente devuelve un número que no cuadra.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/289/1*7WGnKKSDE--eo1a6sf8Csw.png" /><figcaption>Properties del grupo de cálculo de la vista de modelo</figcaption></figure><h3>Por qué funciona: la cadena técnica</h3><p>Y te estarás preguntando: “¿pero por qué funciona el grupo de cálculo como interruptor?” La respuesta está en cómo se propaga el contexto de filtro en DAX.</p><p>Cuando pones el grupo de cálculo como filtro del visual con el elemento Aplicar, le estás diciendo a Power BI: <em>“en este visual, antes de devolver cualquier medida, pásala por esta función.”</em> Esa instrucción está activa en cada celda de la matriz.</p><p>El grupo de cálculo intercepta la evaluación de la medida y la envuelve: no calcula GOP directamente, sino que ejecuta tu expresión Aplicar, donde SELECTEDMEASURE() vale “la medida de esta celda” — GOP, EBITDA, lo que toque. Automáticamente.</p><p>A la vez, como la tabla eje está en las columnas de la matriz, cada celda sabe en qué columna está. Eso es lo que lee SELECTEDVALUE([Comparativa]), y con esa información el SWITCH decide qué calcular.</p><p>Sin el filtro Aplicar, el grupo de cálculo no tiene ningún elemento seleccionado y DAX devuelve la medida sin transformar. El resto del informe tampoco lo tiene — por eso no se ve afectado.</p><p>En una frase: <em>el grupo de cálculo le dice a cada celda “mira en qué columna estás y transforma la medida según el SWITCH.”</em> Y como el filtro solo vive en ese visual, solo ese visual obedece.</p><h3>¿Por qué merece la pena?</h3><p>De un número de medidas proporcional a KPIs × comparativas a KPIs + 1 grupo de cálculo. Si cambia la definición de GOP, se cambia en un sitio y todas las comparativas lo heredan. Un controller puede montar su propia matriz arrastrando KPIs sin pedir nada a nadie.</p><p>Si tu modelo tiene más medidas Budget, LY y Dif que KPIs reales, prueba este patrón. Tu yo del cierre de mes te lo va a agradecer. 😅</p><p>¿Lo has montado de otra forma? ¿Tienes algún caso que no contempla este patrón? ¡Cuéntamelo en los comentarios!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lS-3CL7oRPQxpbcFLG6PmQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=725b32a7866d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[La importancia de un buen modelo de datos (más que nunca, ahora que hay IA de por medio)]]></title>
            <link>https://medium.com/@salonsobernardo/la-importancia-de-un-buen-modelo-de-datos-m%C3%A1s-que-nunca-ahora-que-hay-ia-de-por-medio-c090c706d7be?source=rss-935c672d2fb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/c090c706d7be</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[power-bi]]></category>
            <category><![CDATA[data-analysis]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[microsoft-fabric]]></category>
            <dc:creator><![CDATA[Sara Alonso B]]></dc:creator>
            <pubDate>Tue, 15 Sep 2026 11:31:01 GMT</pubDate>
            <atom:updated>2026-09-15T12:18:09.874Z</atom:updated>
            <content:encoded><![CDATA[<p>¡Hola! 😻</p><p>Llevo años metida en el mundo de los datos, especialmente en Power BI y ahora en Fabric… y hay algo que veo repetirse con frecuencia: nos apetece ir directas a la parte bonita. El dashboard chulo, las medidas rápidas, que Copilot nos escriba el DAX en dos segundos. Y si, todo eso mola. Pero muchas veces nos saltamos el paso que de verdad sostiene todo lo demás: el modelo de datos.</p><p>Con tanto Fabric y tanta IA metida ya en mi día a día últimamente, sentía que tocaba parar un momento y reflexionar sobre esto, porque al final es la base de todo lo demás y muchas veces se nos olvida dedicarle el tiempo que merece.</p><p>¿Te ha pasado alguna vez heredar un informe de Power BI precioso, con esos visuales que dan gustito a la vista, pero que en cuanto abres una matriz un poco grande te toca ir a por un café mientras carga? Pues esto va de eso: nueve de cada diez veces el problema no está en el visual, está en el modelo que hay debajo.</p><p>Cuanta más IA metemos en el flujo de trabajo, más se nota lo importante que es tener una base sólida debajo. Te cuento por qué, con analogías para que se entienda sin necesidad de ser “data person”.</p><h3>El modelo es la base de todo</h3><p>¿Te acuerdas del cuento de los tres cerditos? Uno hace la casa de paja porque es rápido y así antes se pone a hacer otras cosas. Otro la hace de madera, que ya mejora un poco. Y el tercero se pega la currada del siglo de hacerla de ladrillo, aunque tarde más. Total, que llega el lobo, sopla, y solo una de las tres sigue en pie.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/0*NgNt_5GxiyarPq_i.gif" /><figcaption>El lobo derriba de un soplido las casas que se han construido de forma rápida</figcaption></figure><p>Con los modelos de datos pasa exactamente lo mismo. Podemos montar algo rapidísimo, que a primera vista queda hasta bonito, con las tablas conectadas como sea con tal de que el informe “funcione”. Y funciona, sí… hasta que sopla el lobo: llega más volumen de datos, alguien pide una pregunta de negocio un poco más compleja, hay que añadir una nueva fuente. Y ahí es cuando la casa de paja se derrumba, porque nunca estuvo pensada para aguantar peso de verdad.</p><p>Piensa en el modelo de datos así, como los cimientos de una casa. Puedes tener el sofá más bonito de Ikea, la cocina de tus sueños, la decoración perfecta… que si los cimientos están mal, en cuanto haga un poco de viento se te empieza a torcer todo.</p><p>O piénsalo como una receta de cocina: si no tienes claro qué ingredientes llevas, en qué cantidad y en qué orden van, da igual lo bueno que sea el horno (o lo lista que sea la IA que te ayuda). El resultado va a salir raro.</p><p>Cuando el modelo está bien pensado: relaciones claras, granularidad correcta, un esquema que tenga sentido (a poder ser, en estrella), nombres que no despisten… todo lo que viene después funciona mejor y más rápido: el DAX, los visuales, los informes, y también la IA. Cuando no lo está, cada medida nueva es un parche encima de otro parche, cada informe tarda el triple en salir, y acabamos con algo que ni nosotras mismas entendemos dentro de tres meses.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/0*vmLBwxi1rPe0n1xw.gif" /><figcaption>El lobo incapaz de derribar la casa bien construida</figcaption></figure><p>Lo he visto una y otra vez trabajando en varios proyectos a la vez:<strong> los que fluyen no son los que tienen el DAX más ingenioso, son los que tienen el modelo más ordenado.</strong></p><p>Y otra que seguro te suena: ¿cuántas veces has tenido que crear una medida rarísima, con un CALCULATE lleno de excepciones, solo para “arreglar” algo que en realidad era un problema de relaciones mal planteadas? Yo ya he perdido la cuenta.</p><h3>Aquí es donde entra la IA (y por qué no nos libra de modelar bien)</h3><p>Ahora mismo tenemos herramientas increíbles: Copilot escribiéndote DAX, agentes de datos en Fabric, MCPs que le dan contexto a la IA sobre tu modelo semántico… Ayudan muchísimo, de verdad, yo las uso en mi día a día y mi blog está plagado de posts sobre el uso de las mismas. Pero hay algo que no cambia: sin un modelo bien diseñado la IA no trabaja correctamente, solo trabaja con lo que le damos.</p><p>Es un poco como pedirle a un GPS que te lleve a un sitio con un mapa mal dibujado: por muy bueno que sea el GPS, si el mapa de base tiene las calles mal puestas, te va a acabar llevando por donde no es. Y muchas veces no te das cuenta hasta que ya has llegado tarde.</p><p>Si le pides a una IA que te genere una medida DAX sobre un modelo con relaciones ambiguas o tablas mezclando niveles de detalle, te va a devolver algo que “más o menos” funciona, quizás por un tiempo… hasta que deja de hacerlo. Y como el fallo no siempre salta a la vista, puede colarse tranquilamente en un informe que luego se usa para tomar decisiones importantes. Ahí el problema deja de ser un detalle técnico.</p><p>Cuanto más automatizamos (una IA que llama a otra herramienta, que llama a otro agente), más se va acumulando cualquier grieta que hubiera en la base, y por tanto, más deuda técnica que arrastramos. Un modelo limpio no es un capricho de purista, es lo que hace que la IA sea realmente útil y no solo aparente.</p><h3>Lo mismo pasa con M (Power Query)</h3><p>Nos obsesionamos con el DAX porque es la parte que más se ve, la que da resultados directos. Pero el trabajo de verdad muchas veces está antes, en Power Query: cómo limpiamos, cómo transformamos, a qué nivel de detalle dejamos cada tabla antes de que llegue al modelo. Es un poco como lavar y cortar bien las verduras antes de cocinar: nadie lo ve en el plato final, pero si te lo saltas, se nota.</p><p>Aquí también la IA puede ayudarte a escribir pasos en M más rápido. Pero decidir qué transformación hace falta y por qué esa tabla tiene que quedar a ese nivel de detalle y no a otro, eso sigue siendo trabajo nuestro, de entender el negocio. Ninguna IA lo va a acertar si no le damos antes el contexto correcto.</p><h3>¿Qué hago yo antes de escribir una sola línea de DAX?</h3><p>Un par de costumbres que me han salvado más de un proyecto:</p><p>•	Documento el modelo desde el minuto uno, en TMDL o utilizando el MCP de Power BI. Lo que no se escribe, se olvida, y lo que se olvida, cada persona nueva lo acaba interpretando a su manera.</p><p>•	Defino primero la granularidad de cada tabla de hechos. Es la pregunta más aburrida de todas y también la más importante: ¿qué representa cada fila?</p><p>•	Reviso las relaciones una a una, evitando bidireccionales que no hacen falta y que solo generan ambigüedad después.</p><p>•	Pongo a prueba el modelo con preguntas reales de negocio antes de metérselo a la IA. Si yo no puedo responder esa pregunta con el modelo tal cual está, la IA tampoco va a poder.</p><p>Solo cuando esa base está sólida, dejo que Copilot o cualquier agente entre en juego para acelerar el resto.</p><h3>Vale, ¿y si el problema ya está ahí? Cómo diagnosticarlo</h3><p>Todo esto está muy bien cuando partes de cero, pero seamos realistas: la mayoría de las veces no diseñamos el modelo desde el minuto uno, lo heredamos. Y ahí la pregunta ya no es “¿cómo lo hago bien?” sino “¿cómo sé qué está fallando exactamente?”. Por suerte no hace falta adivinar, hay herramientas pensadas justo para eso.</p><p>La primera parada, casi obligatoria, es el<strong> Analizador de rendimiento (Performance Analyzer) </strong>que trae el propio Power BI.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xYAC9eA_ES3M-R-hErAXkw.png" /><figcaption>View -&gt; Performance Analyzer</figcaption></figure><p>Es como ponerle un cronómetro a cada visual de tu informe: le das a grabar, interactúas con la página como lo haría cualquier usuario, y te dice exactamente cuánto tarda cada elemento en cargar y, más importante todavía, cuánto de ese tiempo es consulta DAX y cuánto es renderizado visual.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/421/1*GP4GV5yEo5Y07XAc-287rQ.png" /><figcaption>Performance Analyzer</figcaption></figure><p>Si ves que una matriz tarda cinco segundos y casi todo ese tiempo es “DAX query”, ya sabes que el problema no es el visual en sí, es lo que hay detrás.</p><p>Cuando ese “detrás” hay que abrirlo en canal, ahí entra <a href="https://daxstudio.org/"><strong>DAX Studio</strong></a><strong>, </strong>que es gratis y si no la tienes ya instalada, es buen momento de hacerlo.</p><p>Es la herramienta de referencia para meterte de verdad en una medida o una consulta: te enseña el plan de consulta, separa el tiempo de motor de fórmulas del de motor de almacenamiento (<strong>formula engine vs. storage engine</strong>, para quien le suene), y te deja ver si una medida está generando demasiados “callbacks” al formula engine, que suele ser síntoma de que algo en el modelo (una relación, un contexto de filtro raro, una columna calculada que debería ser de otro tipo) está obligando al motor a currárselo mucho más de lo necesario.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*iyOGlz3w6eExNX8_.png" /><figcaption>Server Timings en DAX Studio: reparto entre Formula Engine y Storage Engine, consulta a consulta. (Imagen del blog de Nikola Ilic: <a href="https://data-mozart.com/mastering-dp-500-dp-600-exam-troubleshoot-dax-performance-with-dax-studio/">Data Mozart</a>).</figcaption></figure><p>Y aquí viene el punto clave: estas herramientas no arreglan el modelo, lo diagnostican. Te dicen dónde te duele, pero la solución casi siempre pasa por volver a las relaciones, a la granularidad, a cómo está construido el esquema. Es un poco como ir al médico: la radiografía te dice dónde está la fractura, pero no te la suelda ella sola.</p><p>Y como dice la gran <a href="https://www.linkedin.com/in/ambynet/">Ana María Bisbé</a>: medir, medir y volver a medir. Son los cimientos de la casa de ladrillo del tercer cerdito.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*bRFJiLFC3gLOl4BZ.gif" /><figcaption>Cerdito construyendo su casa ladrillo a ladrillo</figcaption></figure><p>La buena noticia es que, si le enseñas a la IA lo que te ha devuelto el Performance Analyzer o DAX Studio, sí puede ayudarte a interpretarlo más rápido o a proponerte hipótesis de qué podría estar pasando. Pero el diagnóstico de fondo, y sobre todo la decisión de cómo remodelar, sigue siendo trabajo nuestro.</p><h3>La conclusión de siempre, pero con más razón que nunca</h3><p>La IA no ha venido a quitarle importancia al modelado de datos, más bien todo lo contrario: lo ha puesto todavía más en evidencia. Un buen modelo nos deja escalar, automatizar y usar IA con confianza. Un modelo flojo nos va a hacer perder más tiempo arreglando lo que la IA “automatizó mal” del que nos hubiera costado modelar bien desde el principio.</p><p>Como dice mi amigo <a href="https://www.linkedin.com/in/javiersanchezrivero/">Javier Sánchez</a>, autor del libro “<a href="https://www.amazon.es/Modelado-datos-Power-BI-Query-ebook/dp/B0DXXCMVN7/ref=sr_1_1?__mk_es_ES=%C3%85M%C3%85%C5%BD%C3%95%C3%91&amp;crid=2SX1653S1BVZ3&amp;dib=eyJ2IjoiMSJ9.KTmzrHFAmmXPjh_IxtiubrJvJmlSIIWxJSsRCJEKm4wbTCZ9pfQnUkIxRwlyXxEE1oZ0scFTFw-hB7CVWUf4acuT9wfyRCD8DyDgsXArz8H1TCOu2nlZx94HK2y8mXvkTE15Mw-BXU28oMhadDoazvr50mQsq464dvGJub5DmqJuc_KZxobRe-Yw-29BsShClQ-aIoKLQr8ncl3tb3mER52rdGmpxkZKgt49mSJN2eQ.0oDPbKuP8VjSk1EOHCCSyPSN7Q2haSGEh4aaQv716sU&amp;dib_tag=se&amp;keywords=modelado+de+datos+en+power+bi&amp;qid=1789474634&amp;sprefix=modelado+de+datos+en+power+bi%2Caps%2C111&amp;sr=8-1">Modelado de datos en Power BI</a>”, la IA multiplica por 1000 la productividad de tu día con un modelo de datos sólido, o te la multiplica por -1000 si tu modelo de datos no está bien montado.</p><p>Así que la próxima vez que le pidas a la IA “hazme esta medida”, prueba a preguntarte tú primero: ¿mi modelo está listo para que esa pregunta tenga una respuesta correcta?</p><p>Si la respuesta es que no, por ahí es por donde hay que empezar.</p><p>Y tú, ¿cuál es tu batallita con un modelo mal planteado? Seguro que tienes alguna para contar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lS-3CL7oRPQxpbcFLG6PmQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c090c706d7be" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fabric en VSC: Desarrolla y optimiza con IA contextual — Cap. 3]]></title>
            <link>https://medium.com/@salonsobernardo/fabric-en-vsc-desarrolla-y-optimiza-con-ia-contextual-cap-3-03824887ef34?source=rss-935c672d2fb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/03824887ef34</guid>
            <category><![CDATA[visual-studio-code]]></category>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[microsoft-fabric]]></category>
            <dc:creator><![CDATA[Sara Alonso B]]></dc:creator>
            <pubDate>Tue, 01 Sep 2026 16:01:14 GMT</pubDate>
            <atom:updated>2026-09-01T21:51:40.639Z</atom:updated>
            <content:encoded><![CDATA[<h4>Cap 3 —Extensión <strong>SQL Server (MSSQL) para VS Code: </strong>Ahora sí podemos crear, editar y eliminar en el SQL Endpoint</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*saTxJ7JHhGvW00E2lq91vQ.png" /><figcaption>Imagen creada con IA</figcaption></figure><p>¡Hola de nuevo! 😻</p><p>Si veníais siguiendo la serie, en el <a href="https://medium.com/@salonsobernardo/fabric-en-vsc-desarrolla-y-optimiza-con-ia-contextual-cap-2-0c4ab390a252">Cap. 2</a> os dejé con un límite del MCP de Fabric que me chocó bastante. Estaba construyendo una vista diaria en el SQL Endpoint de Silver a partir de una regla de negocio hotelera con miga, y cuando le pedí al agente que se conectase al SQL Endpoint y creara la vista él mismo, la respuesta fue clara: con las herramientas del MCP de Fabric solo podía <strong>leer</strong> el SQL Endpoint, no ejecutar CREATE VIEW ni ningún otro DDL. Tuve que pedirle el código, copiarlo yo a mano al editor SQL de Fabric y ejecutarlo por mi cuenta.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/590/0*I0vKDsO0Jcwb70po.png" /><figcaption>Recordatorio de la petición (capítulo 2): el MCP de Fabric llegaba a leer, pero no a escribir.</figcaption></figure><p>Funcionó, pero era justo el hueco que me quedó marcado con el ⚠️ del límite gordo: <strong>el MCP llega al SQL Endpoint para mirar, no para escribir.</strong></p><p>Pues bien: unos días después, investigando otra vista rota, descubrí que ya tenía la pieza que me faltaba instalada sin saberlo. Y con ella, esa limitación deja de serlo.</p><h3>El descubrimiento, en directo</h3><p>La pregunta que lo desató fue directa: <strong>“¿puedes acceder a las vistas y editarlas?”</strong>.</p><p>A veces le pregunto cosas al agente sobre las que ya sé la respuesta pero, yo siempre pruebo por si acaso 😅, y en esta ocasión, la respuesta me dejó a cuadros:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RWD88eorOKhH1WMdkgoscQ.png" /><figcaption>El momento exacto en el que até cabos: el agente sí podía crear y editar vistas — con mi permiso explícito.</figcaption></figure><p>Le insistí un poco más: <strong>“¿y crear una nueva?”</strong>. Sí, con CREATE VIEW , y proponiéndome de entrada crear primero una vista _test, validarla sin tocar la original, y sustituirla solo cuando yo confirmara el resultado. Exactamente el flujo con las barreras de seguridad que necesitaba.</p><p>Y la pregunta que me abrió la cabeza: <strong>“¿a través de qué herramienta lo puedes hacer?”</strong>. La respuesta fue la lista de herramientas de la extensión MSSQL: mssql_connect para conectar al SQL Endpoint, mssql_get_connection_details para comprobar la conexión, mssql_run_query para consultar, crear o modificar vistas ejecutando SQL, mssql_list_views para listar las existentes, y mssql_disconnect para cerrar. Y una aclaración clave: el MCP de Fabric no llega a ejecutar DDL como CREATE VIEW , para eso, la vía es mssql_run_query.</p><p>Ahí até el cabo del todo: llevaba semanas usando el MCP de Fabric para <em>mirar</em>, y tenía la pieza para <em>escribir</em> instalada en VS Code sin haberlo probado.</p><h3>Solucionado uno de los límites del MCP de Fabric</h3><p>En medio de esa conversación con Copilot confirmé que ya tenía instalada la extensión <strong>SQL Server (MSSQL) para VS Code</strong>, y que GitHub Copilot podía usar sus herramientas directamente.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cjGIA5gkhcaX3h0VRTNQ8A.png" /><figcaption>Extensión SQL Server (MSSQL) para VS Code</figcaption></figure><p>Con una conexión autorizada de por medio, en <em>agent mode</em> también puede:</p><ul><li>Listar mis perfiles de conexión.</li><li>Conectarse a un servidor y a una base de datos.</li><li>Cambiar de base activa.</li><li>Consultar metadatos del esquema.</li><li>Listar tablas, vistas y funciones.</li><li>Ejecutar T-SQL.</li><li><strong>Crear o modificar vistas.</strong></li><li>Validar los cambios.</li></ul><p>Ahí está: lo que en el Cap. 2 no podía hacer el MCP de Fabric (tocar el SQL Endpoint más allá de la lectura ) sí lo hace la extensión MSSQL en agent mode. La diferencia con lo que hacía Copilot antes tampoco es sutil: ya no se limita a imaginarse el esquema a partir de lo que le cuento en el prompt, ni a dejarme el código para que yo lo pegue a mano. Puede ir a consultar y modificar los objetos reales, directamente.</p><p>Una vez instalada la extensión podrás acceder a ella y conectarte a tu SQL Endpoint, siguiendo los pasos que indico a continuación:</p><p>Desde MSSQL: abrir el diálogo de conexión → <strong>Browse Fabric</strong> → login con Entra ID → elegir tenant, workspace y endpoint → conectar.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LBkvxnAYQ6f-W255UzEKNg.png" /><figcaption><em>En mi caso: añadí la conexión, escogí “browse Fabric”, me logué con la cuenta y seleccioné el SQL Endpoint que necesitaba</em></figcaption></figure><p>¡Tachán! Ya tienes acceso completo al SQL Endpoint.</p><h4>Caso 1: Crear una vista nueva</h4><p>Entonces le pedí que me crease la vista “v_charges_test”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/960/1*pTk180FUsCY82rtvSl8fWQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/947/1*Id_nSXJiq-NGPQ0bpTxb_Q.png" /></figure><p>En la interfaz de Copilot pueden aparecer herramientas tipo mssql_list_servers, mssql_connect, mssql_change_database, mssql_list_views, mssql_run_query.Los nombres dependen de la versión, pero el patrón es siempre: listar, conectar, cambiar de base, listar objetos, ejecutar.</p><p>Voy a la interfaz de Fabric y veo que efectivamente creó la vista en el SQL Endpoint 😊, siendo una copia exacta de v_charges:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/757/1*EOJGdsGdF18vIBmtkQy_CQ.png" /><figcaption>Interfaz de Fabric: SQL Endpoint de la capa Silver.</figcaption></figure><h4><strong>Caso 2: Editar una vista existente</strong></h4><p>Vamos con otro caso. Le pido al agente que revise todas las vistas con datos históricos para verificar que sus queries estén usando las tablas correctas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0maobjnMptE9tR1mIpCRXA.png" /></figure><p>Detectó que la vista v_charges_hist usa algunas tablas que contienen info actual en lugar de histórica. Le pido que las cambie por las históricas:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7wKjFDsjgKpjDJVKWBa3kQ.png" /></figure><p>Voy a mi interfaz de Fabric a comprobarlo y… “voilà”:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ahRLzMRR5QZRWVjB3LM-1g.png" /><figcaption>Query de la vista v_charges_hist</figcaption></figure><p>Damos fe de que ha cambiado el código en la vista.</p><h4><strong>Caso 3: Eliminar una vista</strong></h4><p>Como era una vista de prueba, toca comprobar también que el agente puede eliminarla. Le pido que borre v_charges_test.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/764/1*A3lY8_ZnQ9XCS8CLWY82Vg.png" /></figure><p>Vamos a la interfaz y comprobamos de que ya no existe:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/576/1*5bvUag_eCIFZg0R_VOCriQ.png" /></figure><h3>Esto no sustituye al MCP, lo complementa</h3><p>Dicho lo anterior, quiero pararme un momento, porque es importante no mezclar peras con manzanas. Llevo meses trabajando con el MCP de modelado de Power BI y con el de Fabric, y una de las cosas que más repito quien me lee es que <strong>cada herramienta cubre una capa distinta</strong>:</p><ul><li>El <strong>MCP de modelado de Power BI/Fabric</strong> trabaja sobre el semantic model y el inventario de la plataforma: mide DAX, relaciones, tablas del modelo, artefactos del workspace. Es la capa de negocio y de plataforma.</li><li>La <strong>extensión MSSQL + Copilot</strong> trabaja sobre el <strong>SQL analytics endpoint</strong>: el nivel de vistas, tablas Delta y T-SQL, un escalón por debajo del modelo semántico, y donde el MCP de Fabric se quedaba corto para escribir.</li></ul><p>No son la misma pieza jugando dos papeles. Son dos capas del mismo pipeline, y cada una necesita su propia herramienta con sus propios límites.</p><p>Y lo importante no cambia entre una y otra: <strong>la ejecución y la validación siguen siendo tuyas.</strong> Ni el MCP ni Copilot con MSSQL sustituyen tu criterio como ingeniera de datos. Amplifican lo que puedes hacer, pero cada DDL, cada cambio de dependencias, cada vista nueva tiene que pasar por tu revisión antes de darla por buena. Esto no es “dejar que la IA lo haga”, es tener una interfaz conversacional para un trabajo que sigues dirigiendo tú.</p><h3>Las tres piezas del tablero</h3><ol><li><strong>La extensión MSSQL para VS Code.</strong> Conecta con SQL Server, Azure SQL y SQL en Microsoft Fabric, con Object Explorer, editor y resultados, planes de ejecución e integración nativa con Copilot. Para Fabric tiene <strong>Browse Fabric</strong>: login con Entra ID, eliges tenant y workspace, y te conectas al SQL analytics endpoint sin copiar cadenas de conexión a mano.</li><li><strong>GitHub Copilot Chat.</strong> Cuatro superficies, no las mezcles: <em>Ask mode</em> para preguntas puntuales, <em>Agent mode</em> para flujos de varios pasos y cambios delegados, <em>Plan mode</em> para pensar antes de escribir DDL, e <em>Inline completions</em> que no conocen el esquema conectado por sí solas. Para tocar objetos reales hace falta @mssql o las herramientas MSSQL que Copilot expone en agent mode.</li><li><strong>El SQL analytics endpoint de Fabric.</strong> Permite consultar con T-SQL las tablas Delta de un Lakehouse, pero en modo solo lectura sobre los datos: SELECT sí, INSERT/UPDATE/DELETE no (eso es cosa de Spark). Lo que sí puedes persistir ahí son objetos SQL (vistas, funciones, procedimientos) así que CREATE VIEW y ALTER VIEW funcionan aunque las tablas Delta sean de solo lectura desde T-SQL.</li></ol><h3>Reglas que aplico siempre</h3><ul><li>Confirmar servidor, base e identidad antes de cualquier DDL.</li><li>Probar siempre primero en un entorno de desarrollo o con una vista _test, nunca directo sobre un objeto en producción.</li><li>Inspeccionar antes de escribir.</li><li>Validar comportamiento, no solo sintaxis.</li><li>Ocultar servidor, tenant, correo y datos reales en capturas.</li><li>Mínimo privilegio: Copilot hereda los permisos de mi conexión, ni uno más.</li><li>No dar por hecho compatibilidad total entre SQL Server y Fabric.</li><li>Revisar siempre el SQL antes de aprobar el cambio.</li><li>Definir casos funcionales con resultado esperado, no solo &quot;que compile&quot;.</li><li>Comprobar duplicados al combinar históricos.</li></ul><h3>Limitaciones que me he encontrado</h3><ul><li>Tener la extensión instalada no significa tener una conexión registrada.</li><li>La base por defecto puede no ser la que buscas.</li><li>Algunas DMV de SQL Server no están disponibles en Fabric.</li><li>El endpoint no modifica filas Delta vía T-SQL, eso es cosa de Spark.</li><li>Una vista no compensa datos que no han llegado. Los históricos pueden multiplicar filas si no tienes cuidado.</li></ul><h3>Cerrando el círculo</h3><p>Lo más valioso no es que una IA haya escrito un CREATE VIEW . Para mi el valor está en que el agente pueda ir a comprobar hechos reales antes de tocar nada: qué base estaba activa, si una tabla existía de verdad, qué decía realmente la definición de una vista... GitHub Copilot en agent mode, la extensión MSSQL y el SQL analytics endpoint convierten el chat en una forma de trabajar de verdad con SQL, y por eso piden disciplina: no sustituyen mi criterio, lo ayudan cuando hay pruebas de por medio.</p><p>Si venías siguiendo la serie: en el Cap. 2 os dejé con el MCP de Fabric mirando el SQL Endpoint sin poder tocarlo. Con esto ya tenéis la pieza que faltaba: el modelo semántico con el MCP de modelado, y ahora el SQL Endpoint con MSSQL. Misma norma de la casa: <strong>yo reviso, yo apruebo, yo valido.</strong></p><p>¿Qué os ha parecido? ¡Os leo!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lS-3CL7oRPQxpbcFLG6PmQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=03824887ef34" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fabric en VSC: Desarrolla y optimiza con IA contextual — Cap. 2]]></title>
            <link>https://medium.com/@salonsobernardo/fabric-en-vsc-desarrolla-y-optimiza-con-ia-contextual-cap-2-0c4ab390a252?source=rss-935c672d2fb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/0c4ab390a252</guid>
            <category><![CDATA[microsoft-fabric]]></category>
            <category><![CDATA[power-bi]]></category>
            <category><![CDATA[mcp-server]]></category>
            <dc:creator><![CDATA[Sara Alonso B]]></dc:creator>
            <pubDate>Wed, 05 Aug 2026 10:31:01 GMT</pubDate>
            <atom:updated>2026-08-05T15:24:07.749Z</atom:updated>
            <content:encoded><![CDATA[<h3>Cap 2 — MCP + Fabric: hasta dónde llega de verdad un asistente conectado a tu plataforma de datos</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N1iRVQOucRaYxEkePsA4Gg.png" /></figure><p>¡Hola! ¿Cómo estáis? 😻</p><p>Como ya sabéis, últimamente ando bastante metida en <strong>Fabric</strong> y en eso de usar la <strong>IA</strong> como asistente en mis primeros desarrollos en esta plataforma.</p><p>Hace unos meses publiqué una serie de tres capítulos sobre el <strong>Power BI Modelling MCP Server </strong>(<a href="https://medium.com/@salonsobernardo/power-bi-modelling-mcp-server-cap-1-cad66742e310?sharedUserId=salonsobernardo">aquí</a> el enlace al primer capítulo), y hoy justo os vengo hablar del <strong>Fabric MCP Server (local)</strong>, que por supuesto, ya he estado trasteando con él y ya me ha ayudado un montón en mi proyecto.</p><p>Lo primero que hice fue descargarme la extensión de Fabric MCP Server en Visual Studio Code (VSC). ¡Es gratuita!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/892/1*rhw8649fWArbkTCU_elhBw.png" /></figure><p>Y si vas a trabajar con modelos semánticos, el Power BI Modelling MCP Server también te va ayudar. Si aún no lo tienes, descárgatelo gratis también:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4hXYre8loA4QjVh-fpi4dA.png" /></figure><p>Y si no tienes instalada la extensión de Fabric, es el momento de descargarla:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/720/1*050XpKeACgSviPQ7UH5LYg.png" /></figure><p>Recuerda que también debes disponer de cuenta de GitHub con licencia, y tener instalado <strong>GitHub Copilot Chat. </strong>(También puedes usar Claude Code en su lugar).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/838/1*09_1fzU7F4umTQAqXwYpIg.png" /></figure><p>Conéctate a tu entorno Fabric desde VSC y ya puedes empezar a trastear, como hice yo. También puedes abrir VSC desde tu interfaz de Fabric y tendrás que logarte la primera vez para que VSC quede sincronizado con tu cuenta de Fabric.</p><p>Lo primero que hice fue poner el chat en modo agente, escoger un modelo (yo ahora estoy usando Github Copilot con GPT-5.6 Sol), y preguntarle si se podía <strong>conectar a mi entorno de Fabric. </strong>Nada más. Sólo para ver hasta dónde llegaba de verdad cuando cuenta con herramientas para consultar y modificar sistemas reales.</p><p>Con todo el contexto empecé a trabajar y en un punto se combinaron ambos MCP y editó un modelo de Power BI.</p><p>Pero también encontré límites: <strong>no todo estaba expuesto, no podía ejecutar cualquier SQL, y seguía siendo imprescindible validar la granularidad y las reglas de negocio a mano.</strong></p><p>Vamos al lío.</p><h3>Primero: ¿qué es esto del MCP?</h3><p>Aunque ya lo explicaba en el primer post de la serie de <a href="https://medium.com/@salonsobernardo/power-bi-modelling-mcp-server-cap-1-cad66742e310?sharedUserId=salonsobernardo">Power BI Modelling MCP Server</a>, no está mal recordarlo o explicarlo con otras palabras.</p><p><strong>MCP (Model Context Protocol)</strong> es un estándar para que una aplicación de IA use herramientas y fuentes externas de forma estructurada. Viene a ser como el <strong>enchufe</strong> entre el agente de IA (GitHub Copilot en mi caso) y Fabric. Un servidor MCP le expone al asistente un catálogo de operaciones concretas: listar artefactos de un workspace, consultar el esquema de un Lakehouse, obtener una muestra de una tabla, ejecutar un pipeline, modificar relaciones de un modelo…</p><p>Y aquí está la clave: <strong>el asistente NO recibe acceso ilimitado.</strong> Solo puede usar las herramientas que el servidor publica, y siempre actúa <strong>con los permisos de la identidad conectada.</strong></p><p>O sea: MCP <strong>no es una credencial maestra ni una puerta trasera a Fabric.</strong> Es una <strong>interfaz controlada</strong> sobre capacidades concretas. Que no es poco, pero no es magia negra. 🪄</p><h3>Dos MCP, no uno solo</h3><p>Otra cosa que conviene tener clara: como comentaba antes, en esta prueba usé <strong>dos tipos de MCP</strong>, aunque desde el chat pareciera una sola.</p><ol><li><strong>MCP de Microsoft Fabric</strong> → workspaces, artefactos, Lakehouses, OneLake y metadatos.</li><li><strong>MCP de modelado de Power BI</strong> → conectarme a Power BI Desktop y operar sobre tablas, relaciones, medidas y DAX.</li></ol><p>Parece un detalle tonto, pero importa. <strong>Fabric para la plataforma, Power BI para el modelo semántico. Cada uno a lo suyo.</strong> 💪</p><h3>El bucle que repetí todo el rato</h3><p>Antes de contaros paso a paso lo que fui haciendo, os adelanto el patrón, porque se repite en TODOS los casos:</p><p><strong>Pregunto al agente → el MCP inspecciona → el agente me propone → yo ejecuto / yo valido.</strong></p><p>Guardaos esta frase, que en cada paso vais a ver dónde se corta la automatización. 👇</p><h3>Paso 1: pedirle que me inventaríe la plataforma</h3><p>Como os comentaba, solo con pedirle que se conectase a mi entorno ya empezó a responderme preguntas como: ¿qué workspaces existen?, ¿qué Lakehouses contienen?, ¿cuál es el SQL Endpoint de Silver?, ¿qué notebooks y pipelines hay desplegados?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*8PqkkHQ-fUPG0k9JuwESIg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cXhNlGYoeRkrsmMH9Om8xw.png" /></figure><p>El MCP de Fabric me dejó <strong>listar los artefactos y recuperar sus metadatos</strong> con su herramienta &quot;list_artifacts&quot;, y con todo eso monté un inventario de artefactos agrupados por tipo (workspaces, lakehouses, notebooks, dataflows, data pipelines…)</p><p>Sin esta conexión, ese inventario habría sido abrir el portal, navegar carpeta a carpeta y copiar a mano en un Excel. Con MCP, el asistente me lo convierte en <strong>documentación estructurada.</strong></p><p>⚠️<strong>¡OJO! Pero aquí ya asoma el primer límite:</strong> <strong>no es lo mismo un dato comprobado, una decisión que ya está implementada, algo que he podido inferir o un tema que sigue pendiente.</strong> Porque poner una descripción basándome solo en el nombre de un notebook no tiene, ni de lejos, el mismo nivel de fiabilidad que revisar directamente sus datos.</p><p>De hecho, podía listar los notebooks, pero <strong>no recuperar de forma uniforme su código completo.</strong> Y ojo a la lección, que es importante: <strong>inventariar un artefacto NO es documentar su lógica interna.</strong></p><h3>Paso 2: traducir una regla de negocio a una vista diaria</h3><p>Otro uso que me encantó fue <strong>explorar tablas del Lakehouse </strong>a través del <strong>SQL Endpoint: </strong>columnas, tipos y muestras de datos… Y sobre esa exploración salió el ejemplo más completo de toda la prueba.</p><p>Estábamos trabajando sobre la capa <strong>Silver</strong>, construyendo el modelo de datos mediante <strong>vistas</strong> y conectándolo a <strong>Power BI</strong>, de forma que el cliente pudiera ir validando tanto la estructura como la lógica aplicada antes de pasar a Gold.</p><p>Una vez recibido el OK por parte del cliente, el siguiente paso era trasladar todas las transformaciones y reglas de negocio definidas en esas vistas a <strong>notebooks</strong>, para generar las <strong>tablas Delta definitivas de la capa Gold</strong>.</p><p>Tenía entre manos una regla de negocio hotelera de esas con miga (en mi post anterior comentaba que estoy ahora trabajando en un proyecto de este sector):</p><ul><li>una fecha anterior al check-out cuenta como noche (RN-&gt; room night);</li><li>el día de salida NO cuenta como noche;</li><li>un <em>day-use</em> cuenta personas pero no pernoctación;</li><li>los cargos productivos fuera de la estancia se conservan sin sumar noches ni personas.</li></ul><p>Esto:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/928/1*FquJcQPYVbhkWJKOcv_XBg.png" /></figure><p>La tabla cabecera de reservas tiene una fila por reserva (foto de la última actualización de la misma), así que no era el sitio para una regla que <strong>cambia cada día.</strong> Necesitaba una vista nueva con una fila por <strong>reserva y fecha analizada</strong>, con una clave legible así:</p><pre>reservation_id|YYYYMMDD</pre><p>Como no soy experta en SQL, pedí ayuda al agente. Y lo primero que hice fue lo más directo: preguntarle si podía <strong>conectarse al SQL Endpoint y crear la vista él mismo.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/590/1*5ZfhrabFGQRrwRDPrxcCdA.png" /></figure><p><strong>⚠️ Y aquí aparece el límite gordo:</strong> el MCP llegaba al SQL Endpoint para mirar tablas y datos, pero <strong>no crea vistas, ni las edita, ni recupera su definición.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/692/1*2CRqMQdvjS4tLOG3v3NBOA.png" /><figcaption>EL MCP de Fabric actuando como conector entre el agente y el SQL endpoint</figcaption></figure><p>Así que cambié el chip: si no me la crea, que me escriba el código y ya la creo yo. Y aquí <strong>el contexto lo es TODO:</strong></p><blockquote>Me preparas el código SQL? necesito una vista con granularidad reserva+ fecha, expandiendo el intervalo entre entrada y salida con la tabla calendario. Utiliza las tablas del SQL Endpoint de Silver. Aplica estas reglas (Adjunto) [pegué las reglas de negocio].</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VzRa65jMZUi2wbwhLT4ywA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Qro2JKC-gdK30sFEOFrYIg.png" /></figure><p>Con ese análisis en la mano, Copilot me escribió <strong>tooodo el código de la vista</strong> (en serio, enterito).</p><p>Creé una nueva vista en el SQL Endpoint del workspace Silver:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/680/1*6nzkbeugEtaUTjruyX2rYg.png" /><figcaption>SQL Endpoint</figcaption></figure><p>La copié al editor SQL…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RtpFNWdEfvH-LSnwPkuC3w.png" /><figcaption>Editor SQL del SQL Endpoint</figcaption></figure><p>La ejecuté y…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w477OJv5eM0aIh3HkvWxpA.png" /><figcaption>SQL Endpoint</figcaption></figure><p>¡Tachán! Nos ha incluido los campos de la lógica de negocio. Vamos a filtrar por una reserva para ver el desdoble de días y si cumple la lógica:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CFKVZs3EhJ2ggc6WwSMvOA.png" /><figcaption>SQL Endpoint</figcaption></figure><p>Comprobamos que esta reserva era para estos 4 días: del 10 al 13 de febrero. Por lo que ha creado una línea para cada día y así cumple con las necesidades de negocio que nos habían indicado.🪄</p><h3>Paso 3: saltar al modelo de Power BI</h3><p>Y aquí es donde se combinaron los dos MCP, que era lo que más ganas tenía de probar. Entró el <strong>MCP de modelado de Power BI</strong>, conectándome al PBIX abierto en Desktop.</p><p>Pude auditar el modelo, convertirlo en esquema en estrella, eliminar caminos ambiguos, corregir tipos, crear una dimensión puente, relacionar hechos actuales con históricos para drill-through… La verdad es que estábamos montando un modelo <strong>de todo menos sencillo.</strong> Así que uno de los objetivos era simplificarlo y optimizarlo a tope, con sentido común.</p><p>Al añadir la vista diaria, el MCP detectó que Power BI ya había creado <strong>relaciones automáticas</strong> (esas relaciones fantasma que aparecen solas 👻).</p><p>Antes de tocar nada, le pedí las comprobaciones:</p><blockquote>He añadido la vista al modelo del pbix (lo tengo abierto) y la he renombrado a “v_reservation_stay_daily”. Conéctate a él y ejecútame DAX para contar filas y detectar claves huérfanas contra reserva, fecha, hotel, habitación y tarifa.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/910/1*QoLBl7SVjfP0RWG4ZSkXlQ.png" /><figcaption>El agente va haciendo su magia con las herramientas que le expone el MCP</figcaption></figure><p>Y los resultados:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/994/1*pC7GVm5XlEwNVQIFo7B1yQ.png" /><figcaption>Herramientas MCP Power BI y resultados</figcaption></figure><p>Tras conectarse al modelo y ejecutar varias consultas DAX (que te da la opción de visualizar y descargar) me dio los resultados que le pedí. A partir de aquí tuve que investigar el origen de esos tipos de habitación huérfanos en la tabla. Aquí los MCP nos echan una mano también.</p><p>Solo <strong>después</strong> le pedí que me ayudase a crear las relaciones definitivas y validé que los filtros de año y hotel devolvieran bien noches, PAX y day-use.</p><p>Y esto fue <strong>más que darme instrucciones para ir clicando</strong>: el asistente inspeccionó el estado, aplicó los cambios y comprobó el resultado. Ese salto es lo que a mí me parece potente de verdad.</p><p>⚠️ <strong>El último límite, y el más importante:</strong> <strong>el MCP no decide la arquitectura por ti.</strong> Necesita reglas de negocio explícitas: qué estados no cuentan noches, si los bebés van en el PAX, cuál es la clave de un histórico… Eso no se deduce del nombre de una columna. Y tampoco se salta los permisos: si tú no puedes crear un pipeline o leer una tabla, el MCP tampoco. Y está bien que sea así.</p><h3>La matriz honesta</h3><p>Porque me gusta dejar las cosas claritas, aquí va la tabla de la verdad sobre esta prueba concreta:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1003/1*D4m3LVasMiLuh7_fZOtGQw.png" /></figure><p>Que una herramienta esté “soportada” no significa que la haya probado. Es más riguroso decir «la herramienta lo permite» que venderlo como algo ya validado. Y de eso va justo este post. 😉</p><h3>Una nota importante: usa la IA con cabeza</h3><p>Ya sabéis que en cada post os suelto mi chapa 🤣, y esta vez no va a ser menos.</p><p>MCP <strong>no convierte al asistente en el administrador todopoderoso de Fabric.</strong> Lo convierte en un <strong>cliente estructurado</strong> de las capacidades que TÚ decides exponerle. En mi caso esa diferencia bastó para recorrer un montón del ciclo del dato: inventariar, estudiar tablas, descubrir granularidades, diseñar vistas, resolver errores, tocar un modelo y documentar. Pero también aprendí <strong>dónde termina la automatización.</strong></p><p>Si volviera a empezar mañana, me llevaría <strong>cinco reglas de oro</strong>: versionar el código en Git, documentar la granularidad de cada tabla, separar hechos comprobados de inferencias, usar MCP especializados (Fabric + Power BI) y mantener aprobación humana en lo sensible (DDL, borrados, producción). Ah, y <strong>nunca mandar secretos al chat.</strong></p><p>Al final os lo resumo en una frase: <strong>el MCP no piensa por ti, piensa CONTIGO.</strong> Y esa diferencia, en Fabric, se nota en cada paso.</p><p>Porque la IA no es un oráculo. Es una herramienta. Y como toda herramienta, necesita a alguien que entienda lo que está haciendo. <strong>Úsala con cabeza.</strong> 🧠</p><p>¿Qué os ha parecido? ¿Habéis probado ya a conectar MCP a vuestros entornos? ¡Os leo! 😻</p><h3><strong>Referencias</strong></h3><ul><li>Blog de <a href="https://www.monicamesa.es/category/microsoft-fabric/">Mónica Mesa</a> para todo lo relacionado con Fabric (¡y más!)</li><li><a href="https://learn.microsoft.com/es-es/rest/api/fabric/articles/mcp-servers/what-is-fabric-mcp-server">https://learn.microsoft.com/es-es/rest/api/fabric/articles/mcp-servers/what-is-fabric-mcp-server</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lS-3CL7oRPQxpbcFLG6PmQ.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0c4ab390a252" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fabric en VSC: Desarrolla y optimiza con IA contextual — Cap. 1]]></title>
            <link>https://medium.com/@salonsobernardo/fabric-en-vsc-desarrolla-y-optimiza-con-ia-contextual-ceb57451a16f?source=rss-935c672d2fb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/ceb57451a16f</guid>
            <category><![CDATA[microsoft-fabric]]></category>
            <category><![CDATA[data-engineering]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Sara Alonso B]]></dc:creator>
            <pubDate>Sun, 12 Jul 2026 15:31:00 GMT</pubDate>
            <atom:updated>2026-07-20T10:31:22.661Z</atom:updated>
            <content:encoded><![CDATA[<h3>Cap. 1 — Notebooks con IA que sabe lo que hace</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*93TiND1NTXCclCZloC238A.png" /><figcaption>Imagen creada con IA</figcaption></figure><p>¡Hola a todas y todos! ¿Como estáis? Si, has leído bien. Dejo a Power BI en la estantería para centrarnos en Fabric.😻</p><p>Si vienes del mundo de Power BI, ya sabes cómo es: tarde o temprano, te guste o no, tienes que pegar el salto. Y reconozco que a mí me daba un poco de miedo con tanta palabreja rara (notebooks, lakehouses, SQL endpoints, KQL, pipelines…). Gracias a mi incorporación en Crosspoint me estoy sumergiendo en este mundillo y he de decir que me está gustando (¡y mucho!).</p><p>Ahora bien, en esta serie de posts dejo a un lado Power BI pero la IA… no 🤣. Y es que nada como la ayuda de esta para iniciarte en en terreno desconocido.</p><p>En estas líneas os cuento desde mi experiencia cómo he entrado en Fabric y, sobre todo, cómo la IA me ha acompañado en el camino. Y de verdad, es mucho más fácil de lo que crees.</p><h4>El proyecto: Mi primer encuentro con Fabric</h4><p>Empecé un proyecto nuevo y me encontré con la siguiente situación: teníamos la necesidad de crear un proceso de ingesta de ficheros JSON, transformar los datos, limpiarlos y crear tablas Delta con esos datos para almacenarlos en un Lakehouse de Fabric.</p><p>Como si me hablasen en chino. 🤷‍♀️</p><p>A mí lo único que me venía a la cabeza era Power Query para la transformación y limpieza de datos. Pero para llevar a cabo ese proceso se había acordado con el cliente generar <strong>notebooks en Fabric utilizando PySpark</strong>.</p><p>Seguía siendo chino para mí.</p><p><em>Nota: No te preocupes, ahora explicaremos todos estos términos.</em></p><h4>¿Qué es PySpark?</h4><p><strong>PySpark</strong> es la interfaz de<strong> Python</strong> <strong>(lenguaje) para Apache Spark (motor)</strong>, una herramienta para procesar <strong>grandes volúmenes de datos.</strong></p><p>Como decía antes, si vienes de Power BI, lo más parecido que conoces es <strong>Power Query</strong>: donde transformas datos (limpiar, filtrar, agrupar, unir tablas). Pero Power Query es para volúmenes “normales”.</p><p><strong>PySpark es Power Query en esteroides</strong>, más potente y con código. hecho para cuando tienes millones de registros y necesidad de procesar todo rápido y en paralelo.</p><p><strong>En Fabric, ¿dónde lo usas? </strong>En los <strong>notebooks</strong>. Un notebook es básicamente un documento donde escribes código PySpark, lo ejecutas, ves resultados y comentas qué haces en cada paso.</p><p><strong>La diferencia clave entre Power Query y PySpark</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1011/1*GoNbUWqZUcMWuT2PXLarKQ.png" /></figure><p><em>Nota: Fabric también soporta SQL, Python normal, R y Scala. Pero 80% del tiempo usarás PySpark o SQL.</em></p><p>👉🏼Para profundizar en Notebooks: Ver referencias al final.</p><h4>La arquitectura medallón: Bronze, Silver, Gold</h4><p>Bien, ahora que sabemos qué es PySpark, volvemos al proyecto.</p><p>Había que generar un notebook para cada Entidad (así lo llama este cliente). Mi compañera Marta Plaza, con mucha paciencia, me indicó dónde se ubicaban esos ficheros que cada notebook tenía que procesar.</p><p>La estructura que seguimos es propia de una <strong>arquitectura medallón</strong> (un patrón muy usado en data engineering):</p><ul><li><strong>Lakehouse Bronze:</strong> aquí almacenamos los datos en crudo. Teníamos los archivos JSON que cada notebook tenía que ingerir y procesar. Es el <strong>input</strong> del notebook: “Toma, procesa esto.”</li><li><strong>Lakehouse Silver:</strong> aquí se guardan las tablas Delta que se crean tras ejecutar cada notebook. Son los datos transformados, limpios y listos. Es el <strong>output</strong> del notebook: “Aquí está el resultado.”</li><li><strong>Lakehouse Gold:</strong> aquí viven los datos optimizados y con la lógica de negocio. Son agregaciones, tablas desnormalizadas, vistas que alimentarán Power BI o reporting. El paso final antes de que el negocio los use.</li></ul><p><strong>💼 Workspace aparte:</strong> donde viven los notebooks que hacen toda la magia.</p><p>👉🏼Para profundizar en esta arquitectura: Ver referencias al final.</p><h4>Setup: Lo que necesitas para trabajar en Fabric + VSC + Copilot</h4><p>Me metí en el workspace de los notebooks y fui siguiendo mi intuición para crear el notebook (esto Fabric lo pone fácil):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PuCxeoU81Mai0SJRYxyWTg.png" /><figcaption>Pulsamos sobre “New item” en la cabecera del workspace</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aOCicUcVeQC0tBgU8dNTZA.png" /><figcaption>El notebook aparece en el listado de “Prepare data”, pero también puede aparecer como “reciente” o puedes buscarlo en la barra de búsqueda</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/953/1*q0MfezklH62OWxuCC88W2Q.png" /><figcaption>De momento con darle un nombre y saber donde lo ubicamos nos bastaría</figcaption></figure><p>Lo primero que tienes que hacer (no hace falta que sea lo primero, pero lo tienes que hacer 🤣), es asignarle al notebook al menos un Lakehouse. En mi caso como el input del notebook y el output están en diferentes Lakehouses le tuve que asignar los dos. Y escoger uno por defecto, en este caso, asigné el Lakehouse Silver, que es donde se alojan los datos procesados por el notebook.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/854/1*ESsxXjXVfX-_rpJhYIO2fw.png" /></figure><p>Vale. Todo listo. ¿Por dónde empiezo? Si yo no sé de Python ni de PySpark ni nada de nada. Y de repente, ahí estaba… saludándome desde la barra de herramientas. Sí, el icono de Visual Studio Code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SOYGxJEgfcXsV8ojgs6gzQ.png" /></figure><p>Sí, sé que esa pantalla negra de VSC con código suele dar bastante miedo, sobre todo a los que venimos de BI. Yo afortunadamente lo perdí cuando me enteré de que podíamos editar los modelos de Power BI con TMDL desde VSC utilizando GitHub copilot. Y fue lo mejor que me pudo pasar.</p><p>Tener GitHub Copilot instalado junto a las extensiones necesarias es el mejor asistente del mundo para escribir código y editar modelos. Desde mi experiencia.</p><p>Así que no dudé en pinchar ahí y que se me abriese la ventana de Visual Studio.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/605/1*oBGZ1TmX1vQEZUJWpBzh0w.png" /></figure><p>¿Que necesitamos para trabajar en nuestro entorno de Fabric dentro de VSC y con Github Copilot como asistente?</p><ul><li>Sincronizar Fabric con VSC logándonos con nuestra cuenta: La primera vez te va a pedir que te conectes con las credenciales que tengas para Fabric. En ese momento entu ventana del VSC verás tu entorno de Fabric sincronizado.</li><li>Tener licencia de Github Pro (personal o corporativa) y conectarte a la cuenta.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/652/1*oinRmQBcVP8N0fFki8mnRg.png" /></figure><ul><li>Tener instalada la extensión de Github Copilot Chat:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*Snl_OHLZOKuphJKjSM22qw.png" /></figure><ul><li>Tener instalada la extensión de Fabric:</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/922/1*fCj-lrguHG3MpHbnhWPXAQ.png" /></figure><ul><li>Tener instalada la extensión de Fabric Data Engineering VS Code: La más importante para crear y editar los notebooks.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/925/1*xKHQrgT6L9BXDxVWw13emQ.png" /></figure><p><em>NOTA: Existen más extensiones de VSC relacionadas con Fabric, yo también tengo instalado el MCP de Fabric, por ejemplo. Pero al menos de momento, con estas tiramos.</em></p><h4>Creando el primer notebook</h4><p>Con todo el setup listo, hay dos maneras de crear el notebook: desde la pestaña de Explorer o desde la de Fabric Data Engineering.</p><p>Hoy vamos a hacerlo desde el Explorer y más adelante veremos la otra manera:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/575/1*No9ZM5lODoRIvHJuRa9j4g.png" /><figcaption>Pestaña explorer</figcaption></figure><p>Por defecto (si ya lo tienes instalado) te aparecerá en el desplegable del chat la opción de <strong>FabricNotebook.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DTaRM1C-EPifZiXXytSiJw.png" /></figure><p>Además, puedes seleccionar el modelo que quieres que trabaje como agente. Ojo: Opus 4.8 es la bomba pero consume tokens a montones. Mejor ir alternando entre modelos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/801/1*cpHkL0DdJ-V4LxvK1I6lVg.png" /></figure><p><strong>El poder del prompt claro:</strong></p><p>Como siempre digo, <strong>lo primero es tener claro qué quieres conseguir</strong> al ejecutar el notebook. Porque sin conocer el código tenemos que darle a la IA una instrucción muy clara.</p><p>Y eso es lo que le vas a escribir en la ventana de chat de Github Copilot.</p><p>Si es el primer notebook que creas debes ser <strong>muy concreta/o en tu prompt.</strong> Indica todo lo que quieres que te devuelva cuando se ejecute.</p><p>Aquí va el ejemplo real del primero que creé, lo llamaremos notebook_x:</p><pre>💡 PROMPT:<br><br>Necesito crear un notebook ETL en Fabric que se llame notebook_x y que:<br><br>1. Lea archivos JSON de una API que llegan diariamente a una landing zone en OneLake Bronze<br>   - Los archivos tienen formato: x_YYYY-MM-DD.json<br>   - Estructura JSON: un array results con objetos que contienen: [campos específicos]<br><br>2. Valide la calidad de los datos:<br>   - Detectar archivos vacíos<br>   - Validar que el esquema JSON tenga los campos esperados<br><br>3. Cargue los datos en una tabla Delta Silver llamada Schema.nombre_tabla<br>   - Hacer UPSERT por ID (evitar duplicados)<br>   - Mantener solo la versión más reciente de cada id<br><br>4. Gestione el ciclo de vida de archivos:<br>   - Archivos procesados → mover a carpeta History<br>   - Archivos con errores → mover a carpeta Failed<br><br>5. Configuración del entorno:<br>   - Bronze Lakehouse: LH_Bronze<br>   - Silver Lakehouse: LH_Silver<br><br>¿Puedes generar el notebook completo con código modularizado y comentado?</pre><p>En este caso lo que hacía este notebook era:</p><ul><li>Ingerir ficheros JSON concretos alojados en el LH Bronze</li><li>Pasarle una validación de datos (que el fichero traiga datos correctos)</li><li>Mover ese fichero a una carpeta en función de si pasaba la validación o no</li><li>Si la pasaba, guardar los datos en una tabla Delta en el LH Silver</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1STDNuubRJScGkF2JjYk0A.png" /><figcaption>Ha creado el notebook_x desde 0</figcaption></figure><p>Ahora bien, la realidad es que muchas veces no lo tenemos tan claro o no somos conscientes de todas las instrucciones que debemos darle. No pasa nada, podemos ir iterando sobre lo que nos va devolviendo. Nunca obtenemos el código correcto a la primera (ni a la quinta).</p><h4>Crear notebooks basados en otros notebooks</h4><p>Si lo que necesitas es crear un notebook nuevo pero ya hay otros notebooks validados en el entorno, le podemos decir que se base en uno ya existente.</p><p>Ejemplo:</p><pre>💡 PROMPT:<br><br>Necesito crear un notebook nuevo &quot;y&quot; basado en la misma lógica del notebook &quot;x&quot;.<br><br>Cambios a realizar:<br>1. Nombre del notebook: notebook_y<br>2. FILE_TYPE: y<br>3. Tabla destino: schema.nueva_tabla<br>4. Esquema JSON (estructura API): [indicas la estructura con los campos]<br>5. Campos de validación esperados: [los campos obligatorios]<br><br>Mantener EXACTAMENTE igual:<br>- Lógica de validación (archivos vacíos, schema mutations, registros nulos)<br>- Deduplicación por ID + timestamp<br>- Merge condicional con protección de timestamps<br>- Gestión de archivos (landing → history/failed)<br>- Estructura modular de funciones<br><br>¿Puedes generar el notebook completo aplicando estos cambios?</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UphmaOmcy8T6XMQoUU6xjQ.png" /><figcaption>Ha creado un notebook neuvo “notebook_y” basándose en otro existente “notebook_x”</figcaption></figure><p>Como ves, <strong>cuanto más detalle mejor.</strong> Es como darle a la IA un plano para construir exactamente lo que necesitas.</p><h3>Iterando: Los cambios que pides después</h3><p>Una vez que Copilot te genera el notebook, puedes seguir iterando sobre él si necesitas añadirle cambios.</p><p>Por ejemplo, le pedía que añadiera en el notebook_y una nueva columna en la estructura obligatoria para la validación del fichero:</p><pre>Añade la columna &quot;is_online_company&quot; a la validación.</pre><p>Empieza a trabajar y finalmente vemos como crea el nuevo notebook:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QPRnocNzqKyYpZ1AIgQdGg.png" /><figcaption>Itera sobre el notebook_y añadiendo una modificación</figcaption></figure><p>Aparece en verde lo nuevo, en rojo lo eliminado. Solo tienes que darle a “Keep” para guardar los cambios.</p><p>Luego, a guardar:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/413/1*AiuH1NqFwKcP_YzMnhAJqw.png" /></figure><p>Y listo. Si vas a la interfaz de Fabric ves que se ha añadido tu notebook con el último cambio que le pediste.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xp_6oplipNNizb4mY_JCCQ.png" /><figcaption>Interfaz de Fabric</figcaption></figure><p>En caso del primer notebook, lo verás en su workspace añadido.</p><h3>Y eso es todo</h3><p>Sin haber escrito Python, sin entender PySpark en profundidad, tenía mis primeros notebooks ETL funcionando.</p><p>Mágico, ¿verdad? 😻</p><p><strong>Lo que acabamos de hacer:</strong></p><ul><li>✅ Entendimos qué es PySpark (Power Query en esteroides)</li><li>✅ Comprendimos la arquitectura medallón (Bronze → Silver → Gold)</li><li>✅ Preparamos el setup: Fabric + VSC + Copilot</li><li>✅ Creamos el primer notebook desde 0 con un prompt claro y otro basándonos en otro ya validado.</li><li>✅ Iteramos y mejoramos sobre lo generado.</li></ul><p><strong>Todo sin escribir una sola línea de código.</strong></p><h3>Una nota importante: Usa la IA con cabeza</h3><p>Antes de terminar, quiero dejar clara una cosa.</p><p>Antes escribía posts sobre cómo la IA me ayudaba con DAX o M. Lenguajes que ya dominaba (más o menos). Ahora es diferente: <strong>la IA me está ayudando con PySpark, un lenguaje que desconozco completamente.</strong></p><p>Y eso requiere otra mentalidad.</p><p>No basta con pedirle al agente que genere un notebook. <strong>Tienes que saber qué necesitas.</strong> Tienes que tener claros los objetivos de negocio, la estructura de tus datos, qué esperas que salga al otro lado. Ahora más que nunca.</p><p>Segundo: <strong>poco a poco vas aprendiendo el lenguaje.</strong> No será de la noche a la mañana, pero cada notebook que revises, cada prompt que escribas, te va enseñando.</p><p>Tercero: <strong>siempre pregunta a la IA qué está haciendo el código.</strong> “¿Por qué usaste esta función? ¿Cuál es el riesgo?” No aceptes generaciones a ciegas.</p><p>Porque la IA no es un oráculo. Es una herramienta. Y como toda herramienta, necesita un operario que entienda lo que está haciendo. Úsala con cabeza. 🧠</p><p>¿Qué os ha parecido? ¡Os leo! 😻</p><h3>Referencias y recursos</h3><p>Si quieres profundizar en los temas que hemos tocado hoy, aquí van algunos enlaces útiles:</p><p><strong>📚 Documentación oficial:</strong></p><ul><li><a href="https://learn.microsoft.com/es-es/fabric/">Microsoft Fabric — Documentación oficial</a></li><li><a href="https://learn.microsoft.com/es-es/fabric/data-engineering/how-to-use-notebook">Notebooks en Fabric Data Engineering</a></li><li><a href="https://learn.microsoft.com/es-es/fabric/onelake/onelake-medallion-lakehouse-architecture">Arquitectura medallón en Fabric</a></li></ul><p><strong>👩‍💻 De mi compi y amiga </strong><a href="https://www.linkedin.com/in/monicamesa/"><strong>Mónica Mesa</strong></a><strong>:</strong></p><ul><li><a href="https://www.monicamesa.es/crea-tu-primer-notebook-en-microsoft-fabric-sin-morir-en-el-intento/">Notebooks</a></li><li><a href="https://www.monicamesa.es/category/microsoft-fabric/">Resto de posts de su blog sobre Fabric</a></li></ul><p>Y por favor, sigue también a personas como <a href="https://www.linkedin.com/in/nelson-lopez-centeno/">Nelson</a>, <a href="https://www.linkedin.com/in/diana-aguilera-reyna/">Diana</a>, <a href="https://www.linkedin.com/in/mar-lizana/">Mar Lizana</a>, <a href="https://www.linkedin.com/in/ambynet/">Ana María</a> o <a href="https://www.linkedin.com/in/nexus150/">Ricardo Rincón</a>. Nadie sabe de Fabric como ellos y encima comparten su conocimiento gratis y en español.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eI7PHGIk8AKjoDAVOwGSCw.jpeg" /><figcaption>Sara Alonso Bernardo: Amante de los datos y de los gatos</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ceb57451a16f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Power BI Modelling MCP Server — Cap. 3]]></title>
            <link>https://medium.com/@salonsobernardo/power-bi-modelling-mcp-server-cap-3-08fdf09f88d3?source=rss-935c672d2fb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/08fdf09f88d3</guid>
            <category><![CDATA[power-bi]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[mcp-server]]></category>
            <dc:creator><![CDATA[Sara Alonso B]]></dc:creator>
            <pubDate>Tue, 12 May 2026 16:53:42 GMT</pubDate>
            <atom:updated>2026-05-12T16:53:42.918Z</atom:updated>
            <content:encoded><![CDATA[<h3>Manos a la obra: casos de uso reales en Power BI Desktop</h3><p>¡Hola! Ya estamos de vuelta con el tercer capítulo de esta serie sobre el Power BI Modelling MCP Server. 😻</p><p>En el <a href="https://medium.com/@salonsobernardo/power-bi-modelling-mcp-server-cap-1-cad66742e310">primer capítulo</a> vimos qué es el MCP, qué requisitos necesitas para empezar y en qué se diferencia de trabajar con Copilot y TMDL sobre el PBIP.</p><p>En el <a href="https://medium.com/@salonsobernardo/power-bi-modelling-mcp-server-cap-2-f31bde5ce9fe">segundo capítulo</a> abrimos la caja: herramientas expuestas, agentes, modos de funcionamiento y cómo ve la IA el modelo semántico cuando se conecta a través de MCP.</p><p>Y ahora viene lo que muchos/as estabais esperando: <strong>casos de uso reales</strong>.</p><p>Porque una cosa es entender la teoría y otra muy distinta es ver qué puedes hacer con esto en tu día a día. En este capítulo vamos a ver algunos escenarios reales en los que el MCP me ha ayudado a trabajar de forma más eficiente con mis modelos semánticos.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/352/1*JZmX_w_PYTYghQQbwvp6PA@2x.jpeg" /></figure><h3>Antes de empezar: el entorno que vamos a usar</h3><p>Todos los ejemplos de este artículo los vamos a realizar desde <strong>Visual Studio Code</strong> utilizando <strong>GitHub Copilot Chat en modo agente</strong>, que es el entorno que ya vimos configurado en el capítulo anterior. Es el setup que mejor me funciona en el día a día, además incluye modelos LLMs de varios agentes (Claude, GPT, Gemini…) y el que os recomiendo para seguir los ejemplos.</p><p>Dicho esto, el MCP es agnóstico al cliente: si preferís trabajar con <strong>Claude Desktop</strong> como host, también es posible y los resultados son igualmente buenos. Si os interesa, puedo dedicar otro artículo a mostrar cómo se configura y se usa MCP desde Claude Desktop. ¡Decidme en comentarios! 😉</p><h3>Índice</h3><p>En este artículo veremos:</p><ol><li>Analizar dependencias y detectar objetos sin uso</li><li>Depurar medidas DAX que no funcionan como esperamos</li><li>Refactorizar el modelo de forma guiada</li><li>Documentar automáticamente un modelo semántico completo</li><li>Buenas prácticas y lecciones aprendidas</li></ol><p>Todo con <strong>archivos pbix locales.</strong></p><h3>1. Analizar dependencias y detectar objetos sin uso</h3><p>Los modelos semánticos crecen. Se añaden medidas para pruebas, columnas calculadas que ya no se usan, tablas auxiliares que se quedaron ahí… Con el tiempo, empieza a tener síndrome de Diógenes.</p><p>Limpiar manualmente es tedioso y arriesgado: ¿Quién se atreve a borrar una medida sin estar seguro/a de que no la usa otra?</p><h4>¿Qué le pedimos?</h4><blockquote><em>“Analiza las dependencias entre medidas e identifica qué objetos no están siendo utilizados por ningún otro objeto del modelo.”<br></em>(Recuerda que lo primero es pedirle que se conecte al modelo del archivo pbix que tenemos abierto)</blockquote><h4>¿Qué hace el agente?</h4><p>Invoca las herramientas de análisis y ejecuta las consultas DAX correspondientes:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eBbkwGmLd5pPerKMiA1DVg.png" /></figure><p>El resultado es un mapa de dependencias real: qué medidas dependen de qué columnas, qué medidas llaman a otras medidas, y cuáles quedan “sueltas” sin que nada las referencie.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SoaIR-us22u_MDcF6rSxWA.png" /><figcaption>resultado de la petición de analisis de dependencias</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UFl6oFUpfGx65ZWCfzHHSg.png" /><figcaption>resultado de la petición de analisis de dependencias</figcaption></figure><h4>¿Qué valor tiene esto?</h4><p>Imagina que tu modelo tiene 120 medidas. El agente te identifica 15 que no están siendo referenciadas por ninguna otra medida ni por ningún visual del informe. Eso no significa que debas borrarlas todas automáticamente (algunas pueden estar expuestas directamente en informes), pero sí te da un punto de partida muy claro para una auditoría.</p><p>También puede detectar patrones como <strong>cadenas de dependencias largas</strong> o medidas que dependen de columnas calculadas que a su vez dependen de otras medidas. Ese tipo de complejidad oculta es difícil de ver a simple vista, pero el agente la mapea en segundos.</p><h4>Sin MCP</h4><p>Habrías tenido que usar herramientas externas como Measure Killer, DAX Studio o Tabular Editor para inspeccionar las dependencias, cruzar información manualmente y decidir qué se puede eliminar. Son herramientas maravillosas y funcionan perfectamente si no quieres o no puedes utilizar la IA. ¡Así que no nos olvidemos de ellas!</p><h3><strong>2. Depurar medidas DAX que no funcionan como esperamos</strong></h3><p>Este es mi favorito. Ese momento en el que tienes una medida que <em>debería</em> funcionar, pero los resultados no cuadran y no encuentras el problema. ¿Os ha pasado? A mí más veces de las que me gustaría admitir. 😅</p><p>Aquí os dejo un ejemplo: Tenemos este objeto visual de tabla con 3 medidas. La segunda, “Rules Failing”, corresponde a la medida <em>[Total Rules Failing]</em>. Devuelve “blank” en todas las filas, esto no es lo esperado.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/341/1*sHVG2rExSXsETS81p7449g.png" /><figcaption>La columna “Rules Failing” del objeto visual de tabla corresponde a la medida indicada. Devuelve “blank” en todas las filas.</figcaption></figure><h4>¿Qué le pedimos?</h4><blockquote><em>“La medida [Total Rules Failing] no está devolviendo los valores esperados. Analiza su expresión, sus dependencias y el contexto de filtro para identificar el problema.”</em></blockquote><h4>¿Qué hace el agente?</h4><p>Aquí es donde se nota la diferencia real de MCP. El agente no se limita a leer la expresión DAX como texto. Hace algo mucho más completo:</p><ol><li><strong>Lee la expresión DAX</strong> de la medida.</li><li><strong>Identifica todas las medidas y columnas</strong> de las que depende.</li><li><strong>Lee también las expresiones DAX</strong> de esas medidas dependientes.</li><li><strong>Analiza las relaciones</strong> entre las tablas involucradas para entender el contexto de filtro.</li><li><strong>Señala el problema</strong> y propone una corrección.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/673/1*PSRzULhAhrKIa3D3DLpd6Q.png" /><figcaption>herramientas invocadas</figcaption></figure><p>Ha encontrado el error. En este caso, la medida DAX no estaba correctamente formulada:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*42N5rPU5LxJT8cWjZ-UGpw.png" /><figcaption>diagnóstico</figcaption></figure><p>Me sugiere una serie de correcciones:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XDXJCVmAD6xsiPgoRQPF-g.png" /><figcaption>Correcciones recomendadas y sugerencias</figcaption></figure><p>Le pido que aplique los cambios para corregirla:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yQR3a9BnTMBSUpYeX98fpw.png" /><figcaption>cambios aplicados</figcaption></figure><p>Ya tenemos la medida arreglada y ya muestra los valores esperados:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/348/1*GdGqbplI0FLrQZETVw2lxA.png" /><figcaption>Medida arreglada.</figcaption></figure><h4>Sin MCP</h4><p>Habrías copiado la medida en un chat, pedido ayuda, recibido sugerencias genéricas que podrían o no aplicar a tu modelo concreto, y tendrías que ir verificando hipótesis una a una. Con MCP, el agente tiene contexto completo desde el primer momento.</p><p><em>NOTA: Hemos hecho un ejemplo sencillo con una medida DAX errónea, pero me he encontrado en una situación en la que la medida era correcta y no me devolvía el resultado esperado. El origen de datos de esa medida era una query SQL con un “JOIN” incorrecto de una tabla a otra. El MCP fue capaz de llegar a la query cargada en Power Query y cambiar ese “JOIN”. Desde entonces la medida empezó a devolver el resultado esperado 😍.</em></p><h3>3. Refactorizar el modelo de forma guiada</h3><p>A veces necesitas hacer cambios que afectan a varias partes del modelo a la vez. Renombrar una tabla, cambiar la dirección de un filtro, reorganizar medidas en carpetas, o migrar de un patrón de cálculo a otro.</p><p>Estos cambios en cascada son los que más miedo dan, porque un error puede romper una docena de medidas.</p><h4>¿Qué le pedimos? Ejemplo “reorganización de medidas en carpetas”</h4><blockquote><em>“Organiza todas las medidas del modelo en carpetas de visualización siguiendo esta estructura: ‘Ventas’, ‘Cantidad’, ‘Otros KPIs’. Clasifícalas según su lógica.”</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*TMt4zCTXWdwpQxZ3h1NZbg.png" /><figcaption>Primero analiza cada medida y su función</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/981/1*t8yM6yP99oMgQuVR9I2aJw.png" /><figcaption>Una vez analizadas las medidas pregunta si puede proceder a crear las subcarpetas</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/922/1*HioR04K9hEagoNqVFjElkQ.png" /><figcaption>Una vez analizadas las medidas pregunta si puede proceder a crear las subcarpetas</figcaption></figure><p>El agente lee cada medida, interpreta su función y las distribuye en las carpetas correspondientes. No tienes que decirle una por una dónde va cada medida: entiende el modelo y toma decisiones coherentes.</p><p>Comprobamos los cambios en el modelo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/485/1*j-dgSlrVUuu5_wCHGBQ4zA.png" /></figure><h4>Sin MCP</h4><p>Para este ejemplo tendrías que ir medida a medida analizando dependencias y creando carpetas en función de las necesidades. <br>Con MCP, el agente actúa como un asistente que conoce tu modelo al detalle y te avisa antes de hacer algo peligroso.</p><h3>4. Documentar automáticamente el modelo semántico</h3><p>Y ahora el broche final: la documentación. Quien me conoce sabe que llevo años investigando las mejores formas de documentar sin morir en el intento. Recordad que documentar no es opcional, te lo agradecerán tus compañeros y tu “yo” del futuro (como dice mi querida <a href="https://www.linkedin.com/in/ambynet/">Ana María Bisbé</a>).</p><p>Después de haber analizado dependencias, depurado medidas y refactorizado relaciones, documentar es el paso natural. Ya conoces tu modelo mejor que nunca, y ahora el agente puede dejarlo todo por escrito.</p><p>Con MCP podemos pedirle al agente que <strong>recorra todo el modelo y genere descripciones</strong> para las tablas, columnas y medidas.</p><h4>¿Qué le pedimos?</h4><p>Algo tan sencillo como:</p><blockquote><em>“Conéctate al modelo (que tengo abierto en Desktop), analiza todas las tablas y medidas, y añade una descripción a cada medida que no la tenga.<br>Después genera un documento con toda la documentación”</em></blockquote><h4>¿Qué hace el agente?</h4><p>El agente comienza invocando las herramientas de inspección para entender la estructura del modelo, y una vez que tiene el contexto completo, empieza a generar descripciones coherentes con la lógica real de cada medida. <br>No son descripciones genéricas: el agente lee la expresión DAX, analiza las dependencias y redacta una descripción que refleja lo que la medida realmente calcula.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/957/1*bT2EpAspbHiDbw4Rq2rPPA.png" /><figcaption>Analiza las medidas y crea las descripciones</figcaption></figure><p>Revisamos en el modelo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UdIEGfQCWr_E7WbsnOpvNw.png" /><figcaption>Revisamos descripciones en el modelo</figcaption></figure><p>Después continúa inspeccionando el modelo y con la creación del documento:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/708/1*jx0nV0ZxPi3QYEy-_dqH_g.png" /><figcaption>Crea el documento y concluye con tareas que ha realizado</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/988/1*Bi86LG5jZVLx700Yn4v_kw.png" /><figcaption>Explica el documento que ha creado y donde lo ha depositado</figcaption></figure><p>Ha creado un documento md en la carpeta que tengo abierta en VSC con toda la documentación del modelo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fnC6liNeOBafCPAp8lovMg.png" /></figure><p>Si lo abrimos con VSC podremos leer el documento.</p><p><em>-&gt; Tip: </em><strong><em>Ctrl+Shift+V </em></strong><em>para verlo en formato documento.</em></p><p>Si eres de los que odian la pantalla negra, le puedes pedir que cree el documento en Word, por ejemplo.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oiVSNISuLL01qaUKgpJFIQ.png" /></figure><p>Y nos crea el mismo archivo en Word, en la misma carpeta:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Kw5UfFbzEpQJuDxKc-sKSw.png" /></figure><p>Lo abrimos:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5BOwwy2tE7coHQsPsT1jMA.png" /><figcaption>Documentación en Word</figcaption></figure><h4>¿Qué habríamos hecho sin MCP?</h4><p>Habríamos tenido que ir medida por medida, abrir la definición, entender la lógica, escribir la descripción manualmente y pegarla en el campo correspondiente. Con un modelo de 50 o 100 medidas, eso son horas y horas de trabajo.</p><p>Con el MCP, le dices que documente el modelo y te vas a por un café. Cuando vuelves, está hecho. ☕</p><p>Eso si, NO TE OLVIDES DE REVISAR. La IA nos acompaña, no hace nuestro trabajo.</p><h4>Un punto importante</h4><p>Las descripciones que genera el agente son <strong>coherentes con la nomenclatura y estructura real del modelo</strong>, porque está leyendo el modelo directamente. No inventa nombres de tablas ni asume relaciones que no existen. Eso marca una diferencia enorme frente a pegar una medida DAX en un chat genérico y pedir que te la explique.</p><h3>5. Buenas prácticas y lecciones aprendidas</h3><p>Después de bastante tiempo trabajando con MCP, hay cosas que he aprendido a base de práctica y que creo que os pueden ahorrar más de un susto:</p><h4>Trabaja primero en local</h4><p>Antes de conectar MCP a un modelo publicado en el Service, <strong>practica con modelos abiertos en Desktop</strong>. El entorno local te permite experimentar sin riesgo, no depende de la configuración del tenant y los cambios son inmediatos. Una vez que estés cómoda con el flujo, da el salto a la nube.</p><h4>Revisa antes de dar permiso</h4><p>Cuando el agente te pide permiso para modificar algo, <strong>lee lo que te está diciendo</strong>. La mayoría de las veces la acción será exactamente lo que necesitas, pero hay ocasiones en las que el agente puede interpretar tu instrucción de una forma ligeramente distinta a la que esperabas. Un segundo de revisión te ahorra un problema.</p><h4>Sé específica en tus instrucciones</h4><p>Cuanto más precisa sea tu petición, mejores resultados obtendrás. No es lo mismo decir “arregla las medidas” que “la medida [Ventas MTD] devuelve NULL cuando el mes seleccionado no tiene datos; necesito que devuelva 0 en ese caso”. El contexto importa, y aunque el agente tiene acceso al modelo, tu intención solo la conoces tú.</p><h4>Usa MCP para entender antes de cambiar</h4><p>Antes de pedir un cambio, puedes pedirle al agente que simplemente <strong>inspeccione y te explique</strong>. “Explícame cómo está configurada la relación entre estas dos tablas”, “Muéstrame de qué depende esta medida”. Entender primero y actuar después es siempre más seguro.</p><h4>Combina MCP con TMDL cuando tenga sentido</h4><p>MCP y TMDL no son excluyentes. Hay escenarios donde tiene más sentido crear objetos nuevos o hacer cambios desde TMDL y luego usar MCP para integrarlos, documentarlos o validar que encajan bien en el modelo existente.</p><h4>Cuidado con los modelos grandes</h4><p>En modelos con muchas tablas y medidas, las operaciones de inspección completa pueden tardar más de lo esperado. Si tu modelo es muy grande, puede ser más eficiente pedirle al agente que trabaje sobre un subconjunto específico (“analiza solo las medidas de la tabla factVentas”) en lugar de lanzar un análisis completo de golpe.</p><h3>En el próximo capítulo…</h3><p>Hasta aquí los casos de uso que más utilizo en mi día a día. Espero que os hayan servido para ver que el MCP no es solo un concepto bonito: es una herramienta que, bien usada, cambia realmente cómo trabajamos con los modelos semánticos.</p><p>En el siguiente capítulo veremos cómo usar el MCP en modelos publicados en el Service y Fabric.</p><p>¡Os leo en comentarios! 😻</p><p><strong>Referencias:</strong></p><ul><li><a href="https://learn.microsoft.com/en-us/power-bi/developer/mcp/mcp-servers-overview#power-bi-modeling-mcp-server">Microsoft Learn: MCP Servers Overview</a></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eI7PHGIk8AKjoDAVOwGSCw.jpeg" /><figcaption><em>Sara Alonso Bernardo: Amante de los datos y de los gatos</em></figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=08fdf09f88d3" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Power BI Modelling MCP Server — Cap. 2]]></title>
            <link>https://medium.com/@salonsobernardo/power-bi-modelling-mcp-server-cap-2-f31bde5ce9fe?source=rss-935c672d2fb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/f31bde5ce9fe</guid>
            <category><![CDATA[power-bi]]></category>
            <dc:creator><![CDATA[Sara Alonso B]]></dc:creator>
            <pubDate>Tue, 17 Mar 2026 11:39:29 GMT</pubDate>
            <atom:updated>2026-04-08T11:25:23.938Z</atom:updated>
            <content:encoded><![CDATA[<h3>Abrimos la caja: herramientas, agentes y lo que realmente ve la IA cuando se conecta a tu modelo</h3><p>¡Hola! Ya estamos por aquí de nuevo con un nuevo capítulo sobre el MCP de Power BI. 😻</p><p>En el artículo anterior vimos qué es el <strong>Power BI Modelling MCP Server</strong> y por qué representa un cambio interesante en cómo la IA puede interactuar con los modelos semánticos.</p><p>Hablamos del concepto, de los requisitos para empezar y de cómo se diferencia de trabajar con Copilot y TMDL (<a href="https://medium.com/@salonsobernardo/power-bi-modelling-mcp-server-cap-1-cad66742e310">aquí</a> el capítulo anterior).</p><p>Pero ahora viene la parte interesante.</p><p>¿Qué pasa <strong>una vez que todo está instalado y funcionando?</strong><br> ¿Qué<strong> ve realmente la IA</strong> cuando se conecta al MCP de Power BI?</p><p>En este artículo vamos a abrir la caja y ver qué hay dentro:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BSaObyXnI6B3ZSQNT5m28A.png" /><figcaption>Caja del Power BI Modelling MCP Server: Imagen generada con IA</figcaption></figure><h3>El MCP no expone código, expone herramientas</h3><p>Una de las ideas clave para entender MCP es que <strong>no expone el modelo como código, sino como un conjunto de herramientas estructuradas (<em>tools</em>)</strong> que permiten trabajar directamente sobre él.</p><p>En lugar de pedirle a la IA que nos cree una medida DAX, por ejemplo, y recibir un bloque de código que tú tienes que aplicar, el agente puede invocar directamente herramientas como:</p><pre>create_measure<br>update_measure<br>measure_operations<br>list_tables</pre><p>Esto cambia bastante el modelo mental. La IA ya no genera código que el desarrollador tiene que ejecutar manualmente. Está interactuando con el modelo mediante operaciones definidas que se aplican directamente, siempre que tú le des permiso.</p><p>Ejemplo:</p><p><strong><em>Pedimos al MCP que se conecte al pbix que tenemos abierto</em></strong><em> y que nos </em><strong><em>cree una nueva medida</em></strong><em> que calcule el total de clientes.</em></p><p><em>Vamos viendo los pasos que va dando (de momento solo disponible en inglés) y además nos los va explicando en español. En el momento en que ya tiene que editar el modelo semántico nos saldrá un mensaje de aviso como el que vemos en la imagen de abajo. Tendremos que darle permiso para continuar.</em></p><p><em>En otras ocasiones nos saldrá una ventana en la que tengamos que decirle si “Yes” o si “No” para seguir.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fj_MmAErdAhhVNYxrFwYEw.png" /><figcaption>petición de una medida nueva y MCP pide permiso de edición</figcaption></figure><p><em>Y finalmente me crea la medida y la aplica en el modelo:</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*66xWEnUNVL4nAo5px1NRug.png" /><figcaption>Creación de medida DAX</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*23pxF4a3CgfLsi8Z4TnP1A.png" /><figcaption>Medida DAX que ha creado en el modelo y visualizamos en el pbix abierto.</figcaption></figure><p><em>El MCP, con permisos, y tras analizar el modelo, ha creado directamente la medida sobre el mismo, y organizándolo en la tabla y carpeta que le corresponde (brutal</em>🙃<em>).</em></p><p>Sin el MCP, la IA habría creado la medida sin contexto y con nomenclatura estándar (no adaptada a la de tu modelo), y luego habrías tenido que ir tú a la tabla y carpeta correspondiente a crear la medida y pegar el código.</p><h3>Cómo ve la IA tu modelo semántico</h3><p>Como comentábamos, cuando un agente se conecta al MCP Server, lo primero que hace es <strong>inspeccionar el contexto del modelo</strong>. Obtiene información sobre las tablas, columnas, medidas, relaciones, dependencias y expresiones DAX. En definitiva, una <strong>visión estructurada del modelo semántico.</strong></p><p>Eso le permite, por ejemplo, entender qué tablas existen, detectar las relaciones entre ellas, analizar dependencias entre medidas o evitar crear objetos duplicados.</p><p>Es una diferencia enorme respecto a trabajar únicamente con generación de código, donde la IA no tiene ni idea de lo que ya existe en tu modelo.</p><p>Ejemplo:</p><p><em>En este ejemplo le vamos a</em><strong><em> pedir al MCP que se conecte al pbix que tenemos abierto</em></strong><em> </em><strong><em>y que nos cree una medida que ya existe:</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EFIPv6hbb8XRvKMPShIMow.png" /><figcaption>petición de crear una medida que ya existe</figcaption></figure><p><em>El MCP nos va indicando todos los pasos que va dando y las herramientas que va utilizando como “table_operations” o “measure_operations”. Además nos explica todo lo que va encontrando.</em></p><p><em>En la imagen de arriba nos dice que ya existe una medida que calcula las ventas MTD, que es lo que le estábamos pidiendo que crease, aun así va a leer la expresión DAX y va a seguir buscando.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X4cZF9qLkYDS4X99HWRfXw.png" /><figcaption>sugerencias sobre la creación de otra medida</figcaption></figure><p><em>Termina confirmando que la medida que le he pedido que crease ya está creada, y nos indica la expresión DAX de la misma. Finalmente nos da sugerencias al respecto.</em></p><p>Sin el MCP la IA nos habría creado la medida utilizando nomenclatura estándar, no la de nuestro modelo, y sin verificar si esa medida estaba ya creada o no. Habríamos tenido de copiar y pegar o aplicar nosotros la fórmula DAX... ¡para crear una medida que ya existía!❤️</p><h3>Algunas herramientas que expone el MCP de Power BI</h3><p>El Power BI Modelling MCP Server expone un conjunto de herramientas que permiten interactuar con el modelo semántico.</p><p>Entre las más habituales encontramos:</p><pre>Inspección:     list_tables, list_columns, list_measures, list_relationships<br>Metadata:       get_model_metadata, get_measure_definition<br>Modificación:   create_measure, update_measure, delete_measure, update_measure_description<br>Relaciones:     create_relationship, update_relationship<br>Análisis:       analyze_dependencies, find_unused_measures<br>Operaciones:    measure_operations, table_operations</pre><p>Este listado no pretende ser exhaustivo. El conjunto exacto de herramientas puede evolucionar mientras la funcionalidad esté en preview.</p><p>Lo importante es el concepto: <strong>el MCP no ofrece acceso al modelo mediante código libre, sino mediante operaciones estructuradas que la IA puede descubrir e invocar.</strong></p><h3><strong>Los agentes que utilizan el MCP</strong></h3><p>El MCP no es un asistente en sí mismo. Es un protocolo que permite que distintos agentes de IA interactúen con el modelo semántico.</p><p>Para entender cómo funciona el ecosistema MCP, es útil distinguir tres conceptos:</p><ul><li><strong>Host</strong>: la interfaz que aloja al agente y gestiona la conexión con el servidor MCP actuando como cliente (por ejemplo, Claude Desktop, Visual Studio Code).</li><li><strong>Agente</strong>: el sistema que usa un modelo para razonar, planificar y ejecutar acciones, como conectarse a un servidor MCP (por ejemplo, Claude, GitHub Copilot Chat).</li><li><strong>Modelo</strong>: el motor de razonamiento que procesa el lenguaje y genera respuestas (por ejemplo, Claude Opus 4.6, Claude Sonnet 4.6, GPT-5.4).</li></ul><p>Entre los agentes gratuitos podemos encontrar <strong>Claude</strong> en su plan básico, que opera desde hosts como <strong>Claude Desktop</strong> y puede conectarse a servidores MCP definidos en su configuración. También existen distintos clientes MCP open-source desarrollados por la comunidad.</p><p>Entre los agentes de pago, uno de los escenarios más habituales es <strong>GitHub Copilot Chat</strong>, que opera dentro de <strong>Visual Studio Code</strong> (hablábamos de esto en el <a href="https://medium.com/@salonsobernardo/power-bi-modelling-mcp-server-cap-1-cad66742e310">post anterior</a>) y permite al usuario elegir el modelo subyacente (Claude Opus 4.6, GPT-5.4, entre otros) para interactuar con el modelo semántico a través del servidor MCP.</p><p>El protocolo MCP está diseñado para ser agnóstico tanto al modelo de IA como al agente que lo utiliza, por lo que cualquier combinación compatible de host, agente y modelo puede conectarse al servidor MCP.</p><h3>Cómo funciona el agente en Visual Studio Code</h3><p>Cuando utilizamos MCP desde Visual Studio Code normalmente lo hacemos a través de <strong>Copilot Chat en modo agente</strong>.</p><p>En la barra del chat aparecen varios elementos que definen cómo se ejecutará el agente.</p><p>Por ejemplo, los que suelo utilizar yo:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/334/1*PgdSjzn5ybOmBEDKqUjTeA.png" /></figure><p>Cada uno de estos elementos representa una dimensión distinta del comportamiento del agente.</p><h4>Contexto del agente</h4><p>El primer selector define <strong>dónde puede actuar el agente</strong>. En el entorno actual de VS Code pueden aparecer opciones como:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/311/1*zG_rUXX-5FjVu7yrcwGk9w.png" /></figure><p><em>Local: </em>El agente trabaja dentro del entorno local del desarrollador. Puede interactuar con archivos del proyecto, extensiones instaladas, repositorios locales y herramientas disponibles en la máquina, como servidores MCP configurados localmente. Este suele ser el contexto más habitual cuando trabajamos con MCP durante el desarrollo.</p><p><em>Copilot CLI: </em>El agente se ejecuta de forma autónoma en segundo plano, sin bloquear tu trabajo en el editor. Es útil para tareas bien definidas que no requieren interacción constante, como implementar un plan ya elaborado o ejecutar cambios en paralelo.</p><p><em>Cloud: </em>El agente ejecuta las acciones en infraestructura remota y se integra con pull requests de GitHub, pensado para colaboración en equipo.</p><h4>Modo de funcionamiento del agente</h4><p>El segundo selector define <strong>cómo actúa el asistente</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/323/1*OfjSzmTLsqKugyBI0XSdjg.png" /></figure><p><em>Ask:</em> Modo conversacional clásico. El modelo responde preguntas o explica conceptos, pero no ejecuta herramientas automáticamente.</p><p><em>Agent: </em>Modo agente. El asistente puede planificar acciones, descubrir herramientas disponibles y ejecutarlas automáticamente. <strong>Este es el modo necesario para que el agente utilice herramientas MCP.</strong></p><p><em>Plan:</em> Modo de planificación. El modelo analiza el problema y propone una estrategia paso a paso, pero no la ejecuta por sí solo. Una vez revisado y ajustado el plan, puedes pasarlo a un agente (Local o Copilot CLI) para que lo implemente.</p><p>Desde este mismo menú también aparece la opción <strong>Configure Custom Agents</strong>, que permite crear agentes personalizados definiendo sus herramientas e instrucciones.</p><h4>Modelo de IA utilizado</h4><p>El tercer selector define <strong>qué modelo de IA utiliza el agente</strong> para razonar y generar respuestas. Dependiendo de la configuración y del tipo de cuenta en GitHub pueden aparecer modelos como:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/345/1*ofGEeND7OQ6eY2KnyJ5E0w.png" /></figure><p><em>Auto</em> — VS Code selecciona automáticamente el modelo más adecuado según el contexto.</p><p><em>Claude Opus 4.6</em> — modelo avanzado de Anthropic orientado a razonamiento complejo.</p><p><em>Claude Sonnet 4.6</em> — modelo de Anthropic más ligero y rápido para tareas generales.</p><p><em>GPT-5.3-Codex</em> — modelo de OpenAI orientado a tareas de programación.</p><p><em>GPT-5.4</em> — modelo general de OpenAI para análisis y razonamiento.</p><p>Los modelos disponibles dependen de tu suscripción y pueden variar con el tiempo.</p><p>El modelo seleccionado es el que el agente utiliza para interpretar la instrucción del usuario y decidir qué herramientas invocar.</p><p>Yo personalmente suelo utilizar <em>Claude Opus 4.6</em>, que es el que mejores resultados me ha dado en este contexto.</p><h3>Cómo encaja todo esto con MCP</h3><p>Cuando utilizamos MCP en este entorno, el flujo real sigue una cadena bien definida. El usuario lanza una petición al agente (Copilot en modo Agent), que a su vez consulta al modelo de IA. Este descubre las herramientas disponibles a través del protocolo MCP, las invoca, y el MCP Server se encarga de traducir esas llamadas en consultas DAX contra el modelo semántico de Power BI.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FU-U_wFEFHoUM9cc6f4MEQ.png" /><figcaption>Imagen generada con IA</figcaption></figure><pre>Usuario → Agente → Modelo de IA → Descubre herramientas MCP → Invoca herramientas → MCP Server → Modelo semántico</pre><p>El punto clave es que el modelo de IA nunca toca Power BI directamente. El MCP Server actúa como puente: recibe las intenciones del agente, las convierte en operaciones concretas sobre el modelo semántico y devuelve los resultados. Esa separación es lo que permite que el agente trabaje con datos reales sin necesidad de conocer los detalles internos de Power BI.</p><h3>El MCP no sustituye al modelador</h3><p>Es importante tener claro algo: el MCP no sustituye al modelador ni toma decisiones arquitectónicas por sí solo. Lo que hace es <strong>darle a la IA una vía estructurada para interactuar con el modelo semántico</strong>.</p><p>Eso abre la puerta a automatizar tareas que hasta ahora eran manuales y repetitivas: documentar el modelo, generar medidas DAX y sus descripciones, analizar dependencias entre tablas y columnas, o auditar la estructura en busca de inconsistencias.</p><p>Pero el diseño del modelo sigue siendo responsabilidad humana. El MCP es una herramienta que amplifica lo que el modelador ya sabe hacer, no algo que lo reemplaza.</p><h3>En el próximo capítulo…</h3><p>¿Qué os ha parecido? Espero que os sirva para entender un poco mejor cómo funciona el Power BI Modelling MCP Server y qué herramientas pone a disposición del agente. En el próximo capítulo entraremos ya en harina con casos de uso reales 😊.</p><p>¡Te leo en comentarios! 😻</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eI7PHGIk8AKjoDAVOwGSCw.jpeg" /><figcaption>Sara Alonso Bernardo: Amante de los datos y de los gatos</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f31bde5ce9fe" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Power BI Modelling MCP Server — Cap. 1]]></title>
            <link>https://medium.com/@salonsobernardo/power-bi-modelling-mcp-server-cap-1-cad66742e310?source=rss-935c672d2fb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/cad66742e310</guid>
            <category><![CDATA[power-bi-mcp-server]]></category>
            <category><![CDATA[tmdl]]></category>
            <category><![CDATA[semantic-model]]></category>
            <dc:creator><![CDATA[Sara Alonso B]]></dc:creator>
            <pubDate>Thu, 05 Mar 2026 13:04:11 GMT</pubDate>
            <atom:updated>2026-03-05T14:28:56.961Z</atom:updated>
            <content:encoded><![CDATA[<h3>Cuando la IA deja de sugerir… y empieza a interactuar con tu modelo</h3><p>¡Hola! ¿Cómo estáis?</p><p>Estoy por aquí otra vez con un nuevo post y… ¡en el inicio de una nueva serie!🙃. En esta ocasión quiero empezar con un post un poquito más teórico para ponernos en situación y entender bien de lo que vamos a hablar, prometo que los siguientes serán más prácticos.</p><p>Os voy a hablar de algo que me tiene realmente fascinada: el <strong>Power BI Modelling MCP Server</strong>.</p><p>Aunque es bastante novedoso, ya se leen bastantes cositas sobre él, y si alguien estuvo en el eventazo de AgentCamp el pasado 28 de febrero y se pasó por mi sesión, probablemente ya tenga una idea de por dónde van los tiros. También quería mencionar a <a href="https://www.linkedin.com/in/javiersanchezrivero/"><strong>Javier Sánchez</strong></a>, que siempre es inspiración y tiene también unos cuantos artículos en su <a href="https://losdatoscomoherramienta.blogspot.com/">blog</a> sobre lo que vamos a tratar.</p><p>Pero antes de entrar en materia, vamos a ponernos un poco en contexto.</p><h3>Índice</h3><p>En este artículo veremos:</p><ol><li>Qué es realmente el Power BI Modelling MCP Server</li><li>Si funciona en local, en la nube o en ambos</li><li>Qué requisitos técnicos y de gobierno necesitas</li><li>En qué se diferencia de usar Copilot con TMDL sobre el PBIP</li><li>Qué implicaciones tiene en seguridad y gobierno</li><li>Por qué esto puede cambiar cómo desarrollamos modelos semánticos</li></ol><h3>Un pequeño contexto</h3><p>Durante años hemos trabajado el modelo semántico de Power BI casi como artesanos.</p><ul><li>Medidas escritas a mano.</li><li>Refactorizaciones cuidadas.</li><li>Documentación que “ya haremos después”.</li><li>Dependencias revisadas manualmente…</li></ul><p>Con el tiempo y con la incorporación de la IA en nuestro día a día han ido apareciendo herramientas que han cambiado poco a poco esta forma de trabajar.</p><p>Primero llegó<strong> ChatGPT </strong>para echarnos un cable de forma genérica.</p><p>Luego <strong>Power BI como proyecto con PBIP</strong>, que nos permitió tratar el modelo como un proyecto versionable.</p><p>Después llegó la edición en <strong>TMDL</strong>, que nos abrió la puerta a editar el modelo directamente como texto y a integrarlo en flujos de desarrollo más cercanos al mundo del software.</p><p>Y ahora aparece algo distinto y, sinceramente, bastante fascinante: <strong>el Power BI Modelling MCP Server.</strong></p><p>Y no, no es simplemente “Copilot mejorado”. Es un cambio en cómo la IA puede <strong>interactuar con el modelo semántico</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zh85vfFCnWtweufaNVpUIg.jpeg" /><figcaption>Imagen generada con IA</figcaption></figure><h3>1. ¿Qué es realmente el MCP Server?</h3><p>El <strong>Power BI Modelling MCP Server</strong> es la implementación en Power BI del estándar <strong>Model Context Protocol (MCP)</strong>.</p><p>En términos sencillos, lo que hace es exponer el modelo semántico como un conjunto de <strong>herramientas estructuradas</strong> que un asistente de IA puede invocar.</p><p>Esto cambia completamente la forma de interacción.</p><p>La IA ya no está limitada a generar texto o sugerir código. Ahora puede interactuar con el modelo mediante operaciones definidas.</p><p>Dependiendo de los permisos del usuario puede, por ejemplo, inspeccionar la estructura del modelo, ejecutar consultas DAX, analizar dependencias, crear o modificar medidas, actualizar relaciones o añadir descripciones, analizar errores en consultas y solventarlos..</p><p>Todo esto ocurre <strong>a través de herramientas estructuradas</strong>, no mediante generación de texto libre.</p><p>Otro punto importante es que el MCP no accede a los datos fila a fila como lo haría una consulta SQL, opera sobre la <strong>capa semántica del modelo</strong>, es decir, sobre su metadata, sus definiciones y sus dependencias.</p><p>Eso significa que la IA no trabaja sobre una copia textual del modelo, sino sobre el <strong>modelo real</strong>.</p><h3>2. ¿Funciona en local o en la nube?</h3><p>La respuesta corta es: <strong>en ambos escenarios</strong>, aunque con algunos matices.</p><p>Por un lado, puede trabajar con modelos abiertos en <strong>Power BI Desktop</strong>. Sí, como lo lees. Con decirle que se conecte a un pbix abierto bastaría para empezar a trabajar con él. Esto resulta especialmente útil en escenarios de desarrollo, refactorización o documentación. Al tener el modelo activo en local, la interacción suele ser bastante directa y cómoda para experimentar. Y como suelo añadir: “Déjalo que trabaje mientras tú puedes dedicarte a otras cosas”.</p><p>Por otro lado, también puede conectarse a <strong>modelos semánticos publicados en Power BI Service o Microsoft Fabric</strong>. Aquí entran en juego otros factores como los permisos, el licenciamiento y la configuración del tenant.</p><p>Y es precisamente en este escenario donde suelen aparecer los primeros bloqueos si algo no está correctamente configurado.</p><h3>3. Requisitos técnicos y de gobierno</h3><p>Aquí es donde conviene ser bastante precisa, porque hay varios elementos que tienen que alinearse para que todo funcione.</p><ol><li>Lo primero es que la funcionalidad debe estar <strong>habilitada a nivel de tenant</strong>. En la práctica esto significa que un administrador de Power BI o Fabric debe activar la característica correspondiente, que actualmente se encuentra en preview. Sin esa habilitación, ningún cliente MCP podrá conectarse a modelos publicados <strong>en la nube:</strong></li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MtkRuUn61RkJPnuAZH4Ghg.png" /></figure><p>Sin embargo, cuando se trabaja con un modelo abierto localmente en Power BI Desktop, la interacción se realiza contra el motor local del modelo y no depende de esta configuración del tenant.</p><p>Esto implica que <strong>muchos desarrolladores podrán empezar a experimentar con MCP incluso si su tenant corporativo aún no lo ha habilitado</strong>, siempre que trabajen con modelos locales en Desktop.</p><p>2. En segundo lugar está el <strong>licenciamiento</strong>. El MCP no es una licencia en sí misma, pero depende del entorno en el que se utilice. Por ejemplo, las licencias trial no permiten conectarse a modelos semánticos publicados en la nube mediante MCP. Para trabajar con modelos publicados necesitarás una licencia adecuada como Pro, Premium Per User o un entorno Fabric con capacidad asignada.</p><p>3. Otro punto crítico son los <strong>permisos sobre el modelo semántico</strong>. Para interactuar con un modelo publicado necesitarás al menos permiso <strong>Build</strong>. Sin ese permiso no podrás acceder al modelo desde herramientas externas, incluido MCP. Y si además quieres que la IA pueda modificar el modelo, entonces necesitarás permisos de edición en el workspace correspondiente.</p><p>4. También necesitarás trabajar con un <strong>cliente compatible con MCP</strong>. En muchos escenarios actuales esto implica utilizar <a href="https://code.visualstudio.com/download"><strong>Visual Studio Code</strong></a>, junto con la <strong>extensión</strong> necesaria para conectarse a <strong>Power BI Modelling MCP Server:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/757/1*l1gUzGV6ygIUr9wO5yZ2XQ.png" /><figcaption>Extensión para VSC</figcaption></figure><p>Solo tienes que buscar la extensión en VS Code e instalarla.</p><p>5. También necesitaremos <a href="https://code.visualstudio.com/docs/copilot/overview"><strong>GitHub Copilot</strong></a><strong> y Copilot Chat</strong>. Para ello necesitarás una cuenta activa de GitHub Pro (personal o business), con la que te conectarás a VS Code, una licencia de Copilot y las extensiones correspondientes en VS Code. <strong>Copilot Chat actúa en este caso como el cliente de IA </strong>que puede invocar las herramientas expuestas por el MCP Server.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/737/1*oN7vbD9M9w7FvtAoR8R0aw.png" /><figcaption>Extensión para VSC</figcaption></figure><h3>4. ¿En qué se diferencia de usar Copilot con TMDL sobre el PBIP?</h3><p>Aquí está probablemente la diferencia conceptual más importante.</p><p>Cuando utilizamos Copilot con <strong>PBIP y TMDL </strong>(PBIP cargado en VS Code y editando el código TMDL que define el modelo), la IA trabaja sobre archivos. Genera texto, modifica fragmentos de código y propone cambios que luego nosotros revisamos y aplicamos.</p><p>En cambio, con <strong>MCP</strong> la IA puede invocar herramientas que interactúan directamente con el modelo semántico.</p><p>Para verlo más claro, imaginemos un ejemplo sencillo.</p><p>Supongamos que pedimos a Copilot algo como:</p><blockquote>“Cambia la relación entre dimProduct y factVentas para que sea unidireccional desde Product hacia Ventas”.</blockquote><p>En un flujo tradicional con Copilot, lo que obtendremos será el fragmento TMDL correspondiente. Copilot editará el archivo, nosotros revisaremos el cambio y después lo aplicaremos.</p><p>Pero Copilot realmente no sabe si esa relación existe exactamente con ese nombre, si hay ambigüedades en el modelo o si hay otras relaciones que puedan verse afectadas. Está trabajando sobre <strong>texto</strong>.</p><p>Si damos esa misma instrucción a Copilot, conectado al <strong>MCP Server</strong>, el proceso es distinto. El servidor puede localizar la relación real en el modelo, analizar su cardinalidad, revisar posibles ambigüedades o dependencias y aplicar el cambio si el usuario tiene permisos suficientes. En este caso no se está editando un archivo. Se está <strong>operando directamente sobre el modelo</strong>.</p><h4>Visualmente sería algo así</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*T-u46hOoogiX-9GNerJ1aA.jpeg" /><figcaption>Imagen generada con IA</figcaption></figure><h4>Principales diferencias</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/796/1*NpBOLyfEtfp8DSxo7i4kPg.png" /></figure><h4>¿Cuándo usar Copilot + TMDL sobre PBIP?</h4><p>Copilot sigue siendo extremadamente útil cuando estás trabajando <strong>a nivel de código del modelo</strong>.</p><p>Por ejemplo cuando quieres generar medidas DAX, refactorizar expresiones, crear tablas de calendario, escribir documentación o preparar cambios para versionado en Git.</p><p>Es decir, cuando estás trabajando <strong>en el proyecto como código</strong>.</p><p>Yo suelo utilizarlo para crear nuevos objetos dentro del modelo.</p><h4>¿Cuándo usar MCP?</h4><p>El MCP tiene más sentido cuando necesitas <strong>interactuar con el modelo como sistema</strong>.</p><p>Por ejemplo para analizar relaciones, revisar dependencias entre medidas, identificar objetos no utilizados, documentar automáticamente el modelo o inspeccionarlo antes de aplicar cambios.</p><p>Aquí la IA no está generando código, sino <strong>interactuando directamente con el modelo semántico</strong>.</p><p>Yo, personalmente lo utilizo siempre que necesito “arreglar” medidas incorrectas y que no encuentro el problema, cambios complejos en queries de origen, por ejemplo. Es decir, MCP trabaja literalmente como mi asistente.</p><h4>En resumen:</h4><p>Copilot + TMDL te ayuda a escribir el modelo sobre el PBIP.<br>MCP permite que la IA interactúe con él.</p><h3>5. Consideraciones de seguridad y gobierno</h3><p>Es fácil entusiasmarse con esta tecnología, pero también es importante entender sus límites.</p><p>El MCP respeta completamente el modelo de seguridad de Power BI. No puede hacer nada que el usuario no tenga permitido hacer manualmente.</p><p>Los permisos Build y de edición siguen siendo determinantes, y en entornos corporativos cualquier uso de este tipo de herramientas debe alinearse con las políticas de gobierno del dato.</p><p>La IA no salta la seguridad del sistema. Opera dentro de ella.</p><h3>6. Por qué esto puede cambiar cómo desarrollamos modelos semánticos</h3><p>La evolución ha sido bastante clara.</p><ul><li>PBIP permitió <strong>versionar los modelos</strong>.</li><li>TMDL permitió <strong>tratarlos como código y editarlos</strong>.</li><li>El MCP Server permite que la IA <strong>interactúe con el modelo semántico mediante herramientas estructuradas</strong>.</li></ul><p>Esto no sustituye al modelador ni elimina la necesidad de arquitectura. Pero sí cambia el tipo de tareas que podemos delegar.</p><p>La ventaja competitiva ya no está solo en escribir DAX rápido. Está en <strong>diseñar bien el modelo y saber orquestar la IA dentro de un marco de gobierno sólido</strong>.</p><p>Y eso, bien aplicado, empieza a parecerse bastante a una <strong>Automatización 360 con madurez 😊.</strong></p><p>¿Os ha gustado? Aunque ya he dado algunas pinceladas de cómo empezar a usarlo, espero que os haya gustado lo suficiente como para convenceros de que es una pasada y que merece la pena probarlo.</p><p>¡Os leo en comentarios!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eI7PHGIk8AKjoDAVOwGSCw.jpeg" /><figcaption>Sara Alonso Bernardo: Amante de los datos y de los gatos</figcaption></figure><p>Referencias:</p><p><a href="https://learn.microsoft.com/en-us/power-bi/developer/mcp/mcp-servers-overview#power-bi-modeling-mcp-server">https://learn.microsoft.com/en-us/power-bi/developer/mcp/mcp-servers-overview#power-bi-modeling-mcp-server</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cad66742e310" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Automatización 360 en Power BI: Cap.4]]></title>
            <link>https://medium.com/@salonsobernardo/automatizaci%C3%B3n-360-en-power-bi-cap-4-8b528a47da4a?source=rss-935c672d2fb0------2</link>
            <guid isPermaLink="false">https://medium.com/p/8b528a47da4a</guid>
            <category><![CDATA[tmdl]]></category>
            <category><![CDATA[power-bi]]></category>
            <category><![CDATA[dax]]></category>
            <dc:creator><![CDATA[Sara Alonso B]]></dc:creator>
            <pubDate>Fri, 16 Jan 2026 11:55:16 GMT</pubDate>
            <atom:updated>2026-02-06T09:11:56.212Z</atom:updated>
            <content:encoded><![CDATA[<h3>Automatización 360 en Power BI: Cap.4 — Documentación técnica automatizada con las funciones INFO.VIEW y TMDL.</h3><p>¡Hola! ¿Cómo estáis? 😊<br>Abrimos este nuevo año con el último capítulo de esta serie de <strong>Automatización 360 en Power BI</strong> 🚀</p><p>En el primer capítulo aprendimos a generar una tabla calendario en M en cuestión de minutos (sin tener que montar pasos manuales en Power Query).<br>En el segundo, vimos cómo generar medidas y descripciones en un “pis pas” gracias a la vista TMDL y la ayuda de ChatGPT.<br>Y en el tercero, optimizamos el modelo con Measure Killer y su nuevo script para TMDL (maravillita).</p><p>Hoy aprenderemos a generar <strong>documentación técnica</strong> en pocos minutos con un <strong>script TMDL</strong> que incorpora las funciones DAX <strong>INFO.VIEW</strong>.</p><p>Es increíble cómo, combinando estas piezas, se pueden montar flujos tan potentes. Y antes de empezar, quiero dar las gracias a <a href="https://www.linkedin.com/in/monicamesa/"><strong>Mónica Mesa</strong></a> (compañera de comunidad y MVP), que fue quien me descubrió este script. No dejéis de seguirla que ella ha sido una de mis inspiraciones en esto del TMDL junto al gran <a href="https://www.linkedin.com/in/javiersanchezrivero/">Javier Sánchez </a>(síguele también).</p><p>¡Mil gracias, Mónica! ❤️ Qué maravilla de comunidad.</p><p>Éstos son todos los capítulos que componen la serie:</p><ol><li><a href="https://medium.com/@salonsobernardo/automatizaci%C3%B3n-360-en-power-bi-cap-1-generaci%C3%B3n-de-una-tabla-calendario-en-m-con-tmdl-y-chatgpt-e0e51c5eb708">Generación de una tabla calendario en M con TMDL y ChatGPT</a></li><li><a href="https://medium.com/@salonsobernardo/automatizaci%C3%B3n-360-en-power-bi-cap-2-e63d55feeb44">Generación de medidas y sus descripciones con TMDL y ChatGPT.</a></li><li><a href="https://medium.com/@salonsobernardo/iautomatizaci%C3%B3n-360-en-power-bi-cap-3-optimizaci%C3%B3n-del-modelo-con-measure-killer-y-tmdl-7b40a31757ef">Optimización del modelo con Measure Killer y TMDL.</a></li><li><strong>Documentación técnica automatizada con las funciones INFO.VIEW y TMDL -&gt; 👈Estamos aquí.</strong></li></ol><p>¡Vamos allá!</p><h3>Cap.4 — Documentación técnica automatizada con las funciones INFO.VIEW y TMDL.</h3><p>En el punto en el que estamos, ya solo nos queda una pieza para cerrar el círculo: <strong>la documentación del modelo</strong>. Yo suelo dividirla en dos bloques:</p><ul><li><strong>Documentación técnica</strong> (orientada a developers y al mantenimiento del modelo).</li><li><strong>Documentación para cliente/negocio</strong>, más visual, más “presentable” y enfocada a explicar el qué y el porqué de los KPIs.</li></ul><p>Hoy nos vamos a centrar en la <strong>documentación técnica</strong>. Para la documentación de cliente, os sugiero que veáis los posts que escribí hace unos meses sobre cómo utilizar <strong>Model Documenter,</strong> <a href="https://medium.com/@salonsobernardo/power-bi-docutips-ii-b58db0dcfce5">aquí</a>.</p><p>En posts anteriores ya os he hablado de las funciones <strong>INFO</strong> y <strong>INFO.VIEW</strong>, incluso combinándolas con <strong>Power Automate</strong>, para exprimir todo lo que podemos sacar del propio modelo. Pues hoy vamos un paso más allá: vamos a <strong>integrarlas en un script TMDL</strong> para generar documentación técnica en minutos. Y ya sabéis lo que pasa cuando juntamos TMDL + automatización… que salen cosas bastante serias 😄</p><p>Antes os mencionaba ese script, a Mónica le daba las gracias por dármelo a conocer, pero el primer agradecimiento debería ser para <a href="https://www.linkedin.com/in/davidkofod/">David Kofod Hanna</a>, el autor del script. Es un lujo contar con estos genios tan generosos. Está disponible en la web de la comunidad de Fabric, y os lo dejo <a href="https://community.fabric.microsoft.com/t5/TMDL-Gallery/Model-Documentation-INFO-VIEW-Functions/td-p/4795219">aquí</a>:</p><pre>createOrReplace<br><br> table &#39;Model Documentation&#39;<br>  column Type<br>   displayFolder: Attributes<br>   summarizeBy: none<br>   isNameInferred<br>   sourceColumn: [Type]<br><br>   annotation SummarizationSetBy = Automatic<br><br>  column Name<br>   displayFolder: Attributes<br>   summarizeBy: none<br>   isNameInferred<br>   sourceColumn: [Name]<br><br>   annotation SummarizationSetBy = Automatic<br><br>  column Description<br>   displayFolder: Attributes<br>   summarizeBy: none<br>   isNameInferred<br>   sourceColumn: [Description]<br><br>   annotation SummarizationSetBy = Automatic<br><br>  column Location<br>   displayFolder: Attributes<br>   summarizeBy: none<br>   isNameInferred<br>   sourceColumn: [Location]<br><br>   annotation SummarizationSetBy = Automatic<br><br>  column Expression<br>   displayFolder: Attributes<br>   summarizeBy: none<br>   isNameInferred<br>   sourceColumn: [Expression]<br><br>   annotation SummarizationSetBy = Automatic<br><br>  partition &#39;Model Documentation&#39; = calculated<br>   mode: import<br>   source =<br>     <br>     VAR _columns =<br>         SELECTCOLUMNS(<br>             FILTER(<br>                 INFO.VIEW.COLUMNS( ),<br>                 [Table] &lt;&gt; &quot;Model Documentation&quot; &amp;&amp; NOT ( [IsHidden] )<br>             ),<br>             &quot;Type&quot;, &quot;Column&quot;,<br>             &quot;Name&quot;, [Name],<br>             &quot;Description&quot;, [Description],<br>             &quot;Location&quot;, [Table],<br>             &quot;Expression&quot;, [Expression]<br>         )<br>     VAR _measures =<br>         SELECTCOLUMNS(<br>             FILTER(<br>                 INFO.VIEW.MEASURES( ),<br>                 [Table] &lt;&gt; &quot;Model Documentation&quot; &amp;&amp; NOT ( [IsHidden] )<br>             ),<br>             &quot;Type&quot;, &quot;Measure&quot;,<br>             &quot;Name&quot;, [Name],<br>             &quot;Description&quot;, [Description],<br>             &quot;Location&quot;, [Table],<br>             &quot;Expression&quot;, [Expression]<br>         )<br>     VAR _tables =<br>         SELECTCOLUMNS(<br>             FILTER(<br>                 INFO.VIEW.TABLES( ),<br>                 [Name] &lt;&gt; &quot;Model Documentation&quot; &amp;&amp; [Name] &lt;&gt; &quot;Calculations&quot;<br>                     &amp;&amp; NOT ( [IsHidden] )<br>             ),<br>             &quot;Type&quot;, &quot;Table&quot;,<br>             &quot;Name&quot;, [Name],<br>             &quot;Description&quot;, [Description],<br>             &quot;Location&quot;, BLANK( ),<br>             &quot;Expression&quot;, [Expression]<br>         )<br>     VAR _relationships =<br>         SELECTCOLUMNS(<br>             INFO.VIEW.RELATIONSHIPS( ),<br>             &quot;Type&quot;, &quot;Relationship&quot;,<br>             &quot;Name&quot;, [Relationship],<br>             &quot;Description&quot;, BLANK( ),<br>             &quot;Location&quot;, BLANK( ),<br>             &quot;Expression&quot;, [Relationship]<br>         )<br>     RETURN<br>         UNION( _columns, _measures, _tables, _relationships )</pre><p>Y tan sencillo como ir a la vista TMDL de nuestro informe, pegarlo y ejecutar el script:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KAoiW9WGR1L44xlV9h5SJQ.png" /><figcaption>Script pegado y ejecutado en la vista TMDL de Power BI</figcaption></figure><p>Como podéis ver, el script ha generado <strong>una tabla calculada</strong> a la derecha con la documentación del modelo.<br>Ahora vamos a la <strong>vista de tabla</strong> para ver exactamente qué información nos ha creado (y cómo queda por dentro):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g__JkYNNnKXFQAZHgM-K5g.png" /><figcaption>Tabla calculada de documentación en la vista de tabla</figcaption></figure><p>La tabla contiene 5 columnas que si queréis, podéis renombrar:</p><ul><li>Type: Tipo de objeto. Puede ser columna, medida, tabla o relación.</li><li>Name: El nombre del objeto.</li><li>Description: La descripción que hemos puesto al objeto. No solo a medidas, se puede añadir descripción a todos los objetos.</li><li>Location: En qué tabla se encuentra el objeto, si se trata de una columna o medida.</li><li>Expression: La expresión DAX o la expresión de la relación.</li></ul><p>En esta tabla tenemos toda la info técnica que necesitamos. Ahora podemos organizarla como más nos guste:</p><ul><li>Podemos crear en una página nueva un visual de tabla con esta información.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J3nUFKwB21V-uJ7hyy9G9g.png" /></figure><ul><li>También podemos usar Power Automate para automatizarla. Ejemplo: Creamos un excel con esta info y que se vaya actualizando a medida que va cambiando el modelo. Si queréis que os cuente el flujo para conseguir esto decidme y escribo un post sobre ello.</li></ul><p>En fin: con esto ya tenéis toda la información necesaria para <strong>documentar vuestro modelo de datos</strong>. A partir de aquí, podéis darle la forma que queráis: dentro del propio informe o fuera, automatizar la generación cuando haya cambios… o simplemente usarlo como punto de partida para tener una base sólida.</p><p>¿Qué os ha parecido? A mí me parece la bomba.</p><p>En los 6 años que llevo trabajando como desarrolladora de Power BI he visto claramente cómo Microsoft ha ido apostando cada vez más por la <strong>automatización y la IA</strong>, y cómo lo ha ido incorporando en sus herramientas. Y, sinceramente, el impacto en productividad y ahorro de tiempo es brutal.</p><p>Y, por supuesto, gracias a la comunidad de <strong>Fabric &amp; Power BI</strong> por compartir estas joyas. Queda ya muy atrás aquello de hacer pantallazos del modelo, pegarlos en un Word y volver a comentarlo todo cada vez que había un cambio. 😅</p><p>Y con esto, documentación lista en minutos. Fin del sufrimiento. 😌</p><p>Si te animas a probarlo, mi recomendación es simple: intégralo en tu flujo de trabajo desde ya. Tu “yo del futuro” te lo va a agradecer.</p><p>Y damos por terminada la serie 🎉… de momento. Porque, seamos sincer@s: la <strong>IA</strong> y la <strong>automatización</strong> en Power BI ya deberían formar parte de nuestro día a día.</p><p>Y hablando de automatización… ¿habéis leído sobre el <strong>Power BI Modeling MCP Server</strong>? Si aún no, corred a leer <a href="https://losdatoscomoherramienta.blogspot.com/?m=1">el blog de <strong>Javi Sánchez</strong></a>, porque es oro. Yo estoy convencida de que va a dar para un capítulo (o varios) aquí en el blog 😉.</p><p>Dejadme en comentarios qué os gustaría que tratáramos a continuación sobre automatización, IA, TMDL, Power Automate o Power BI en general, y prepararé un post (o una mini guía) para intentar ayudaros.</p><p>¡Mil gracias por leerme! ❤️</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eI7PHGIk8AKjoDAVOwGSCw.jpeg" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8b528a47da4a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>