Check-In Doc MCP Server: A Handy Way to Search Only the Docs You Trust

Ever wished you could ask a question and have the answer come only from a handful of trusted documentation sites—no random blogs, no stale forum posts? That’s exactly what the Check-In Doc MCP Server does. It’s a lightweight Model Context Protocol (MCP) server you can run locally (or host) to funnel questions to selected documentation domains and get a clean AI-generated answer back.

What It Is

The project (GitHub: https://github.com/fboucher/check-in-doc-mcp) is a Dockerized MCP server that:

• Accepts a user question.
• Calls the Reka AI Research API with constraints (only allowed domains).
• Returns a synthesized answer based on live documentation retrieval.

You control which sites are searchable by passing a comma‑separated list of domains (e.g. docs.reka.ai,docs.github.com). That keeps > results focused, reliable, and relevant.

What Is the Reka AI Research API?

Reka AI’s Research API lets you blend language model reasoning with targeted, on‑the‑fly web/document retrieval. Instead of a model hallucinating an answer from static training data, it can:

• Perform limited domain‑scoped web searches.
• Pull fresh snippets.
• Integrate them into a structured response.

In this project, we use the research feature with a web_search block specifying:

• allowed_domains: Only the documentation sites you trust.
• max_uses: Caps how many retrieval calls it makes per query (controls cost & latency).

Details used here:

• Model: reka-flash-research
• Endpoint: http://api.reka.ai/v1/chat/completions
• Auth: Bearer API key (generated from the Reka dashboard: https://link.reka.ai/free)

How It Works Internally

The core logic lives in ResearchService (src/Domain/ResearchService.cs). Simplified flow:

1. Initialization
   Stores the API key + array of allowed domains, sets model & endpoint, logs a safe startup message.

2. Build Request Payload
   The CheckInDoc(string question) method creates a JSON payload:

   var requestPayload = new {
     model,
     messages = new[] { new { role = "user", content = question } },
     research = new {
       web_search = new {
         allowed_domains = allowedDomains,
         max_uses = 4
       }
     }
   };
   

3. Send Request
   Creates a HttpRequestMessage (POST), adds Authorization: Bearer <APIKEY>, sends JSON to Reka.

4. Parse Response
   Deserializes into a RekaResponse domain object, returns the first answer string.

Adding It to VS Code (MCP Extension)

You can run it as a Docker-based MCP server. Two simple approaches:

Option 1: Via “Add MCP Server” UI

1. In VS Code (with MCP extension), click Add MCP Server.
2. Choose type: Docker image.
3. Image name: fboucher/check-in-doc-mcp.
4. Enter allowed domains and your Reka API key when prompted.

Option 2: Via mcp.json (Recommended)

Alternatively, you can manually configure it in your mcp.json file. This will make sure your API key isn't displayed in plain text. Add or merge this configuration:

{
  "servers": {
    "check-in-docs": {
      "type": "stdio",
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "ALLOWED_DOMAINS=${input:allowed_domains}
        ",
        "-e",
        "APIKEY=${input:apikey}",
        "fboucher/check-in-doc-mcp"
      ]
    }
  },
  "inputs": [
    {
      "id": "allowed_domains",
      "type": "promptString",
      "description": "Enter the comma-separated list of documentation domains to allow (e.g. docs.reka.ai,docs.github.com):"
    },
    {
      "id": "apikey",
      "type": "promptString",
      "password": true,
      "description": "Enter your Reka Platform API key:"
    }
  ]
}

How to Use It

To use it ask to Check In Doc something or You can now use the SearchInDoc tool in your MCP-enabled environment. Just ask a question, and it will search only the specified documentation domains.

Final Thoughts

It’s intentionally simple—no giant orchestration layer. Just a clean bridge between a question, curated domains, and a research-enabled model. Sometimes that’s all you need to get focused, trustworthy answers.

If this sparks an idea, clone it and adapt away. If you improve it (citations, richer error handling, multi-turn context)—send a PR!

Watch a quick demo

Links & References

• GitHub Repository
• Reka Research API
• Reka Research MCP Server (in TypeScript)

AI Vision: Turning Your Videos into Comedy Gold (or Cringe)

I've spent most of my career building software in C# and .NET, and only used Python in IoT projects. When I wanted to build a fun project—an app that uses AI to roast videos, I knew it was the perfect opportunity to finally dig into Python web development.

The question was: where do I start? I hopped into a brainstorming session with Reka's AI chat and asked about options for building web apps in Python. It mentioned Flask, and I remembered friends talking about it being lightweight and perfect for getting started. That sounded right.

In this post, I share how I built "Roast My Life," a Flask app using the Reka Vision API.

The Vision (Pun Intended)

The app needed three core things:

1. List videos: Show me what videos are in my collection
2. Upload videos: Let me add new ones via URL
3. Roast a video: Send a selected video to an AI and get back some hilarious commentary

See it in action

Part 1: Getting Started Environment Setup

The first hurdle was always going to be environment setup. I'm serious about keeping my Python projects isolated, so I did the standard dance:

Before even touching dependencies, I scaffolded a super bare-bones Flask app. Then one thing I enjoy from C# is that all dependencies are brought in one shot, so I like doing the same with my python projects using requirements.txt instead of installing things ad‑hoc (pip install flask then later freezing).

Dropping that file in first means the setup snippet below is deterministic. When you run pip install -r requirements.txt, Flask spins up using the exact versions I tested with, and you won't accidentally grab a breaking major update.

Here's the shell dance that activates the virtual environment and installs everything:

cd roast_my_life/workshop
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

Then came the configuration. We will need an API key and I don't want to have it hardoced so I created a .env file to store my API credentials:

API_KEY=YOUR_REKA_API_KEY
BASE_URL=https://vision-agent.api.reka.ai

To get that API key, I visited the Reka Platform and grabbed a free one. Seriously, a free key for playing with AI vision APIs? I was in.

With python app.py, I fired up the Flask development server and opened http://127.0.0.1:5000 in my browser. The UI was there, but... it was dead. Nothing worked.

Perfect. Time to build.

The Backend: Flask Routing and API Integration

Coming from ASP.NET Core's controller-based routing and Blazor, Flask's decorator-based approach felt just like home. All the code code goes in the app.py file, and each route is defined with a simple decorator. But first things first: loading configuration from the .env file using python-dotenv:

from flask import Flask, request, jsonify
import requests
import os
from dotenv import load_dotenv

app = Flask(__name__)

# Load environment variables (like appsettings.json)
load_dotenv()
api_key = os.environ.get('API_KEY')
base_url = os.environ.get('BASE_URL')

All the imports packages are the same ones that needs to be in the requirements.txt. And we retreive the API key and base URL from environment variables, just like in .NET Core.

Now, to be able to get roasted we need first to upload a video to the Reka Vision API. Here's the code—I'll go over some details after.

@app.route('/api/upload_video', methods=['POST'])
def upload_video():
    """Upload a video to Reka Vision API"""
    data = request.get_json() or {}
    video_name = data.get('video_name', '').strip()
    video_url = data.get('video_url', '').strip()
    
    if not video_name or not video_url:
        return jsonify({"error": "Both video_name and video_url are required"}), 400
    
    if not api_key:
        return jsonify({"error": "API key not configured"}), 500
    
    try:
        response = requests.post(
            f"{base_url.rstrip('/')}/videos/upload",
            headers={"X-Api-Key": api_key},
            data={
                'video_name': video_name,
                'index': 'true',  # Required: tells Reka to process the video
                'video_url': video_url
            },
            timeout=30
        )
        
        response_data = response.json() if response.ok else {}
        
        if response.ok:
            video_id = response_data.get('video_id', 'unknown')
            return jsonify({
                "success": True,
                "video_id": video_id,
                "message": "Video uploaded successfully"
            })
        else:
            error_msg = response_data.get('error', f"HTTP {response.status_code}")
            return jsonify({"success": False, "error": error_msg}), response.status_code
            
    except requests.Timeout:
        return jsonify({"success": False, "error": "Request timed out"}), 504
    except Exception as e:
        return jsonify({"success": False, "error": f"Upload failed: {str(e)}"}), 500

Once the information from the frontend is validated we make a POST request to the Reka Vision API's /videos/upload endpoint. The parameters are sent as form data, and we include the API key in the headers for authentication. Here I was using URLs to upload videos, but you can also upload local files by adjusting the request accordingly. As you can see, it's pretty straightforward, and the documentation from Reka made it easy to understand what was needed.

The Magic: Sending Roast Requests to Reka Vision API

Here's where things get interesting. Once a video is uploaded, we can ask the AI to analyze it and generate content. The Reka Vision API supports conversational queries about video content:

def call_reka_vision_qa(video_id: str) -> Dict[str, Any]:
    """Call the Reka Video QA API to generate a roast"""
    
    headers = {'X-Api-Key': api_key} if api_key else {}
    
    payload = {
        "video_id": video_id,
        "messages": [
            {
                "role": "user",
                "content": "Write a funny and gentle roast about the person, or the voice in this video. Reply in markdown format."
            }
        ]
    }
    
    try:
        resp = requests.post(
            f"{base_url}/qa/chat",
            headers=headers,
            json=payload,
            timeout=30
        )
        
        data = resp.json() if resp.ok else {"error": f"HTTP {resp.status_code}"}
        
        if not resp.ok and 'error' not in data:
            data['error'] = f"HTTP {resp.status_code} calling chat endpoint"
        
        return data
        
    except requests.Timeout:
        return {"error": "Request to chat API timed out"}
    except Exception as e:
        return {"error": f"Chat API call failed: {e}"}

Here we pass the video ID and a prompt asking for a "funny and gentle roast." The API responds with AI-generated content, which we can then send back to the frontend for display. I try to give more "freedom" to the AI by asking it to reply in markdown format, which makes the output more engaging.

Try It Yourself!

The complete project is available on GitHub: reka-ai/api-examples-python

What Makes Reka Vision API So nice to use

What really stood out to me was how approachable the Reka Vision API is. You don't need any special SDK—just the requests library making standard HTTP calls. And honestly, it doesn't matter what language you're used to; an HTTP call is pretty much always simple to do. Whether you're coming from .NET, Python, JavaScript, or anything else, you're just sending JSON and getting JSON back.

Authentication is refreshingly straightforward: just pop your API key in the header and you're good to go. No complex SDKs, no multi-step authentication flows, no wrestling with binary data streams. The conversational interface lets you ask questions in natural language, and you get back structured JSON responses with clear fields.

One thing worth noting: in this example, the videos are pre-uploaded and indexed, which means the responses come back fast. But here's the impressive part—the AI actually looks at the video content. It's not just reading a transcript or metadata; it's genuinely analyzing the visual elements. That's what makes the roasts so spot-on and contextual.

Final Thoughts

The Reka Vision API itself deserves credit for making video AI accessible. No complicated SDKs, no multi-GB model downloads, no GPU requirements. Just simple HTTP requests and powerful AI capabilities. I'm not saying I'm switching to Python full-time, but expect to see me sharing more Python projects in the future!

References and Resources

• GitHub Repository: reka-ai/api-examples-python
• Join Reka community and share what you build! You can find me there as fboucheros.

Using AI with .NET 10 Scripts: What Worked, What Didn’t, and Lessons Learned

I wanted to kick the tires on the upcoming .NET 10 C# script experience and see how far I could get calling Reka’s Research LLM from a single file, no project scaffolding, no .csproj. This isn’t a benchmark; it’s a practical tour to compare ergonomics, setup, and the little gotchas you hit along the way. I’ll share what worked, what didn’t, and a few notes you might find useful if you try the same.

All the sample code (and a bit more) is here: reka-ai/api-examples-dotnet · csharp10-script. The scripts run a small “top 3 restaurants” prompt so you can validate everything quickly.

We’ll make the same request in three ways:

1. OpenAI SDK
2. Microsoft.Extensions.AI for OpenAI
3. Raw HttpClient

What you need

The C# "script" feature used below ships with the upcoming .NET 10 and is currently available in preview. If you prefer not to install a preview SDK, you can run everything inside the provided Dev Container or on GitHub Codespaces. I include a .devcontainer folder with everything set up in the repo.

Set up your API key

We are talking about APIs here, so of course, you need an API key. The good news is that it's free to sign up with Reka and get one! It's a 2-click process, more details in the repo. The API key is then stored in a .env file, and each script loads environment variables using DotNetEnv.Env.Load(), so your key is picked up automatically. I went this way instead of using dotnet user-secrets because I thought it would be the way it would be done in a CI/CD pipeline or a quick script.

Run the demos

From the csharp10-script folder, run any of these scripts. Each line is an alternative

dotnet run 1-try-reka-openai.cs
dotnet run 2-try-reka-ms-ext.cs
dotnet run 3-try-reka-http.cs

You should see a short list of restaurant suggestions.

OpenAI SDK with a custom endpoint

Reka's API is using the OpenAI format; therefore, I thought of using the NuGet package OpenAI. To reference a package in a script, you use the #:package [package name]@[package version] directive at the top of the file. Here is an example:

#:package OpenAI@2.3.0

// ...

var baseUrl = "http://api.reka.ai/v1";

var openAiClient = new OpenAIClient(new ApiKeyCredential(REKA_API_KEY), new OpenAIClientOptions
{
    Endpoint = new Uri(baseUrl)
});

var client = openAiClient.GetChatClient("reka-flash-research");

string prompt = "Give me 3 nice, not crazy expensive, restaurants for a romantic dinner in Montreal";

var completion = await client.CompleteChatAsync(
    new List<ChatMessage>
    {
        new UserChatMessage(prompt)
    }
);

var generatedText = completion.Value.Content[0].Text;

Console.WriteLine($" Result: \n{generatedText}");

The rest of the code is more straightforward. You create a chat client, specify the Reka API URL, select the model, and then you send a prompt. And it works just as expected. However, not everything was perfect, but before I share more about that part, let's talk about Microsoft.Extensions.AI.

Microsoft Extensions AI for OpenAI

Another common way to use LLM in .NET is to use one ot the Microsoft.Extensions.AI NuGet package. In our case Microsoft.Extensions.AI.OpenAI was used.

#:package Microsoft.Extensions.AI.OpenAI@9.8.0-preview.1.25412.6

// ....

var baseUrl = "http://api.reka.ai/v1";

IChatClient client = new ChatClient("reka-flash-research", new ApiKeyCredential(REKA_API_KEY), new OpenAIClientOptions
{
    Endpoint = new Uri(baseUrl)
}).AsIChatClient();

string prompt = "Give me 3 nice, not crazy expensive, restaurants for a romantic dinner in Montreal";

Console.WriteLine(await client.GetResponseAsync(prompt));

As you can see, the code is very similar. Create a chat client, set the URL, the model, and add your prompt, and it works just as well.

That's two ways to use Reka API with different SDKs, but maybe you would prefer to go "SDKless", let's see how to do that.

Raw HttpClient calling the REST API

Without any SDK to help, there is a bit more line of code to write, but it's still pretty straightforward. Let's see the code:

using var httpClient = new HttpClient();

var baseUrl = "http://api.reka.ai/v1/chat/completions";

var requestPayload = new
{
    model = "reka-flash-research",
    messages = new[]
            {
                new
                {
                    role = "user",
                    content = "Give me 3 nice, not crazy expensive, restaurants for a romantic dinner in New York city"
                }
            }
};

using var request = new HttpRequestMessage(HttpMethod.Post, baseUrl);
request.Headers.Add("Authorization", $"Bearer {REKA_API_KEY}");
request.Content = new StringContent(jsonPayload, Encoding.UTF8, "application/json");

var response = await httpClient.SendAsync(request);

var responseContent = await response.Content.ReadAsStringAsync();

var jsonDocument = JsonDocument.Parse(responseContent);

var contentString = jsonDocument.RootElement
    .GetProperty("choices")[0]
    .GetProperty("message")
    .GetProperty("content")
    .GetString();

Console.WriteLine(contentString);

So you create an HttpClient, prepare a request with the right headers and payload, send it, get the response, and parse the JSON to extract the text. In this case, you have to know the JSON structure of the response, but it follows the OpenAI format.

What did I learn from this experiment?

I used VS Code while trying the script functionality. One thing that surprised me was that I didn't get any IntelliSense or autocompletion. I try to disable the DevKit extension and change the setting for OmniSharp, but no luck. My guess is that because it's in preview, and it will work just fine in November 2025 when .NET 10 will be released.

In this light environment, I encountered some issues where, for some reason, I couldn't use an https endpoint, so I had to use http. In the raw httpClient script, I had some errors with the Reflection that wasn't available. It could be related to the preview or something else, I didn't investigate further.

For the most part, everything worked as expected. You can use C# code to quickly execute some tasks without any project scaffolding. It's a great way to try out the Reka API and see how it works.

What's Next?

While writing those scripts, I encountered multiple issues that aren't related to .NET but more about the SDKs when trying to do more advanced functionalities like optimization of the query and formatting the response output. Since it goes beyond the scope of this post, I will share my findings in a follow-up post. Stay tuned!

Video version

Here is a video version of this post

Learn more

• Reka docs: docs.reka.ai
• Join the community on Discord: discord invite
  
• GitHub: API Example for .NET

Get an AI assistant to do your research

Introducing Reka Research: Your AI Research Assistant

Meet Reka Research a powerful AI agent that can search the web and analyze your files to answer complex questions in minutes. Whether you're staying up to date with AI news, screening resumes, or researching technical topics, Reka Research does the heavy lifting for you.

What Makes Reka Research Special?

Reka Research stands out in four key areas:

• Top Performance: Best in class results on research benchmarks
• Fast Results: Get thorough answers in 1-3 minutes
• Full Transparency: See exactly how the AI reached its conclusions. All steps are visible.

Smart Web Search That Actually Works

Ever wished you could ask someone to research the latest AI developments while you focus on other work? That's exactly what Reka Research does.

Watch how it works:

In this demo, Jess and Sharath shows how Reka Research can automatically gather the most important AI news from the past week. The AI visits multiple websites, takes notes, and presents a clean summary with sources. You can even restrict searches to specific domains or set limits on how many sites to check.

File Search for Your Private Documents

Sometimes the information you need isn't on the web - it's in your company's documents, meeting notes, or file archives. Reka Research can search through thousands of private files to find exactly what you're looking for.

See it in action:  

In this example, ess and Sharath shows how HR teams can use Reka Research to quickly screen resumes. Instead of manually reviewing hundreds of applications, the AI finds candidates who meet specific requirements (like having a computer science degree and 3+ years of backend experience) in seconds!

Writing Better Prompts Gets Better Results

Like any AI tool, Reka Research works best when you know how to ask the right questions. The key is being specific about what you want and providing context.

Learn the techniques:

Jess and Yi shares practical tips for getting the most out of Reka Research. Instead of asking "summarize meeting minutes," try "summarize April meeting minutes about public participation." The more specific you are, the better your results will be.

Ready to Try Reka Research?

Reka Research is currently available for everyone! Try it via the playground, or using directly the API. Whether you're researching competitors, analyzing documents, or staying current with industry trends, it can save you hours of work.

Want to learn more and connect with other users? Join our Discord community where you can:

• Get tips from other Reka Research users
• Share your use cases and success stories
• Stay updated on new features and releases
• Ask questions directly to our team

Join our Discord Community

Ready to transform how you research? Visit reka.ai to learn more about Reka Research and our other AI tools.

Reading Notes #649

Welcome to another edition of my reading notes! This week I've come across some interesting articles spanning from programming decisions to career tips and AI innovations. Hope you find something valuable in this collection.

Programming

• Why we built our startup in C# (Sam Cox) - I really like those true-story blog posts; they teach us about the thought process and the reason behind a decision.

• It wasn’t the idea that failed: it was the execution (Salma Alam-Naylor) - Even though I feel like I'm missing a few points about sigma and new stuff coming up in 2025, this post is an amazing memory of our past in terms of evolution in the web industry

AI

• Accelerate AI innovation and business transformation (Byron Rader) - It's important to look forward, and you know what? There are people to help and guide you and your enterprise.

• Why APIs Are Essential and MCP Is Optional (for Now) (Gil Feig) - Great post that clarified the distinction between an API and the mCP servers. It's an interesting post.

Miscellaneous

• Thriving After a Layoff: The First 30 Days (scrappy girl project) - A friend of mine shared with me this post, and I think it will help me in the upcoming days. So here I am sharing so more can benefit from it

Books

• The Let Them Theory (Mel Robbins) - Stop wasting energy on things you can’t control. It something we all know, but probably forgot the power if it. Let go is hard, but it works in so many scenario. In this book Mel explains how to make it works, and how to use it with a let me action.
   

Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week. 

If you have interesting content, share it!

~Frank

Reading Notes #646

Welcome to this week's collection of fascinating reads across cloud computing, AI, and programming! As technology continues to evolve at breakneck speed, I've gathered some of the most insightful articles that caught my attention. From securing MCP servers to exploring Rust, there's something here for every tech enthusiast. 

Dive in and discover what's new in our rapidly changing digital landscape.

Cloud

• Azure API Management Your Auth Gateway For MCP Servers | Microsoft Community Hub (PranamiJ) - Why all the fuss about MCP, we must not forget security. This post suggests a simple solution.

AI

• How Azure Copilot Helped Me Quickly Troubleshoot a Demo (David Giard) - That's a good example of how AI can help you not do the job for yourself but avoid mistakes and do it faster.

• Secure Remote MCP Servers With Entra ID And Azure API Management (Den Delimarsky) - Nice solution in Python to secure your MCP servers

Programming

• When ASP.NET Core Identity Is No Longer Enough (Andrea Chiarelli) - Authentication and authorization have an important place in our Apps. This post shares details about how things work and the different processes.

• New Docker Extension for Visual Studio Code (Remy Suen) - This extension was already a must, they made it better, it's a must must! But seriously give it a try and try it by yourself.

• From C# to Rust: A 42-Day Developer Challenge (Chris Woodruff) - Cool tease of an experiment that promises a lot of learning.

• How to Programmatically Create MS Word DOCX Documents with .NET C# on Linux (Bjoern Meyer) - Cool package that helps create Word documents. Perfect when running in a Linux container.

• Preview 2 of the .NET AI Template Now Available (Jordan Matthiesen) - New templates with AI, Qadran and Aspire, oh boy life is good!

Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week. 

If you have interesting content, share it!

~Frank

Reading Notes #638

Welcome to Reading Notes —a curated dive into the latest and greatest in programming, cloud, and AI. From mastering multithreading with Azure to exploring GitHub Copilot's productivity potential, this collection is brimming with knowledge. Let's unravel what's new, innovative, and worth your attention!

Cloud

• Azure Functions – Part 1 (Jesse Liberty) - Quick launch of a series about Azure Function.

• How to Multistream Using Azure, Azure VM, MonaServer 2, and FFmpeg with OBS Studio (Maho Pacheco) - That's a very cool idea! This post also made me understand better how those things work.

Programming

• Dapr v1.15 is now available (Dapr project maintainers ) - This new release is anticipated by the community with new features and many bug fixes

• Building a CRUD API with ASP.NET Core Web API and PostgreSQL (M. Oly Mahmud) - This is a nice step-by-step tutorial with all the code snippets required to get started.

• .NET Aspire 9.1 is here with six great new dashboard features, and more! - .NET Blog (Maddy Montaquila) - Learn more about many dashboard updates in this post like the grouping, theme, localization and logs management.

AI

• Let's Learn .NET: GitHub Copilot Event - .NET Blog (James Montemagno) - A new cool event is coming up to improve our productivity. Learn how to use copilot as a developer.

• Claude 3.7 Available for Visual Studio - Having options is interesting, I should try Claude to see the difference.

Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week. 

If you have interesting content, share it! 

~frank

Reading Notes #637

In this edition of my Reading Notes, I've curated some fascinating content that spans across programming, creativity, and enlightening podcasts. Whether you're eager to enhance your coding skills, explore unique ideas, or stay updated with the latest in the tech world, there's something here for everyone. 

Dive in and enjoy these insightful reads and discussions!

Programming

• New Features for Enhanced Razor Productivity! (Leslie Richardson) - I love the new component feature that's one that I will use over and over for sure.

• Abstract vs Interface: Deep dive (Serhii Korol) - You probably know the difference between those two just like me, but do you know how the code is interpreted that's very interesting.

• Riverdam - Feature Gates Finally Made Easy (David Guida) - A cool tool to ease development. This new project definitely looked interesting.

• 11 Must Read Software Design and Architecture Books for Developers (Soma) - I like books. It's a great way to go deeper about a topic at your own pace and when you want. This post has great recommendations, and I really enjoy the authenticity in the comments.

Podcasts

• Static Websites in 2025 with Stacy Cashmore (.NET Rocks!) - It was nice listening to the discussion with Stacy about how are Azure Static Websites are evolving.

Miscellaneous

• Typing tests were boring, so i built TypeTheLyrics. (Arjun Vijay Prakash) - Cool idea! It's true that music always has a big impact on everything.

Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week. If you have interesting content, share it! 

 ~Frank

Reading Notes #628

For this week reading notes, I have some exciting blog posts and podcast episodes. Covering topics including .NET scaffolding, Visual Studio updates, the Builder Pattern in C#, and OpenAPI in .NET 9. Plus, tips on validating identity with GitHub, improving Azure Identity, and podcast highlights on GitHub Universe and presentation skills. 

Cloud

• Better Azure Identity authentication support and performance during local development with .NET Aspire (Anthony Simmon) - A cool demo/tutorial with all the code snippets and explanations.

Programming

• dotnet scaffold - Next Generation Content Creation for .NET - .NET Blog (Sayed Ibrahim Hashimi) - Yay! Scaffolding CLI and it looks well done too! It's time to try it and if you are interested it's an OSS project.

• Making you more productive with Visual Studio v17.12 - Visual Studio Blog (Mads Kristensen) - Mad's blog post are always synonym of fun and happiness as it means Visual Studio has new cool features that ease or day and make us more productive. I love that that simple copy error message one.

• The Builder Pattern in C# [2024] - This is a very nice post that explains clearly with code different scenarios where that pattern would make sense.

• OpenAPI document generation in .NET 9 (Mike Kistler) - This is a great new feature in NET9 when building APIs. The post shares how to update existing APIs to get it. I'm looking forward to migrating my stuff.

Podcasts

• 435: GitHub Universe Recap + M4 is here with a NEW Mac mini!!! (Merge Conflict) - Cool summary and nice news for iOS user about xCode.

• How to prepare for a nerve-wracking presentation (Modern Mentor) - Good strategies for new or experienced speakers.

Miscellaneous

• Validate your identity on Bluesky with your GitHub account (Mark Downie) - That's a neat trick, sir!

Sharing my Reading Notes is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.

If you have interesting content, share it!

~Frank

Reading Notes #619

It's reading notes time! It is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week. 

You also read something you liked? Share it!

Suggestion of the week

• Easily dock and float tool windows (Mads Kristensen) - Oh my! One of the best post I read since a long time. It cannot me more accurate, funny, nor useful.

Programming

• DevOps for Beginners: A Complete Roadmap to Get Started (Harshhaa Vardhan Reddy) - This post is a really good overview of DevOps. If your are interested to he topic but don't know where to start,that one is for you.

• How to Build Frontend Apps 10x Faster (Anmol Baranwal) - An interesting tools that you install that act as middle man and helps while developing and testing.

• Switch Branches in Git Without Losing Your Work (Asad Bukhari) - Quick little tip to save time with Git.

• Incorporate GitHub Copilot into your daily flow (Rhea,Sinem,Mika) - Copilot go more accessible!This post summarizes how Copilot will be easier to use with suggested code. That's a good example of product feedback well used, everybody wins!

• 5 Must-Have NuGet Packages for .NET Developers: Elevate Your Code! (Ken Fedorov) - Nice post that shares indeed useful packages.

• GitHub Models and .NET: Building Generative AI apps for engineers (April Yoho) - Very easy to use and accessible, those AI models are perfect for developers. GitHub successfully removed many blockers that aloud a fast onboarding experience.

• Semantic Kernel - Multi agent systems (Bart Wullems) - Nice quick post with a lot of to code to helps understand the concept.

~Frank

Reading Notes #601

It's reading notes time! It is a habit I started a long time ago, where I share a list of all the articles, blog posts, and books that catch my interest during the week.

Having interesting content? Share it! 

Suggestion of the week

• Announcing: Azure Developers (Mehul Harry) - Looking forward to this event. I have the pleasure to present a session with Jerry Nixon about Data API Builder. Join us!

Cloud

• Demystifying Azure CLI pagnination (Jeremy Li) - That's great! It's so sad when all the information is "throw" on us without any control and it's on us to find our "needle" we are looking for in those screens full of line. This will definitely helps.

Programming

• Blazor Basics: Localization Using Resource Files (Claudio Bernasconi) - A nice and complete tutorial.

• What's new for .NET in Ubuntu 24.04 - .NET Blog (Richard Lander) - This is a good news! Definitely going in the right direction.

• Minimal APIs Nuget Packages (Shawn Wildermuth) - Same great tools but new names to make it easier to remember and more of the same family.

• Useful features in Entity Framework Core 8 for your application (Dennis Frühauff) - A great post with detailed explanation and code samples that covers the major new feature and enhancements of EF8.

• Better Minimal APIs Endpoint Organization With Carter in ASP.NET Core (Ivan Gechev) - Carter looks like a very useful library definitely something to explore a bit more.

• Warp’s Team plan for developer productivity is available today (Melanie Crissey) - I started using this terminal a few weeks ago on a personal device. It's interesting to see all the different options an the possibilities for teams.

Open Source

• Open sourcing MS-DOS 4.0 - Microsoft Open Source Blog (Scott Hanselman, Jeff Wilcox) - That a cool news! I'm curious what people will do with it, what kind of experiments they will try.

~ Frank

Reading Notes #593

It is time to share new reading notes. It is a habit I started a long time ago where I share a list of all the articles, blog posts, and books that catch my interest during the week.

If you think you may have interesting content, share it!

Cloud

• Azure Functions Extensibility - Runtime Scaling (Tomasz Pęczek) - A well written post that goes in the details.Perfect to really understand how things works.

Programming

• 5 Powerful HTML Attributes That Don't Require JavaScript (Ashish Patel) - Wow! I didn't even known that most of those attributes existed..

• Docker Init for ASP.NET Core Compared to VS or VS Code Extensions (Julie Lerman) - awesome comparison! I've been thinking about doing it for a little while. Another great post from Julie.

• Blazor and .NET 8: How I Built a Fast and Flexible Website (Jeffrey T. Fritz) - optimisation is often a step that people forgets, but it's one that is extremely rewarding.This series seams very interesting, we will s| more of those in the notes...

• Warp, the modern terminal, is now available for Linux (Aloke Desai, David Stern) - I didn't heard of that terminal before. It looks interesting! Looking forward to try it.

• Using Visual Studio Code for .NET MAUI Development (Vijay Anand) - it's incredible the progress that was done in such little time I'm looking forward to try it.

• The FAST and the Fluent: A Blazor story - .NET Blog (Vincent Baaij) - Nice post that teach us a bit of history. I'm fan of Fluent UI and Blazor...and more recently of the Fluent UI Blazor library. I think it's a must for all Blazor developers.

• GraphQL vs. REST—Which is Better for API Design? (Hassan Djirdeh) - Pretty cool comparison of different type/design of APIs.

Miscellaneous

• Windows AI Studio : Getting Started ( Shreyan Fernandes) - Nice tools the works locally. I'm installing it, will you?

~Frank

Reading Notes #591

It is time to share new reading notes. It is a habit I started a long time ago where I share a list of all the articles, blog posts, and books that catch my interest during the week.

If you think you may have interesting content, share it!

Suggestion of the week

• Make demo typing easy with DemoType in ZoomIt v8.0 (John Stephens) - This is such a game changer! Of course live demo are the best but losing precious secondes because of a typo is a real nightmare.

Cloud

• Planning for Resiliency with Azure OpenAI (Matthew Anderson) - Like everything else in the cloud we need to think about resiliency. This nice post get us started and explains 2 different architectures for our system.

• Azure Developer CLI (azd) - February 2024 Release (Grace Kulin) - Cool feature now supported in this new release with helm support for kubernetes and many other features.

Programming

• The Difference Between RESTful APIs and Web APIs Using ASP.NET Core (Januarius Njoku) - A very complete post about APIs their definition and differences.

• Scaling Docker Compose Up (Milas Bowman) - Interesting post that do a deep dive into docker compose file.

• Our Vision for .NET 9 - .NET Blog (.NET Team) - Inspiring plan for the future release of .Net.

• My Top 10 NEW Visual Studio Features of 2023 for .NET Developers - .NET Blog (James Montemagno) - I don't code everyday and when I do it's on all kind of device and OS so I end up more often using VS Code. But, when I can use Visual Studio it's always a treat. In this post, James shares his favorite new features part of that great IDE. Those are only the recent ones, there are so much more!

• Scaling Docker Compose Up (Milas Bowman) - Interesting post that do a deep dive into docker compose file.

• 8 ways to set the URLs for an ASP.NET Core app (Andrew Lock) - What!? So many different ways to assign the url.

~ Frank

Reading Notes #590

It is time to share new reading notes. It is a habit I started a long time ago where I share a list of all the articles, blog posts, and books that catch my interest during the week.

If you think you may have interesting content, share it!

Cloud

• Observability on Azure Container Apps (Abdullah Abu-Hassan) - Great post to get started. We can download all the code required to try it ourself.

• WTH is Azure Copilot? (Sam Cogan) - I believe this copilot will be extremely useful for so many people... including me.

Programming

• Solved! Visual Studio .http File Not Sending Authorization Header (Steve Smith) - The devil is in the details as they say. Great post that shares the investigation of an issues. A time saver.

• Should I put my Blazor components in the server project, or the client project? (Jon Hilton) - Short and clear explanation of the blazor structure, very helpful post.

• How to Make Your Web Sites Accessible (Beau Carnes) - Accessibility is a must and now there a course available on camp to help us making our website accessible.

• What's new for the Microsoft Fluent UI Blazor components 4.4 (Vincent Baaij) - Nice new components. Its going fast!

• Dev Tunnels: A Game Changer for Mobile Developers - .NET Blog (James Montemagno) - Dev Tunnel is definitely a incredible tool.I used it for debugging connector in Power Platform and there is no doubts it will help with mobile app...No more guesses debug with the real thing.

Miscellaneous

• Introducing Sudo for Windows! (Jordi Adoumie) - Wow! This is a really good new feature. How many time a forgot to start my terminal as admin and needed to starry over again...Looking forward to try it.

~Frank

Reading Notes #589

It is time to share new reading notes. It is a habit I started a long time ago where I share a list of all the articles, blog posts, and books that catch my interest during the week.

If you think you may have interesting content, share it!

Cloud

• Using Azure Load Testing to test Multi-Tenant services (Frédéric Le Coquil) - Nice post that explains in details how to test a scale and cost efficiently our API.

• WASI 0.2 Preview: A New Dawn for WebAssembly (Steven J. Vaughan-Nichols ) - Looking forward how WASI will impact our web. Nice little post to quickly understand what it is.

• How to deploy .NET Aspire apps to Azure Container Apps - .NET Blog (Jiachen Jiang) - It looks simple enough don't you think? I'm trying it today!

• Build your Web Apps faster with the Azure Cache for Redis: Quick Start Template ( Ricky Diep) - This is definitely a simple and quick way to deploy all your assets at once. There is a video with a demo.

Programming

• Understanding C# 8 default interface methods (Andrew Lock) - Very clear post about the new feature available in interfaces, with great examples that make us understand why and when it is useful and how to implement it.

Open Source

• Celebrating One Year of Open at Microsoft (Japhlet Nwamu) - It was surely a nice first year.

Podcasts

• Code Visualization with CodeSee's Shanea Leven (Hanselminutes with Scott Hanselman) - Another very interesting episode. CodeSee definitely catches my attention, I'm planning to try it with my OSS project to get started.

~Frank

Reading Notes #588

It is time to share new reading notes. It is a habit I started a long time ago where I share a list of all the articles, blog posts, and books that catch my interest during the week.

If you think you may have interesting content, share it!

Programming

• Developing & Working with .NET Containers on Windows ARM Devices (James Montemagno) - I'm a big fan and user of dev containers.But I didn't know it was hard for Arm device owner.Love the idea.If you never heard of Podman here a nice teaser.

• Overview over Microsoft's developer tools for Windows (Aaron Junker)) - So many great tools to make the dev experience even better on Windows.Did you see so many are oss projects.

• How to deal with API rate limits (Salma Alam-Naylor) - Perfect post to learn why rate limit exists (its easier to manage them if we understand them), and a few suggestions on how to deal with them.

• Persisting Data Volumes With .NET Aspire | LINQ to Fail (Aaron Powell) - Great tips to be more efficient with .NET Aspire preview 2

~Frank

Reading Notes #576

It is time to share new reading notes. It is a habit I started a long time ago where I share a list of all the articles, blog posts, and books that catch my interest during the week.

If you think you may have interesting content, share it!

Suggestion of the week

• Visual Studio Code: C# Dev Kit Now Generally Available (Almir Vuk) - As a .NET developer that spend a lot of time in Linux, I was already using a lot VSCode and started using DevKit curious to see if if would really helps. I felt empowered. Great work, and congrats on the GA that was fast!

Programming

• How to version your ASP.NET API (Dennis Frühauff)- Versioning will stay easy and hard at the same time...But me must give ot our best.... Right?

• Announcing .NET 8 RC2 - .NET Blog (Jon Douglas) - So much in this next release,the team is seeking feedback, if you have some they will be pleased to listen.

• Introducing Windows Terminal Canary (Christopher Nguyen) - That's a brilliant idea how many times I heard people asking to get the earliest bits faster...Well here it is!

• Blazor Basics: Creating a Todo App using Blazor WebAssembly (Claudio Bernasconi) - A tutorial like I like them: simple And where we do stuff! Great place to get started.

Podcasts

• What do we want from a web browser? (The Changelog: Software Development, Open Source) - I think it was my first episode of The Changelog. I liked it. Interesting discussion about what should be a "good" web browser...

~Frank

Reading Notes #575

Happy Thanksgiving to all Canadian🍁! 

It is time to share new reading notes. It is a habit I started a long time ago where I share a list of all the articles, blog posts, and books that catch my interest during the week.

If you think you may have interesting content, share it!

Suggestion of the week

• New experiences designed to make every developer more productive on Windows 11 (Mike Harsh) - Damn! I'm very tented to go right away and reinstall Windows on my dev PC, it looks so great.

Programming

• Get Started with the Microcks Docker Extension for API Mocking and Testing (Ajeet Singh Raina, Yacine Kheddache, Hugo Guerrero) - This looks like an amazing and simple to use tool to test all our API.How doesn't need it.

• Windows Subsystem for Linux September 2023 update (Craig Loewen) - Wow! So many new improvement. Its time for an update which one will it be for you WSL -update or -pre-release update ?

• New Azure DevOps scopes now available for Microsoft Identity OAuth delegated flow apps - Azure DevOps Blog (Angel Wong) - Security is the job of everyone , right? Nice update for Azure DevOps.

• Hugo + VSCode + Docker = ❤️ (Aaryn Smith) - After an upgrade of Hugo or the theme, one of my site wasn't being generated anymore. Happy to to find a that devContainer, I will be able to investigate quickly.

Open Source

• Windows Terminal Preview 1.19 Release (Christopher Nguyen) - Cool updates! I love that right-click web search! You know... when there is an error it will be so much efficient! An that was a community contribution! Fantastic!

• Unlocking DevOps Magic: Dive into the Azure Kubernetes Service Wonderland in Visual Studio Code! (Japhlet Nwamu, Tatsat Mishra) - Great tools that really simplify the life of Azure Kubernetes Services (AKS). It was the topic of an episode of open at Microsoft.

Podcasts

• Introducing TypeChat with Anders Hejlsberg (Hanselminutes with Scott Hanselman) - It's the second time I hear about TypeChat, remember Reading Notes #565, it seams extremely interesting.
• How to rally support for your big idea (Modern Mentor) - Listening to winning strategies to make sure our biggest ideas have good start... It's always a good idea.
• Community and Empowerment with Sharmadean Reid (A Bit of Optimism) - See ideas and challenges as a way to learn more, to learn maybe something different, to climb higher as Simon says, love it.

~Frank

Reading Notes #571

It is time to share new reading notes. It is a habit I started a long time ago where I share a list of all the articles, blog posts, and books that catch my interest during the week. 

If you think you may have interesting content, share it!

Cloud

• Serverless Playwright the easy way with Azure Container Apps (Anthony Chu) - I didn't think about that scenario but wow! Thats very efficient ant much easier.

Programming

• 6 Best Practices for Documenting APIs (Nduka John) - Documentation is often what makes the difference. Bad docs may cause users to not use correctly the APIs.

• New .NET Upgrade Assistant version with feature updates and .NET MAUI improvements! - .NET Blog (Olia Gavrysh) - Wow that a pretty cool and powerful tool! I really like the mixed upgrade with project file and version.

• Generative AI and .NET - Part 2 SDK | LINQ to Fail (Aaron Powell) - Nice series where we explore the SDK building a .NET poroject.

Open Source

• Walkthroughs in the Windows Terminal Repository (Mike Griese) - Contributing to big oss project is challenging.The Windows Terminal team had a cool idea to make it easier.There is a video version of this blog is you prefer.

• Microsoft PowerToys v0.73.0: A Comprehensive Overview (Kunal Chowdhury) - Cool post that shares new utilities in PowerToys and explains the optimization of the others.

Miscellaneous

• Navigating Developer Burnout: Causes, Impacts, and Strategies for a Ba (Christopher Johnson) - A truthful and realistic post. If you never been exposed to burnout, take 2 minutes to read this.

~Frank

Reading Notes #567

Programming

• Debugging .NET Containers with Visual Studio Code Docker Tools - .NET Blog (Chet Husk) - This new version of the tools looks brillannt! Definitely a must try asap.

• Docker for Developers: Understanding the Core Concepts (Dan Wahlin) - This is a very nice and detailled article that explains what is Docker where it comes from and how it works.

• .NET Conf 2023 (Mehul Harry) - Net cof is coming reverse the dates! And for those if you who knows .NET there is a call for paper here is your chance the share your knowledge!

• Power Platform as Connected Service for Visual Studio is Generally Available | Power Platform Developer Blog (Marcel Ferreira) - Its now GA! This is an excellent news.Using this its now easier thann ever to transform our APIs to power platform connector and empower everyone not fust the developers.

DevOps

• How to deploy Azure Container Apps (Shawn Sesna) - This is a grewt tutorial to get your container Apps deploy without having to care about to much infrastructure aka.kubernetes.

Podcasts

• Beyond the Hype: WebAssembly – from the browser to beyond (Colin Eberhardt) - Episode of a new podcast for me! They got me with WebAssembly and I will defenetly listen to more episodes.

• Kevin LaBranche: Leading teams through DevOps - Episode 251 (Azure DevOps Podcast) - Yes! DevOps is not a thing you implement in 2-3 weeks, it takes time. Great episode that highlight even more that it's not about the tech but the way you do things...

Frank