Forem: Daniel Gomez

Construcción de Agentes con Microsoft Foundry

Daniel Gomez — Mon, 22 Dec 2025 20:35:20 +0000

La inteligencia artificial está evolucionando rápidamente desde simples modelos de lenguaje hacia agentes inteligentes: sistemas capaces de razonar, ejecutar acciones, usar herramientas y colaborar entre sí.

Microsoft Foundry surge como una plataforma clave para que podamos construir, gestionar y escalar agentes de IA de según el escenario o la solución que necesitemos implementar.

¿Qué es Microsoft Foundry?

Microsoft Foundry es una plataforma dentro del ecosistema de Azure AI que nos será de utilidad para:

Construir agentes inteligentes
Orquestar flujos complejos de IA
Integrar modelos (OpenAI, Azure OpenAI, OSS)
Conectar herramientas, APIs y datos empresariales
Gobernar, evaluar y escalar soluciones de IA

Foundry no es solo “usar un modelo”, sino crear sistemas de IA completos, listos para producción.

¿Qué es un agente de IA?

Un agente es más que un prompt. En Foundry, un agente tiene:

🧠 Modelo base (GPT-4, GPT-4o, Phi, etc.)
🎯 Objetivo claro (qué debe lograr)
🧰 Herramientas (APIs, funciones, búsquedas, código)
🗂️ Contexto (memoria, datos, estado)
🔁 Capacidad de razonamiento y acción

Ejemplo:

Un agente que recibe una solicitud, consulta una base de datos, llama a una API, razona sobre la información y devuelve una respuesta estructurada.

Creando nuestro primer agente en Microsoft Foundry

Paso 1: Crear un proyecto en Foundry

Acceder al Azure AI Foundry Portal: ai.azure.com/
Crea un Foundry Project
Asocia: -- Suscripción de Azure -- Resource Group -- Región

Esto será el contenedor de nuestros agentes, evaluaciones y flujos.

Paso 2: Definir el modelo base

Seleccionar el modelo que impulsará al agente:

GPT-4 / GPT-4o → razonamiento avanzado
Phi-3 / Phi-4 → agentes livianos, edge, bajo costo
Modelos custom → casos especializados

Ejemplo:

Modelo: GPT-4o
Uso: razonamiento + herramientas

Paso 3: Definir el rol y comportamiento del agente

Aquí defines la identidad del agente.

Ejemplo de system prompt:

Eres un agente experto en soporte técnico de productos Microsoft.
Tu objetivo es resolver problemas de forma clara, precisa y paso a paso.
Si necesitas información adicional, debes solicitarla antes de responder.

💡 Tip: Un buen agente tiene:

Objetivo claro
Límites explícitos
Tono definido

Paso 4: Agregar herramientas (Tools)

Las herramientas son lo que convierten un LLM en un agente real.

Tipos comunes:

🔌 APIs REST
📊 Bases de datos
📁 Document search (RAG)
🧮 Funciones custom (Azure Functions)

Ejemplo conceptual:

{
  "name": "getUserOrders",
  "description": "Obtiene órdenes de un usuario",
  "parameters": {
    "userId": "string"
  }
}

El agente decide cuándo y cómo usar la herramienta.

Paso 5: Memoria y contexto

Foundry permite:

Memoria por conversación
Contexto persistente
Historial controlado

Esto es clave para:

Agentes conversacionales
Flujos largos
Seguimiento de tareas

Paso 6: Probar y evaluar el agente

Antes de producción:

Simula conversaciones
Evalúa respuestas
Mide: -- Precisión -- Consistencia -- Seguridad -- Costos

Foundry incluye herramientas de evaluación automática y humana.

5. Orquestación de múltiples agentes

Uno de los puntos fuertes de Foundry es crear sistemas multi-agente:

Ejemplo:

🧑‍💼 Agente coordinador
📊 Agente analista
🛠️ Agente ejecutor

Cada uno con responsabilidades claras.

Esto permite:

Mayor modularidad
Mejor razonamiento
Escalabilidad real

6. Seguridad y gobernanza

Foundry está diseñado para entornos empresariales:

🔐 Identity (Entra ID)
📜 Control de prompts
🛡️ Filtros de contenido
📈 Observabilidad
💰 Control de costos

Ideal para organizaciones que no pueden improvisar con IA.

7. Casos de uso reales

Algunos ejemplos donde Foundry brilla:

🤖 Soporte técnico inteligente
📄 Agentes de análisis de documentos
🧠 Copilots internos
📊 Agentes de análisis de datos
🔄 Automatización de procesos empresariales

8. Buenas prácticas

✔ Diseñar agentes con responsabilidades definidas
✔ Usar herramientas, no prompts gigantes
✔ Evalúar constantemente
✔ Pensar en agentes como software, no como chatbots
✔ Empiezar simple, escalar después

Gracias por leer!

Espero que esta guía te haya ayudado a entender mejor sobre los agentes de IA y cómo Microsoft Foundry puede utilizarse para diseñarlos de forma estructurada según las soluciones de IA a implementar.

¡Sigamos en contacto! 🚀 X / LinkedIn - esdanielgomez.com

Hablemos de la Web Agéntica (o Web 4.0)

Daniel Gomez — Wed, 21 May 2025 16:37:57 +0000

Algo está cambiando profundamente en cómo usamos internet, cómo desarrollamos software y cómo interactuamos con la inteligencia artificial. Quizás lo estás sintiendo también: no es solo una nueva herramienta, es una nueva forma de pensar la web.

A esto muchos le están empezando a llamar Web Agéntica, o simplemente, Web 4.0.

Si la Web 1.0 era de solo lectura, la Web 2.0 nos dejó interactuar y colaborar (redes sociales, blogs), y la Web 3.0 nos habló de descentralización y datos conectados (blockchain, web semántica), ahora la Web 4.0 introduce agentes autónomos capaces de razonar, actuar y colaborar entre ellos.

¿Qué es exactamente la Web Agéntica?

Es un nuevo paradigma en el que los usuarios ya no interactúan directamente con aplicaciones o APIs, sino con agentes inteligentes que actúan como intermediarios activos, autónomos y contextualmente conscientes.

Estos agentes pueden:

Recordar lo que hiciste o preguntaste antes.
Aprender sobre tus intereses.
Elegir las mejores herramientas para ayudarte.
Colaborar entre sí para resolver problemas más complejos.

Y todo esto sucede de forma fluida, conversacional y muchas veces, invisible para el usuario.

¿Por qué esto es tan distinto a lo que ya conocemos?

En la Web actual (2.0 o 3.0), si quieres lograr algo, tú tomas la iniciativa:

Buscas en Google.
Llamas APIs desde código.
O integras herramientas específicas.

En la Web 4.0, tú solo declaras una intención, y un agente hace lo demás.

Veamos una comparación simple:

Acción	Web 2.0 / 3.0	Web Agéntica (4.0)
Buscar un vuelo.	Tú lo haces en 3 sitios distintos.	El agente lo hace por ti.
Pedir resumen de reunión.	Usas app, cargas video, esperas.	El agente ya sabe y lo resume automáticamente.
Crear un dashboard.	Tú diseñas, conectas, pruebas.	El agente decide qué mostrar y por qué.

De APIs a agentes que razonan sobre APIs

Aquí es donde probablemente a todos se nos va a volar un poco la cabeza:

En este nuevo modelo, los agentes ya no ejecutan APIs como pasos fijos, sino que razonan sobre cuándo, cómo y con qué combinarlas.

Esto es posible gracias a protocolos como el Model Context Protocol (MCP), que permiten que múltiples componentes (modelos, APIs, fuentes de datos, memorias) se comuniquen en tiempo real, de forma interoperable.

El agente puede leer documentación, entender el propósito de un endpoint, generar el código necesario y ejecutarlo. Todo, según el contexto de tu solicitud.

Modelos que seleccionan modelos

Aquí entramos en terreno aún más fascinante.

Hay modelos diseñados solo para elegir qué otros modelos usar. En lugar de que tú decidas si usar GPT-4, un modelo de embeddings o uno de clasificación… un modelo selector lo hace por ti.

Así se ve este sistema en acción:

Rol del modelo	Función principal	Ejemplo práctico
Selector (router)	Decide cuál modelo usar según la tarea.	“¿Esto es una búsqueda, generación o clasificación?”
Especialista	Ejecuta una función específica.	GPT-4, modelo de visión, embeddings, etc.
Orquestador	Coordina múltiples especialistas y sintetiza resultados.	Unifica respuestas, resuelve conflictos, da salida final.

Esto permite un comportamiento adaptativo: el sistema puede cambiar de estrategia si tu pregunta cambia, si no hay datos disponibles, o si hay que combinar varios enfoques.

La memoria: la joya que lo conecta todo

Uno de los cambios más profundos es que los agentes ahora tienen memoria de largo plazo.

Eso significa que pueden:

Recordar tu estilo de escritura.
Saber que estás planificando un viaje.
Aprender tus horarios o rutinas.
Adaptarse si hoy estás más técnico, o más emocional.

Y lo más interesante: esta memoria puede ser modular y segura. Tú decides qué recuerdan y qué olvidan. La experiencia se vuelve más personalizada con cada interacción, sin necesidad de reconfigurar todo cada vez.

Todo esto ya está pasando

Ya no hablamos de futuro, sino de presente. Plataformas como OpenAI, Microsoft Azure, LangChain, Cohere, entre otras, ya están construyendo sobre esta lógica.

Ejemplos reales:

Microsoft Copilot ya incorpora memorias y planeación de tareas complejas.
Semantic Kernel en Azure facilita que los agentes planeen tareas, guarden memoria y combinen funciones.
Algunos agentes incluso escriben código para integrar APIs nuevas que no conocían antes.

Un nuevo capítulo para la web, y para nosotros

Lo que más me emociona no es únicamente la parte tecnológica, sino el potencial humano detrás de todo esto.

Estamos entrando en una era donde los sistemas entienden intenciones, colaboran con nosotros, y recuerdan lo que somos. Una web donde la inteligencia es distribuida, contextual y profundamente humana.

La Web Agéntica no será solo una herramienta más. Será un nuevo lugar donde pensar, crear y vivir.

Y tú, ¿ya estás hablando con tus agentes?

¡Sigamos en contacto! 🚀 X / LinkedIn - esdanielgomez.com

Let’s Talk About Agentic Web (or Web 4.0)

Daniel Gomez — Wed, 21 May 2025 16:36:29 +0000

Something is changing deeply in how we use the internet, how we develop software, and how we interact with artificial intelligence. Maybe you’re feeling it too: it’s not just a new tool, it’s a new way of thinking about the web.

Many are starting to call this Agentic Web, or simply, Web 4.0.

If Web 1.0 was read-only, Web 2.0 let us interact and collaborate (social media, blogs), and Web 3.0 talked about decentralization and connected data (blockchain, semantic web), now Web 4.0 introduces autonomous agents capable of reasoning, acting, and collaborating with each other.

What exactly is the Agentic Web?

It’s a new paradigm where users no longer interact directly with applications or APIs, but with intelligent agents that act as active, autonomous, and context-aware intermediaries.

These agents can:

Remember what you did or asked before.
Learn about your interests.
Choose the best tools to help you.
Collaborate among themselves to solve more complex problems.

And all this happens smoothly, conversationally, and often invisibly to the user.

Why is this so different from what we know?

In today’s web (2.0 or 3.0), if you want something done, you take the initiative:

You search on Google.
You call APIs from code.
Or you integrate specific tools.

In Web 4.0, you just declare an intention, and an agent does the rest.

Here’s a simple comparison:

Action	Web 2.0 / 3.0	Agentic Web (4.0)
Search for a flight.	You check 3 different sites yourself.	The agent does it for you.
Ask for a meeting summary.	You upload the video and wait.	The agent already knows and summarizes automatically.
Create a dashboard.	You design, connect, and test.	The agent decides what to show and why.

From APIs to agents that reason about APIs

Here’s where things might blow everyone’s mind a bit:

In this new model, agents no longer execute APIs as fixed steps, but reason about when, how, and which ones to combine.

This is possible thanks to protocols like the Model Context Protocol (MCP), which allow multiple components (models, APIs, data sources, memories) to communicate in real time, interoperably.

The agent can read documentation, understand an endpoint’s purpose, generate the necessary code, and execute it—all based on the context of your request.

Models that select models

Now we enter even more fascinating territory.

There are models designed just to choose which other models to use. Instead of you deciding whether to use GPT-4, an embeddings model, or a classifier… a selector model decides for you.

Here’s how this system works:

Model Role	Main Function	Practical Example
Selector (router)	Decides which model to use depending on the task.	“Is this a search, generation, or classification?”
Specialist	Performs a specific function.	GPT-4, vision model, embeddings, etc.
Orchestrator	Coordinates multiple specialists and synthesizes results.	Unifies answers, resolves conflicts, provides final output.

This enables adaptive behavior: the system can change strategies if your question changes, if no data is available, or if multiple approaches need to be combined.

Memory: the jewel that connects it all

One of the deepest changes is that agents now have long-term memory.

That means they can:

Remember your writing style.
Know you’re planning a trip.
Learn your schedules or routines.
Adapt if today you’re more technical or more emotional.

And the coolest part: this memory can be modular and secure. You decide what they remember and what they forget. The experience becomes more personalized with each interaction, without needing to reconfigure everything every time.

This is already happening

It’s no longer just the future—it’s the present. Platforms like OpenAI, Microsoft Azure, and others are already building on this logic.

Real examples:

Microsoft Copilot now includes memory and planning for complex tasks.
Semantic Kernel on Azure helps agents plan tasks, save memory, and combine functions.
Some agents even write code to integrate new APIs they didn’t know before.

A new chapter for the web, and for us

What excites me most isn’t just the technology — it’s the human potential it unlocks.

We’re entering an era where systems understand intentions, collaborate with us, and remember who we are. A web where intelligence is distributed, contextual, and deeply human.

The Agentic Web isn’t just another tool. It’s a new space to think, create, and live.

And you, are you already talking to your agents?

Let’s keep in touch! 🚀 X / LinkedIn - esdanielgomez.com

Creating a Scheduled Task in Sitecore

Daniel Gomez — Tue, 26 Nov 2024 04:30:39 +0000

Hey there, Sitecore developers! Ever wished you could automate those repetitive tasks that eat up your time? Well, you’re in luck. This short tutorial is here to show you how to create scheduled tasks in Sitecore.

Whether it’s sending out reminder emails or publishing content at specific times, setting up these tasks can make your life a lot easier. Let’s dive in and see how you can get your Sitecore environment running like a well-oiled machine with minimal effort.

General steps:

Write the Task Code.
Create a Command.
Set up the Scheduler

With that in mind, let's get started.

1. Write the Task Code

The first step in creating a scheduled task in Sitecore is to write the code that will be executed. This involves creating a class with a method that contains the logic you want to run. For example, we can have a class named ScheduledJob with a method called Execute.

Here’s a simple example:

using System;
using Sitecore.Diagnostics;

namespace YourNamespace
{
    public class ScheduledJob
    {
        public void Execute()
        {
            try
            {
                // Your logic here
                Log.Info("From the scheduled task in Sitecore.", this);
            }
            catch (Exception ex)
            {
                Log.Error("Oops, something went wrong in the task.", ex, this);
            }
        }
    }
}

2. Create a Command in Sitecore

Once you have your task code ready, the next step is to create a command in Sitecore. This command will reference the class and method we created earlier, allowing Sitecore to execute it on schedule.

To create and manage the command we will need:

In Sitecore, go to /sitecore/system/tasks/commands.
Create a New Command Item, for example: Scheduled Job Command.
Configure the Command, referencing the class and method created previously.

The command item could look like this:

3. Set Up the Scheduler in Sitecore

After creating the command, the next step is to set up the scheduler in Sitecore. This scheduler will determine when and how often the task runs.

To set up the scheduler item we will need:

In Sitecore, go to /sitecore/system/tasks/schedules.
Create a New Scheduler Item, for example: Scheduled Job.
Configure the Scheduler.

The scheduler item could look like this:

The fields in this item have the following objectives:

Command: command created in the previous step.
Schedule: Define the interval at which the task should run (e.g., daily, weekly).
Items: Specify any Sitecore items if needed.
Async: Check this box if the task should run asynchronously.
Auto Remove: Use this field to automatically remove the schedule definition when the task expires.

For the schedule format, this value example 20231125|99990101|127|12.00:00 means:

Start Date: November 25, 2023 (20231125)
End Date: Never ends (99990101)
Days of the Week: Sunday, Monday, and Saturday (127)
Time: 12:00 PM (noon) (12.00:00)

And with all this, the task can now be executed automatically as scheduled, or manually as well in the case of tests:

Thanks for reading!

Automating tasks in Sitecore can make your life a lot easier. By writing the task code, creating a command, and setting up a scheduler, we can streamline operations and free up time for more important things.

If you have any questions or ideas in mind, it'll be a pleasure to be able to be in communication with you, and together exchange knowledge with each other.

X / LinkedIn - esdanielgomez.com

Happy scheduling!

Sitecore Pipeline to add rel="noopener noreferrer" to a General Link

Daniel Gomez — Tue, 29 Oct 2024 07:41:18 +0000

In this tutorial, we will explore how to process fields in a Sitecore context using a custom pipeline processor. Specifically, we will handle LinkField types to ensure that external links include the rel="noopener noreferrer" attribute for enhanced security.

We’ll start by examining the C# code for the ExternalLinks class, which processes the LinkField and adds the necessary attributes. Following that, we’ll look at the corresponding pipeline configuration in the .config file, which integrates our custom processor into the Sitecore renderField pipeline.

By the end of this tutorial, you’ll understand how to create and configure a custom pipeline processor in Sitecore to manage external links effectively. Let’s dive in!

Pipeline C# Code

In this code we process a field in a Sitecore context, specifically handling LinkField types. It ensures that external links have the rel="noopener noreferrer" attribute added for security purposes.

public class ExternalLinks
{
    public void Process(RenderFieldArgs args)
    {
        Assert.ArgumentNotNull(args, "args");

        if (Sitecore.Context.Site.DisplayMode == Sitecore.Sites.DisplayMode.Edit) //return;

        var field = FieldTypeManager.GetField(args.GetField());

        if (field is LinkField linkField)
        {
            if (linkField.IsInternal || string.IsNullOrEmpty(linkField.Url)) return;

            args.Parameters.Add("rel", "noopener noreferrer");
        }
    }
}

Pipeline .config

And now we have here the configuration of the pipeline. This configuration sets up the ExternalLinks class to be executed as part of the renderField pipeline in Sitecore. It ensures that the ExternalLinks processor runs after the GetLinkFieldValue processor. Additionally, it includes a setting to control the protection of external links with a target="_blank" attribute.

<configuration xmlns:patch="http://www.sitecore.net/xmlconfig/">
    <sitecore>
        <settings>
          <setting name="ProtectExternalLinksWithBlankTarget" value="false" />
        </settings>
        <pipelines>
            <renderField>
                <processor type="Foundation.Infrastructure.Pipelines.ExternalLinks, Foundation.Infrastructure" patch:after="processor[@type='Sitecore.Pipelines.RenderField.GetLinkFieldValue, Sitecore.Kernel']"/>
            </renderField>
        </pipelines>
    </sitecore>
</configuration>

Thanks for reading!

And that's it! We created a custom pipeline processor in Sitecore to handle LinkField types. The ExternalLinks class ensures external links include the rel="noopener noreferrer" attribute for security. We integrated this processor into the renderField pipeline, ensuring it runs after the GetLinkFieldValue processor. This setup helps maintain the security and integrity of external links in your Sitecore application.

If you have any questions or ideas in mind, it'll be a pleasure to be able to be in communication with you, and together exchange knowledge with each other.

X / LinkedIn - esdanielgomez.com

Searching Items in Sitecore without Solr Indexes

Daniel Gomez — Tue, 22 Oct 2024 15:31:00 +0000

In Sitecore, we often need to build lists, or search for a particular item, to achieve this, most of the time we use searches with Solr, but sometimes we need an alternative or a fallback to ensure that items are obtained correctly.

In this article we will review how to perform a search without using Solr, considering recursive programming.

Example to obtain a list of child items with several levels in the content tree

The ManualSearch class will help us to find specific Sitecore items by searching through a hierarchy of items starting from a given root. It looks for items that match a particular template ID and collects them in a list. The search skips items named _subcontent and continues recursively through each item’s children.

The updated version ensures that it handles null values gracefully and caches the template ID for better performance. This makes the search process efficient and thorough, ensuring we get all the items that meet our criteria.

public class ManualSearch
{
    //With this global collection we will save all the items that meet the conditions in our search.
    private List<Item> ListItems { get; set; }

    //This is the general method that starts the operation.
    public List<Item> GetListItems(Item itemPath)
    {
        ListItems = new List<Item>();
        GetSitecoreItems(itemPath);
        return ListItems;
    }

    //Method that performs recursive search
    private void GetSitecoreItems(Item item)
    {
        foreach (Item child in item.Children)
        {
            //Here you can skip certain items in your search
            if (child.Name.Equals("_subcontent")) continue; 

            //You can do a deep search, if any of the children have the template you need, it will depend on the depth of the tree you have.
            if (child.Children.Any(x => x.TemplateID == new ID(YOUR_TEMPLATE_ID)))
            {
                child.Children
                    .Where(x => x.TemplateID == new ID(YOUR_TEMPLATE_ID))
                    //You can add here all the other conditions you need.
                    .ToList().ForEach(x => { ListItems.Add(x); });
            }
            else
            {
                //In this section we continue with the search
                GetSitecoreItems(child);
            }
        }
    }
}

Example to obtain a specific item in the content tree

This example starts with the SearchItem method, which takes a root item and a field value, and calls the GetSitecoreItemFromChildren method to perform the actual search.

If a match is found, it returns the matching item; otherwise, it continues the search through the children until a match is found or all children are checked.

public class ManualSearch
{
    //This is the general method that starts the operation.
    public Item SearchItem(Item rootItem, string fieldValue)
    {
        return GetSitecoreItemFromChildren(rootItem, fieldValue);
    }

    //Method that performs recursive search
    public Item GetSitecoreItemFromChildren(Item item, string fieldValue)
    {
        foreach (Item child in item.Children)
        {
            if (child.Name.Equals("_subcontent")) continue;
            var children = child.Children?.ToList() ?? new List<Item>();

            if (children.Any(x => x.TemplateID == new ID("YOUR_TEMPLATE_ID")))
            {
                var resultItem = children.FirstOrDefault(x => x.Fields["YOUR_FIELD_VALUE"].Value == fieldValue && x.TemplateID == new ID("YOUR_TEMPLATE_ID"));
                if (resultItem != null) return resultItem;
            }
            else
            {
                var result = GetSitecoreItemFromChildren(child, fieldValue);
                if (result != null) return result;
            }
        }

        return null;
    }
}

And that's it! With the previous examples we can perform a search in Sitecore without Solr indexes to obtain a list of items or a particular item, considering conditionals and additional parameters in a search.

Thanks for reading!

If you have any questions or ideas in mind, it'll be a pleasure to be able to be in communication with you, and together exchange knowledge with each other.

X / LinkedIn - esdanielgomez.com

Solr Search in Sitecore

Daniel Gomez — Mon, 07 Oct 2024 21:42:24 +0000

When working on specific components in Sitecore that require listing or searching for particular items, conducting an in-depth search is essential. To achieve this, we will use Solr Search, which provides robust indexing and search capabilities tailored to meet our needs.

General search with Solr

Considering the path of the item from which we want to perform the search, whether it is the homepage, a folder or any particular page, we can create an instance of SitecoreIndexableItem, perform a query, and obtain the expected results of that search.

var rootItem = database.GetItem("ITEM_PATH");
var indexable = new SitecoreIndexableItem(rootItem);

using (var context = ContentSearchManager.GetIndex(indexable).CreateSearchContext())
{
    var query = context.GetQueryable<SearchResultItem>()
        .Filter(x => x.TemplateId == new ID("TEMPLATE_ID_FOR_SEARCH"));

    var resultItems = query?.Select(s => s.GetItem()).ToList() ?? new List<Item>();
    // YOUR LOGIC WITH THE RESULTS
}

Now, let's look at scenarios where additional attributes need to be analyzed in the query conditional.

Solr Search with specific attributes

To search for items using a specific field, we can create a BaseSearchResultItem inheritance to define the solr attributes we want to use to establish the search query.

For example, below we will see an example where we have items from authors, and we want to search for a particular one according to its ID.

public class AuthorSearchResultItem : BaseSearchResultItem
{
    [IndexField("author_id_s")]
    public string AuthorId { get; set; }

    [IndexField("author_name_s")]
    public string AuthorName { get; set; }
}

And this is the example of the search:

var db = Sitecore.Context.Database;
var locationRoot = db.GetItem("ITEM_PATH");

var indexable = new SitecoreIndexableItem(locationRoot);

using (var context = ContentSearchManager.GetIndex(indexable).CreateSearchContext())
{
    var query = context.GetQueryable<AuthorSearchResultItem>()
        .Filter(x => x.TemplateId == new ID("TEMPLATE_ID_FOR_SEARCH"))
        .Filter(x => x.AuthorId == authorId);

    var authorResult = query.FirstOrDefault();
    var authorItem = author.GetItem();
}

Let's look at an additional case.

Solr Search with predicates

To establish specific conditionals of type AND or OR, we can use predicates when establishing the query to obtain the search results.

var predicateOr = PredicateBuilder.True<SearchResultItem>();
var predicateAnd = PredicateBuilder.True<SearchResultItem>();

predicateAnd = predicateAnd.And(s => s.AuthorId == authorId);

using (var context = ContentSearchManager.GetIndex(indexable).CreateSearchContext())
{
    var query = context.GetQueryable<SearchResultItem>()
        .Where(predicateAnd)
        .Where(predicateOr)
        .Take(10);

    var results = query.GetResults();
}

And that's it! With the previous examples we can perform a Solr search in Sitecore to obtain a list of items or a particular item, considering conditionals and additional parameters in a query.

Thanks for reading!

If you have any questions or ideas in mind, it'll be a pleasure to be able to be in communication with you, and together exchange knowledge with each other.

X / LinkedIn - esdanielgomez.com

Sitecore Experience Editor Tip to show instructions to Content Authors

Daniel Gomez — Wed, 25 Sep 2024 03:39:47 +0000

When creating components in Sitecore, we try to make them as manageable from the Experience Editor as possible, but there are times when we have to give additional instructions so that the Content Author can use the placeholders properly, add options, modify content, etc.

In this article, we'll see how to use a helper to display a special message for the Experience Editor, this could be an informative or warning one.

Helper code

In this code we will see two methods to display a message in the Experience Editor, validating that it is in that mode according to the context, and with special styles.

public static class ExperienceEditorMessage
{
    public static HtmlString Info(string message)
    {
        return !Context.PageMode.IsExperienceEditorEditing 
            ? new HtmlString(string.Empty) 
            : new HtmlString($"<div style=\"background: #AADBEE; margin: 10px 0px; padding: 10px 8px; border-radius: 8px; font-size: 12px;\"><b style=\"font-weight: bold;\">Info</b>: {message}</div>");
    }

    public static HtmlString Warning(string message)
    {
        return !Context.PageMode.IsExperienceEditorEditing 
            ? new HtmlString(string.Empty) 
            : new HtmlString($"<div style=\"background: #f8f8a0; margin: 10px 0px; padding: 10px 8px; border-radius: 8px; font-size: 12px;\"><b style=\"font-weight: bold;\">Warning</b>: {message}</div>");
    }
}

Example from a view

From the view of a component, this way we can display the expected message.

@ExperienceEditorMessage.Info("This is an Experience Editor message for general information.")

@ExperienceEditorMessage.Warning("This is an Experience Editor warning message.")

This is the result in the Experience Editor:

Thanks for reading!

And that's it! With this proposed solution we can show a special message in the Experience Editor for Content Authors. If you have any questions or ideas in mind, it'll be a pleasure to be able to be in communication with you, and together exchange knowledge with each other.

X / LinkedIn - esdanielgomez.com

Add rel="nofollow noopener noreferrer" to external links in Sitecore

Daniel Gomez — Fri, 20 Sep 2024 05:07:16 +0000

In many of the solutions we develop with Sitecore, for external links we need to add the nofollow noopener noreferrer values of the rel attribute for the <a> tags, to have a final markup like this:

<a href="https://www.example.com" target="_blank" rel="nofollow noopener noreferrer">Go to the page</a>

These values allow us to:

nofollow: Tells search engines not to follow the link.
noopener: Stops the new page from controlling the original page.
noreferrer: Hides the link source from the new page.

With this goal in mind, we are going to see in this tutorial a proposal to add the rel attribute in an elegant way in our solution.

Sitecore Link Attributes Settings Item

The goal will be to add the values nofollow noopener noreferrer to the attribute, but it does not necessarily have to be for all external links, exceptions could surely be established according to the client's needs. Keeping these considerations in mind, in Sitecore we can define the following template, with its respective standard values:

Template:

Standard Values:

The logic on .NET side

To obtain the attribute and its values to add to external links, we will use a helper that allows sending the URL to be analyzed as a parameter, and returning the expected attribute, or an empty string from a view.

C# Code

In the helper we will have to obtain the values of the settings item specified above, and to have a better performance of this solution, we will add the setting values to cache to obtain them quickly later.

public static class LinkAttributesHelper
{
    private static LinkAttributesSettings _linkAttributesSettings = null;

    public static string GetLinkAttributes(string url)
    {
        if (Sitecore.Context.PageMode.IsExperienceEditor) return string.Empty;
        if(!IsAbsoluteUrl(url)) return string.Empty; 
        if (string.IsNullOrEmpty(url)) return string.Empty;

        var settings = GetLinkAttributesSettings();
        if(settings==null) return string.Empty;

        if (string.IsNullOrEmpty(settings.RelAttributeValues)) return string.Empty;
        if (string.IsNullOrEmpty(settings.WhitelistedDomains) || !settings.WhitelistedDomains.Split(' ').Any()) return string.Empty;

        var isWhitelistedDomain = false;

        foreach (var domain in settings.WhitelistedDomains.Split(' '))
        {
            if (url.Contains(domain))
            {
                isWhitelistedDomain = true;
            }         

            if(domain == "'self'" || domain == "self")
            {
                if (url.Contains(Sitecore.Context.Site.HostName))
                {
                    isWhitelistedDomain = true;
                }
            }
        }

        return !isWhitelistedDomain ? $"rel=\"{settings.RelAttributeValues}\"" : string.Empty;
    }

    private static bool IsAbsoluteUrl(string url)
    {
        return Uri.TryCreate(url, UriKind.Absolute, out _);
    }

    private static LinkAttributesSettings GetLinkAttributesSettings()
{
    var modelMapper = new ModelMapper(); // To get the values of an Item
    var cacheManager = ServiceLocator.ServiceProvider.GetService<ICacheManager>();

    var cacheKey = $"link-attributes-{<YourLinkAttributesSettingsItem>.ToShortID()}";

    _linkAttributesSettings = cacheManager.Get<LinkAttributesSettings>(cacheKey);
    if (_linkAttributesSettings == null)
    {
        _linkAttributesSettings = modelMapper.MapItemToNew<LinkAttributesSettings>(
            Sitecore.Context.Database.GetItem(<YourLinkAttributesSettingsItem>));

        cacheManager.Add(cacheKey, _linkAttributesSettings, TimeSpan.FromMinutes(30));
    }

    return _linkAttributesSettings;
}

public class LinkAttributesSettings
{
    [RawValueOnly]
    public string RelAttributeValues { get; set; }
    [RawValueOnly]
    public string WhitelistedDomains { get; set; }
}

cshtml View code

From the view of a component, we can have something like this:

<a href="@Model.Url" target="@Model.Target"
   @Html.Raw(LinkAttributesHelper.GetLinkAttributes(Model.Url))>
    @Model.Text
</a>

Note: For this example, we assume that Model object has the attributes of a General Link, that is, the Url and the Target.

Thanks for reading!

And that's it! With this proposed solution we can add nofollow noopener noreferrer values to the rel attribute for external links in Sitecore. If you have any questions or ideas in mind, it'll be a pleasure to be able to be in communication with you, and together exchange knowledge with each other.

X / LinkedIn - esdanielgomez.com

Sitecore PowerShell Script to delete unused items in the Media Library

Daniel Gomez — Tue, 26 Mar 2024 20:12:44 +0000

Hi! In this blog we will find a Sitecore PowerShell script to be able to eliminate multimedia elements that are not being used.

The general idea is to analyze the items or children of a specific path and verify that those items don't have any references. If the item has no reference, then it will be deleted.

Sitecore PowerShell Script:

$mediaLibraryRootPath = "master:/sitecore/media library"

# HasReference determines if the specified item is referenced by any other item.
function HasReference {
    param(
        $Item
    )

    $linkDb = [Sitecore.Globals]::LinkDatabase
    $linkDb.GetReferrerCount($Item) -gt 0
}

# Get-MediaItemWithNoReference gets all the items in the media library and checks if they have references. If the item has no reference, the media item is saved locally and then deleted.
function Get-MediaItemWithNoReference {

    $items = Get-ChildItem -Path $mediaLibraryRootPath -Recurse | 
        Where-Object { $_.TemplateID -ne [Sitecore.TemplateIDs]::MediaFolder }

    $i = 0
    foreach($item in $items) {
        if(!(HasReference($item))) {
            $i = $i + 1
            Write-Output "$($i). $($item.ItemPath)"
            $item | Remove-Item 
        }
    }
}

# Run the script.
Write-Output "Items to delete:"
Get-MediaItemWithNoReference

Example:

This is an example of an unused image that can be removed using the script:

Thanks for reading!

I hope this script has been useful to you. If you have any questions or ideas in mind, it'll be a pleasure to be able to be in communication with you, and together exchange knowledge with each other.

X / LinkedIn - esdanielgomez.com

Backup Sitecore Media Library items with a PowerShell script

Daniel Gomez — Tue, 06 Feb 2024 17:02:05 +0000

Hi! In this blog, we'll find a Sitecore PowerShell script to be able to backup Media Library items in a zip file on the server.

$dataFolder = "C:\inetpub\wwwroot\<YOUR_SITE>\Data"
$mediaLibraryRootPath = "master:/sitecore/media library"

$location = $mediaLibraryRootPath
$dateTime = Get-Date -format "yyyy-MM-d_hhmmss"
$zipName = "Backup Media Library Example"
$zipPath = "$dataFolder/$zipName-$datetime.zip"

function BackupMediaItems {

    [System.Reflection.Assembly]::Load("WindowsBase,Version=3.0.0.0, `
      Culture=neutral, PublicKeyToken=31bf3856ad364e35") | Out-Null

    $ZipPackage=[System.IO.Packaging.ZipPackage]::Open($zipPath, `
      [System.IO.FileMode]::OpenOrCreate, [System.IO.FileAccess]::ReadWrite)

    $items = gci -recurse $sourceDir
    [byte[]]$buff = new-object byte[] 40960

    $items = Get-ChildItem -Path $location -Recurse | 
        Where-Object { $_.TemplateID -ne [Sitecore.TemplateIDs]::MediaFolder }

    $i = 0
    foreach($item in $items) {
            $i = $i + 1
            if([Sitecore.Resources.Media.MediaManager]::HasMediaContent($item))
            {
              Write-Output "$($i). $($item.ItemPath)"

              $mediaItem = New-Object "Sitecore.Data.Items.MediaItem" $item;
              $mediaStream = $mediaItem.GetMediaStream();
              $fileName = Resolve-Path -Path $item.ProviderPath -Relative
              $nm = $item.Name + "." + $item.Extension

              $fileName = "$fileName.$($item.Extension)" `
                -replace "\\","/" -replace "./", "/"
              # Print out the file - the list will show up once the file is downloaded
              "Added: $fileName"

              # Show progress for the operation
              Write-Progress -Activity "Zipping Files " `
                -CurrentOperation "Adding $fileName" `
                -Status "$i out of $($items.Length)" `
                -PercentComplete ($i *100 / $items.Length)

              $partUri = New-Object System.Uri($fileName, [System.UriKind]::Relative)
              $partUri = [System.IO.Packaging.PackUriHelper]::CreatePartUri($partUri);
              $part = $ZipPackage.CreatePart($partUri, `
                "application/zip",  `
                [System.IO.Packaging.CompressionOption]::Maximum)
              $stream=$part.GetStream();

              do {
                $count = $mediaStream.Read($buff, 0, $buff.Length)
                $stream.Write($buff, 0, $count)

              } while ($count -gt 0)

              #Out-Download -Name $nm -InputObject $stream
              $stream.Close()
              $mediaStream.Close()
            }
    }

    $ZipPackage.Close()
}

BackupMediaItems

Example:

This is an example with two images to backup:

Thanks for reading!

I hope this script has been useful to you. If you have any questions or ideas in mind, it'll be a pleasure to be able to be in communication with you, and together exchange knowledge with each other.

X / LinkedIn - esdanielgomez.com

Using Azure OpenAI Service to generate images with DALL-E in .NET

Daniel Gomez — Thu, 01 Feb 2024 16:32:22 +0000

Hey, there! In this tutorial, we'll see how to call an Azure OpenAI Service DALL-E model to generate new images from C#.

Required data from Azure:

Key and endpoint - We can find this information in the Keys and endpoint section in our Azure OpenAI Service resource.

Deployment name - This would be the instance of the model to use. In this case, we can go to the Azure OpenAI Service studio, and in the Deployments section specify a new one:

Azure OpenAI client library for .NET

Azure OpenAI client library for .NET is an adaptation of OpenAI's REST APIs that provides an idiomatic interface and rich integration with the rest of the Azure SDK ecosystem.

This library will allow us to use the GPT model from C#.

NuGet package: Azure.AI.OpenAI

Code in C#

With the NuGet package installed, this is a C# class that will allow us to generate new image using a specified prompt:

using Azure;
using Azure.AI.OpenAI;

namespace GenerativeAI;

public class AzureOpenAIDALLE
{
    const string key = "YOUR_KEY";
    const string endpoint = "https://YOUR_RESOURCE_NAME.openai.azure.com/";
    const string deploymentOrModelName = "YOUR_DEPLOYMENT";

    public async Task<string> GetContent(string prompt)
    {
        var client = new OpenAIClient(new Uri(endpoint), new AzureKeyCredential(key));

        var imageGenerationOptions = new ImageGenerationOptions
        {
            Prompt = prompt,
            DeploymentName = deploymentOrModelName,
            Size = new ImageSize("1024x1024"),
            ImageCount = 1
        };

        var response = await client.GetImageGenerationsAsync(imageGenerationOptions);
        return response.Value.Data[0].Url.AbsoluteUri;
    }
}

Example:

var dalle = new AzureOpenAIDALLE();

var dallePrompt = "Generate a featured image about Thanksgiving dishes";
Console.WriteLine($"{await dalle.GetContent(dallePrompt)}");

Thanks for reading!

If you have any questions or ideas in mind, it'll be a pleasure to be able to be in communication with you, and together exchange knowledge with each other.

Additional Resources:

Contact:
X / LinkedIn - esdanielgomez.com