Sr. Content Developer at Microsoft, working remotely in PA, TechBash conference organizer, former Microsoft MVP, Husband, Dad and Geek.
151211 stories
·
33 followers

Getting Started with MCP on Windows

1 Share


Read the whole story
alvinashcraft
19 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Unlock your email potential with Schema.org

1 Share

Email is a key part of how people get things done, whether it’s booking a reservation, confirming a package delivery, or managing a cab reservation. But as inboxes become increasingly cluttered, important transactional information often gets buried. Users are forced to open multiple emails, search through text, and manually look for key details such as reservation times, delivery status, or order confirmations. Let’s think about business travel, When users are flying out for meetings, training, or conferences, they shouldn’t have to dig through a crowded inbox to find flight details, hotel confirmations, or car service information. Technology should simplify this experience—so everything they need is right at their fingertips.
With schema.org markup, senders can structure email content in a format that can enable Microsoft Outlook to surface key information more intelligently helping users to always stay on top of their bookings, deliveries, and other critical details.

What is Schema.org?

Schema was developed as a joint venture by Microsoft, Google, Yahoo, and Yandex to provide a shared vocabulary for structured data. It enables contents like emails, web content to carry machine-readable metadata that describes events, reservations, shipments, and more. By embedding schema.org markup into the emails that you are sending, you allow Outlook to understand and surface key details more clearly to your users. The schema.org page has a repository of the schema vocabulary which you can use to build your webpages as well as emails.

 

Why should Providers adopt Schema.org?

  • Make your messages stand out: Highlight the most important information (e.g., delivery dates, check-in times) so users can see what matters at a glance.
  • Enable connected workflows: When your data is structured, Outlook can power contextual workflows like calendar event creation, follow-up reminders, or status tracking.
  • Improve discoverability: Structured emails are easier to search, classify, and act upon.
  • Drive engagement: Partners who’ve adopted structured markups have seen up to 30% higher engagement rates.

 

Supported scenarios:

1. Microsoft Outlook uses the same schema.org markup to highlight the most important information within an email and allow user to act on it. Automatically add events from your email to your calendar – Microsoft Support
2. Microsoft Outlook extracts events from booking confirmation emails- such as flights, hotel stays, car rentals, or other reservations and automatically adds them to your Outlook Calendar, ensuring employees always have the right details at the right time.”

Get Started

So, how can you give this experience to your users? The answer is simple: Add markup to your email messages
This allows Outlook to understand the key fields and surface them in relevant experiences across Outlook & Calendar. For example, if the email is about a flight reservation, you can annotate details such as the start time, venue, number of tickets, and other important information—so they appear front and center for the user

 

<html>
   <body>
    <p>
      Dear Stuart, thanks for booking your flight with Scandinavian Airlines.
    </p>
    <p>
      <b>BOOKING DETAILS</b><br/>
      Passenger: STUARTMR TONGE<br/>
      Airline: Scandinavian Airlines (SK)<br/>
      Flight Number: SK532<br/>
      From: Heathrow Airport (LHR), Terminal 2<br/>
      To: Arlanda Airport (ARN), Terminal 5<br/>
      Departure: July 20, 2021 – 13:55 GMT<br/>
      Arrival: July 20, 2021 – 17:25 GMT<br/>
      Reservation Number: NFNEV5<br/>
      Status: Confirmed<br/>
    </p>
  </body>
</html>

Marking up this email is very easy. Add the relevant pieces of information in the email body at one place at the beginning as shown in the example.

Microsoft recommends JSON-LD as this method adds the structured data separate from the HTML code.  This separation allows the code to be easily reviewed. Given that JSON-LD is in a format that can be understood by humans and machines alike, it’s much easier to implement.
<html>
  <head>
    <script type="application/ld+json">
{
"@context": "http://schema.org",
"@type": "FlightReservation",
"reservationId": "NFNEV5",
"reservationStatus": "ReservationConfirmed",
"underName": {
"@type": "Person",
"name": "Stuart Tonge"
},
"reservationFor": {
"@type": "Flight",
"flightNumber": "SK532",
"provider": {
"@type": "Airline",
"name": "Scandinavian Airlines",
"iataCode": "SK"
},
"departureAirport": {
"@type": "Airport",
"name": "Heathrow Airport",
"iataCode": "LHR"

},
"departureTime": "2021-07-20T13:55:00+00:00",
"arrivalAirport": {
"@type": "Airport",
"name": "Arlanda Airport",
"iataCode": "ARN"

},
"arrivalTime": "2021-07-20T17:25:00+00:00"
},
"reservedTicket": {
"@type": "Ticket",
"ticketedSeat": {
"@type": "Seat",
"seatNumber": null
}
}
}
</script>
  </head>
  <body>
    <p>
      Dear Stuart, thanks for booking your flight with Scandinavian Airlines.
    </p>
    <p>
      <b>BOOKING DETAILS</b><br/>
      Passenger: STUARTMR TONGE<br/>
      Airline: Scandinavian Airlines (SK)<br/>
      Flight Number: SK532<br/>
      From: Heathrow Airport (LHR), Terminal 2<br/>
      To: Arlanda Airport (ARN), Terminal 5<br/>
      Departure: July 20, 2021 – 13:55 GMT<br/>
      Arrival: July 20, 2021 – 17:25 GMT<br/>
      Reservation Number: NFNEV5<br/>
      Status: Confirmed<br/>
    </p>
  </body>
</html>

Partner With Us

We’re excited to see how you plan to enhance your users’ experiences using Schema.org markup in email. Microsoft is working to support structured data in Outlook to help users take quick actions directly from their inbox.
Follow the steps below to add a new domain:

Step1: Domain identification & whitelisting 

Goal: Ensure Outlook systems are authorized to process emails from the provider’s sending domains. 

Partners should: 

  1. Share the list of domains from which booking/transactional confirmation emails are sent to users ->Email:  txppro@microsoft.com 
  2. Explain your requirements- what kind of support are you looking for – Flight booking, hotel booking, car booking & parcel tracking are supported currently. 

What we will do: 

  1. We whitelist the shared domains on our end to enable schema extraction and testing.  
  2. This will take close to 2 weeks. 
  3. Whitelisting is a prerequisite for end-to-end testing mentioned in Step 4 

 

Step 2: Prepare & validate the schema markup 

Goal: Ensure the schema payload is correct before it ever reaches Outlook systems. 

Partners should: 

  1. Identify the relevant Schema.org fields for their scenario (flight, hotel, delivery, etc.). E.g. for Flight reservations, take reference from FlightReservation – Schema.org Type 
  2. Map their internal data to the required and recommended schema fields. 
  3. Validate the schema payload using the Schema.org validator. 

Step 3: Embed schema into the email 

Goal: Ensure the validated schema is correctly embedded in the email. 

Partners should: 

  1. Embed the validated schema payload into the email HTML (using the prescribed <script type=”application/ld+json”> format). 
  2. Have the <script> block only at one place at the beginning as shown in above example. (This won’t render on the UI) 

Step 4: Testing & onboarding confirmation 

Goal: Validate that Outlook systems can successfully extract and process the schema. 

  1.  After successfully validating adding schema markup to the emails, send 2–3 booking confirmation emails containing the markup to schemaonboarding@microsoft.com  
  2. Post domain allowlisting (Refer Step 1), you’d be able to test at your end and validate things end to end. 
  3. Points to test 
    • Ensure Outlook settings-> Calendar->“Events From Email” setting is enabled to show “Event summaries in Email and Calendar”  
    • If you get a booking flight/cab/hotel confirmation emails, you should be able to see a summary card at the top of the email. 
    • A corresponding calendar event should have created for the booking. 

 

FAQs 

Do domains need to be whitelisted for testing? → Yes. Domain whitelisting (Step 1) is required before end-to-end testing can be completed. 

Is schema validation alone sufficient to guarantee the experience? → No. Schema validation confirms correctness, but end-to-end extraction testing (Step 4) is required to validate the actual Outlook experience. 

Does Microsoft support all Schema.org types? → No. Microsoft & Outlook currently supports a curated set of schema types relevant for travel and logistics scenarios such as FlightReservation, LodgingReservation, RentalCarReservation, and ParcelDelivery. Additional types may not be recognized by Outlook’s extraction pipeline even if they are validated on schema.org. 

Do we need DMARC, DKIM, SPF header checks?  Strongly recommended. Failing these checks will result in sender authentication failure, which will lead to event not being generated for these bookings. 

 

The post Unlock your email potential with Schema.org appeared first on Microsoft 365 Developer Blog.

Read the whole story
alvinashcraft
19 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

We’re Already Living in a Post-Serverless World

1 Share
This isn’t really about serverless. It’s about what happens when infrastructure stops asking humans to guess the future.
Read the whole story
alvinashcraft
20 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Building a Fibonacci Sphere with AI-Assisted Development

1 Share

How we used MCPs, prompts, and agentic workflows to go from concept to cross-platform 3D visualization in hours, not days.

Imagine starting with a sentence and ending with a running app. Not a mock. Not a gist. An app.

We did that by building an interactive Fibonacci sphere visualization with Uno Platform Studio. The AI agents and MCP servers handled the scaffolding and we steered the decisions and iterated.

Imagine starting with a sentence and ending with a running app. Not a mock. Not a gist. An app.

We did that by building an interactive Fibonacci sphere visualization with Uno Platform Studio. The AI agents and MCP servers handled the scaffolding and we steered the decisions and iterated.

💡 What you'll learn

This tutorial uses a Fibonacci sphere to show an AI-assisted dev loop that boosts production without taking the wheel: Along the way we’ll cover setup and SkiaSharp rendering, then land on a working, cross-platform implementation you can reuse for real production work.

What We're Building

A Fibonacci sphere is just a clean way to place points evenly on a sphere using the golden angle.

The fun part is what we layer on top: point picking, a subtle wobble, motion trails, and a speed control so the whole thing feels alive instead of static.

👆
Point Interaction
Hover to highlight, click to select, drag to rotate the entire sphere
⚡
Speed Control
Adjustable auto-rotation with direction toggle
〰
Wobble Effect
Points oscillate with randomized phases for organic motion
✨
Motion Trails
Fading paths showing point movement history

Part 1: Setting Up with Uno Platform Studio

Prerequisites

Before you start, install Visual Studio 2022/2026 (or VS Code + C# Dev Kit), the .NET 9 SDK, the Uno Platform extension, and an MCP-enabled agent (Claude Code/Desktop, or any IDE that supports MCP).

🔄 Works With Any IDE + LLM

This tutorial uses Claude Code for demonstration, but the workflow isn't locked to any specific tool. You can replicate this approach with VS Code + Copilot, Cursor, Visual Studio + AI Assistant, Codex, or any IDE with MCP support. The patterns and prompts work across LLMs—adapt them to your preferred setup.

Creating the Project

Open Claude Code (or your preferred MCP-enabled IDE) and start by initializing your servers. The exact phrasing doesn’t matter much—I typically go with:

				
					Initialize uno and app mcp
				
			

Once you get confirmation that the servers are running, you’re connected to Uno Platform’s tooling and ready to scaffold.

Create a new project by typing /uno:new and pressing Enter. Claude will prompt you for configuration details. Keep it simple:

				
					Create an Uno Platform project targeting desktop and Android, 
name it FibonacciSphere, use MVVM and SkiaSharp rendering.
				
			

Within seconds, you’ll have a fully configured solution with the correct target frameworks, NuGet packages, and project structure.

Option 2: Wizard-Based Setup

You can also use the Uno Platform Wizard to configure your project visually. Launch it from Visual Studio or use the online wizard for VS Code, from there you can configure and intialize your solution.

Both paths get you to the same place, choose whichever fits your style.

Part 2: The AI-Assisted Development Flow

Here’s where Uno Platform’s integration with AI agents transforms the development experience.

Uno Platforms Model Context Protocol

Uno Platform provides two MCP (Model Context Protocol) servers that give AI agents the context and capabilities they need to build cross-platform .NET apps effectively.

Uno Platform Remote MCP

This is a publicly hosted server that connects your agent to Uno Platform’s knowledge base and development patterns. It provides:

  • Documentation tools – uno_platform_docs_search and uno_platform_docs_fetch let agents search and retrieve relevant documentation on the fly
  • Development primers – uno_platform_agent_rules_init and uno_platform_usage_rules_init teach agents how to interact with Uno Platform apps and use APIs correctly

The Remote MCP also registers predefined prompts in supported agents:

  • /new – Creates a new Uno Platform app with best practices baked in
  • /init – Primes your current chat with Uno’s conventions (useful when adding features to an existing app)

Uno Platform Local App MCP

This is where things get interesting. The Local App MCP runs on your machine and gives agents the ability to interact with your running application—clicking, typing, taking screenshots, and inspecting the visual tree.

Think of it as giving your AI agent eyes and hands. It can validate assumptions, verify that generated code actually works, and debug issues by seeing what’s on screen.

📘 App MCP Tools

Available tools include uno_app_get_screenshot, uno_app_visualtree_snapshot, uno_app_pointer_click, uno_app_type_text, and uno_app_get_runtime_info. This feedback loop is what makes agentic development feel different—the agent doesn't just generate code and hope, it can run the app, see the result, and iterate.

Uno Platforms Model Context Protocol

The Prompt That Started It All

				
					Build an interactive Fibonacci sphere in C#/XAML for Uno Platform 
using SkiaSharp. Points distributed via golden angle algorithm, 
rendered with manual 3D-to-2D projection. Include a control panel 
with sliders for: rotation speed, wobble (amplitude + frequency 
with per-point phase offset), point size with depth scaling, and 
trail length with opacity fade. Support hover highlighting, click 
selection, and drag-to-rotate.
				
			

From this single prompt, the agent:

  1. Searched Uno Platform docs to understand SkiaSharp integration patterns
  2. Primed itself with Uno’s API conventions using the rules tools
  3. Created the project structure with appropriate separation of concerns
  4. Generated the mathematical algorithms for Fibonacci distribution
  5. Scaffolded the MVVM architecture with proper bindings
  6. Wrote the SkiaSharp rendering code with 3D projection

Working with the Agent

The key to effective AI-assisted development is iteration. After the initial scaffold, we refined through conversation:

Us: “The wobble effect feels too uniform. Can you add more variation?”

Agent: Takes a screenshot, analyzes the motion, then updates the code with a secondary wobble frequency and per-point amplitude randomization.

Us: “The trails are causing performance issues at 500+ points.”

Agent: Inspects the visual tree, identifies the bottleneck, implements trail pooling and reduces history when point count exceeds 300.

This conversational refinement—backed by the agent’s ability to actually see and interact with the running app—is faster than traditional development because the feedback loop is immediate and contextual.

Part 3: Core Implementation

The Fibonacci Distribution Algorithm

The golden angle (≈137.5°) ensures no two points align vertically, creating the characteristic spiral pattern seen in nature.

				
					public static class FibonacciSphere
{
    public static List GeneratePoints(int count)
    {
        var points = new List(count);
        float goldenRatio = (1 + MathF.Sqrt(5)) / 2;
        float goldenAngle = 2 * MathF.PI / (goldenRatio * goldenRatio);

        for (int i = 0; i < count; i++)
        {
            // Y coordinate: evenly distributed from +1 to -1
            float y = 1 - (2f * i / (count - 1));
            
            // Radius at this Y slice
            float radius = MathF.Sqrt(1 - y * y);
            
            // Angle based on golden ratio
            float theta = goldenAngle * i;

            points.Add(new Vector3(
                MathF.Cos(theta) * radius,
                y,
                MathF.Sin(theta) * radius
            ));
        }
        
        return points;
    }
}
				
			

The Wobble Effect

The dual-frequency approach creates organic, non-repetitive motion that feels natural rather than mechanical.

				
					public static class FibonacciSphere
{
    public static List GeneratePoints(int count)
    {
        var points = new List(count);
        float goldenRatio = (1 + MathF.Sqrt(5)) / 2;
        float goldenAngle = 2 * MathF.PI / (goldenRatio * goldenRatio);

        for (int i = 0; i < count; i++)
        {
            // Y coordinate: evenly distributed from +1 to -1
            float y = 1 - (2f * i / (count - 1));
            
            // Radius at this Y slice
            float radius = MathF.Sqrt(1 - y * y);
            
            // Angle based on golden ratio
            float theta = goldenAngle * i;

            points.Add(new Vector3(
                MathF.Cos(theta) * radius,
                y,
                MathF.Sin(theta) * radius
            ));
        }
        
        return points;
    }
}
				
			

Part 4: The XAML Interface

The control panel uses standard Uno Platform controls with data binding to the ViewModel.

				
					
    
    
    
    
    
    
        
            
            
            
            
        
    

				
			

Lessons Learned: AI-Assisted Development

⚠ What Still Requires Human Judgment

Performance tuning, visual polish (colors and timing), and platform-specific quirks still benefit from developer experience. The agent suggests optimizations, but profiling is manual.

At the end of this, the Fibonacci sphere is almost the least interesting part. The interesting part is the loop: describe the outcome, let the agent scaffold then you review, iterate and correct.

MCPs make that loop practical in Uno Platform because the agent isn’t guessing in a void – it can use your tooling and your docs. The developer job shifts from “write every line” to “direct, verify, and polish.”
That’s amplification, not automation.

Next Steps

Get the complete source code and start experimenting with your own variations.

The post Building a Fibonacci Sphere with AI-Assisted Development appeared first on Uno Platform.

Read the whole story
alvinashcraft
20 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Kubernetes AI Conformance, with Janet Kuo

1 Share

Janet Kuo, Staff Software Engineer at Google, explains the new Kubernetes AI Conformance program.

 

Do you have something cool to share? Some questions? Let us know:

- web: kubernetespodcast.com

- mail: kubernetespodcast@google.com

- twitter: @kubernetespod

- bluesky: @kubernetespodcast.com

 

Intro

News of the Week

 

Links from the interview

 

 





Download audio: https://traffic.libsyn.com/secure/e780d51f-f115-44a6-8252-aed9216bb521/KPOD263.mp3?dest-id=3486674
Read the whole story
alvinashcraft
20 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

docsummarizer - Local Document Summarization CLI Tool

1 Share
docsummarizer - Local Document Summarization CLI Tool
Read the whole story
alvinashcraft
21 minutes ago
reply
Pennsylvania, USA
Share this story
Delete
Next Page of Stories