Forem: David Au Yeung

How AI Can Help You Recover Your Bitcoin

David Au Yeung — Sat, 16 May 2026 10:18:21 +0000

Introduction

When people talk about Artificial Intelligence today, the conversation usually revolves around chatbots, image generators, coding assistants, or office productivity.

But a recent news shared by Yahoo!Tech caught my attention for a very different reason.

According to the report, an X user known as cprkrn claimed that after being locked out of his Bitcoin wallet for 11 years, he finally recovered access with the help of Claude AI.

The wallet reportedly contained 5 BTC. Based on the approximate market price mentioned in the report, that was worth more than HKD 3 million.

The interesting part was not that AI "hacked Bitcoin".

It did not.

Instead, the user reportedly had:

An old computer
Old wallet files
Some forgotten notes
A seed phrase
A long-forgotten password pattern
Many years of messy digital history

AI helped connect the dots.

This is not a story about breaking cryptography.

It is a story about AI-assisted memory reconstruction.

And that opens up a powerful idea:

AI may not break encryption, but it can help us rediscover the human context around things we forgot.

This article explores:

How AI can reduce password search space
Why this is different from brute force cracking
How old notes can become useful signals
How to build a safe educational C# demo
How to use Ollama and Kimi as the LLM engine
Why privacy and ethics matter

Important:

This project is for education and simulation only.

It does not recover real Bitcoin wallets.

It does not parse real wallet.dat files.

It does not crack encryption.

It must not be used against anyone else’s accounts, wallets, devices, or data.

What Actually Happened Conceptually

The reported Bitcoin recovery story can be understood like this:

Old computer files
    ↓
Old wallet file discovered
    ↓
Old notes and memory fragments analyzed
    ↓
Possible password patterns reconstructed
    ↓
Seed phrase / wallet artifacts matched
    ↓
Wallet access recovered

The important distinction is this:

AI did not defeat Bitcoin cryptography.
AI helped organize messy human memory.

Bitcoin itself relies on strong cryptographic systems.

But humans often create passwords based on:

Emotions
Old events
Favorite words
Personal habits
Dates
Naming formats
Repeated patterns

That is where AI becomes useful.

Brute Force vs AI-Assisted Reasoning

A brute force approach looks like this:

Try every possible combination.
Try millions, billions, or trillions of passwords.
Hope one works.

This is expensive, slow, and usually unrealistic.

AI-assisted reasoning works differently.

Instead of attacking the encryption directly, it attacks the uncertainty around the human-created password.

It looks for clues such as:

Old notes
Diary fragments
File names
Repeated words
Emotional context
Important years
Formatting habits
Common personal patterns

So the workflow becomes:

Messy notes
    ↓
LLM analysis
    ↓
Ranked password candidates
    ↓
Local verification

That last step is important.

The LLM should generate candidates.

The actual verification should happen locally.

The Sample Exercise

For this article, we will create a safe simulation.

We will pretend that we found two old text files from an old computer:

old_notes.txt
diary_fragment.txt

These files contain clues.

The hidden mock password will be:

memory_police_2014

But in a real recovery situation, we would not know that.

The goal of the demo is to see whether an LLM can infer likely candidates from the notes.

Sample File 1: old_notes.txt

2014 - bought BTC when it was around 230 USD
Used police story as password theme before
Memory + river + sunset were words I liked back then
Laptop password had underscore format
Sometimes I append the year to important accounts

Sample File 2: diary_fragment.txt

Can't believe I finally bought Bitcoin.
Police documentary inspired me that week.
Maybe I should combine memory and police somehow.
Don't forget 2014 was important.

These notes are simple, but they contain strong human signals:

Clue	Possible Meaning
`memory`	likely password word
`police`	likely password word
`2014`	likely suffix
underscore format	likely separator
"combine memory and police"	likely word order
BTC price 230	possible alternative suffix

A human might miss the pattern.

An LLM can rank it immediately.

The Prompt We Give to the LLM

Here is the kind of prompt we will send to the model:

You are assisting in a password reconstruction exercise for a simulated wallet recovery.

This is an educational exercise using fake data.
The wallet is a local mock wallet owned by the user.

Your task:
1. Read the recovered historical notes.
2. Identify recurring words, themes, years, and formatting habits.
3. Generate 15 structured password candidates ranked by likelihood.
4. Prefer underscore separators if the notes suggest that style.
5. Consider important years or numbers as suffixes.
6. Do not brute force.
7. Do not generate random unrelated strings.
8. Return JSON only.

Recovered notes:

[old_notes.txt and diary_fragment.txt content here]

The key idea is:

Do not ask the model to crack anything.
Ask the model to reason from context.

Example LLM Result

In my test using Kimi through Ollama, the model generated a ranked candidate list similar to this:

Rank	Password Candidate	Rationale
1	`memory_police_2014`	Direct use of "combine memory and police" + underscore + year
2	`police_memory_2014`	Reverse order variation
3	`memory_river_sunset`	Uses three liked words
4	`police_story_2014`	Police story theme + year
5	`river_sunset_memory`	Alternative ordering of liked words
6	`memory_documentary_2014`	Memory + documentary clue
7	`memory_river_2014`	Liked word + year
8	`sunset_memory_2014`	Liked word + year
9	`police_river_2014`	Cross-combination
10	`river_memory_2014`	Alternative pair
11	`police_sunset_2014`	Cross-combination
12	`memory_2014`	Minimal pattern
13	`police_memory_230`	Uses BTC price clue
14	`memory_police_230`	Price-based variation
15	`sunset_river_2014`	Nature-themed pair + year

The important thing is not the exact output.

The important thing is that the model did not generate random strings like:

xJ9#qPz882!

Instead, it generated human-plausible candidates from the notes.

That is the value of AI here.

Demo Architecture

Our safe simulation looks like this:

old_notes.txt
diary_fragment.txt
        ↓
Ollama + Kimi model
        ↓
JSON password candidates
        ↓
Local mock wallet verifier
        ↓
Success / failure result

The LLM only sees the notes.

It does not receive:

A real wallet file
A private key
A seed phrase
A real password hash
A real Bitcoin address

The verification happens locally inside our C# program.

This is safer and cleaner

Technical Setup

This demo uses OllamaApiClient from OllamaSharp. OllamaSharp documents GenerateAsync for single-turn completions and the Chat class for conversational workflows; Ollama’s own API documentation also describes /api/generate and /api/chat streaming endpoints. (awaescher.github.io)

Create a new console app:

dotnet new console -n AiWalletRecoveryDemo
cd AiWalletRecoveryDemo
dotnet add package OllamaSharp

Make sure your Ollama endpoint is running at:

http://localhost:11434

The sample code defaults to:

string modelName = "kimi-k2.6:cloud";

If you used another model, such as kimi-k2.5, pass it as an argument:

dotnet run -- kimi-k2.5

Project Structure

AiWalletRecoveryDemo/
│
├── AiWalletRecoveryDemo.csproj
├── Program.cs
│
└── sample-data/
    ├── old_notes.txt
    ├── diary_fragment.txt
    └── mock_wallet.json

The program will create the sample files automatically if they do not exist.

Full Educational C# Example

Program.cs

using OllamaSharp;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;

internal static class Program
{
    // Educational only:
    // In a real recovery situation, you would NOT know this value.
    // We use it only to create a local mock wallet verifier.
    private const string DemoPassword = "memory_police_2014";

    public static async Task Main(string[] args)
    {
        Console.OutputEncoding = Encoding.UTF8;

        string modelName = args.Length > 0 ? args[0] : "kimi-k2.6:cloud";
        string ollamaApiUrl = args.Length > 1 ? args[1] : "http://localhost:11434";

        string dataDirectory = Path.Combine(Directory.GetCurrentDirectory(), "sample-data");
        string mockWalletPath = Path.Combine(dataDirectory, "mock_wallet.json");

        Console.WriteLine("AI-Assisted Wallet Recovery Simulation");
        Console.WriteLine("---------------------------------------");
        Console.WriteLine($"Ollama URL : {ollamaApiUrl}");
        Console.WriteLine($"Model      : {modelName}");
        Console.WriteLine();

        DemoData.EnsureCreated(dataDirectory, DemoPassword);

        string recoveredNotes = DemoData.ReadAllNotes(dataDirectory);
        var mockWallet = MockWalletVault.Load(mockWalletPath);

        var generator = new OllamaCandidateGenerator(
            ollamaApiUrl: ollamaApiUrl,
            modelName: modelName,
            wikiRootDirectory: dataDirectory);

        IReadOnlyList<PasswordCandidate> candidates;

        try
        {
            candidates = await generator.GenerateCandidatesAsync(recoveredNotes);
        }
        catch (Exception ex)
        {
            Console.WriteLine("LLM generation failed.");
            Console.WriteLine($"Reason: {ex.Message}");
            Console.WriteLine();
            Console.WriteLine("Using deterministic fallback candidates for demo continuity.");
            Console.WriteLine();

            candidates = FallbackCandidateGenerator.Generate();
        }

        var uniqueCandidates = candidates
            .Where(c => !string.IsNullOrWhiteSpace(c.Password))
            .Select(c => c with { Password = c.Password.Trim() })
            .GroupBy(c => c.Password, StringComparer.Ordinal)
            .Select((g, index) => g.First() with { Rank = index + 1 })
            .Take(25)
            .ToList();

        Console.WriteLine("Ranked Password Candidates");
        Console.WriteLine("--------------------------");

        foreach (var candidate in uniqueCandidates)
        {
            Console.WriteLine($"#{candidate.Rank}: {candidate.Password}");
            Console.WriteLine($"    Reason: {candidate.Rationale}");
        }

        Console.WriteLine();
        Console.WriteLine("Testing candidates against local mock wallet...");
        Console.WriteLine();

        PasswordCandidate? successfulCandidate = null;

        foreach (var candidate in uniqueCandidates)
        {
            bool isMatch = mockWallet.Verify(candidate.Password);

            if (isMatch)
            {
                successfulCandidate = candidate;
                break;
            }
        }

        if (successfulCandidate is not null)
        {
            Console.WriteLine($"✅ Mock wallet unlocked with candidate #{successfulCandidate.Rank}:");
            Console.WriteLine(successfulCandidate.Password);
        }
        else
        {
            Console.WriteLine("❌ No candidate unlocked the mock wallet.");
            Console.WriteLine("Try adding more historical notes or stronger clues.");
        }

        Console.WriteLine();
        Console.WriteLine("Simulation complete.");
    }
}

public sealed class OllamaCandidateGenerator
{
    private readonly OllamaApiClient _ollamaClient;
    private readonly string _wikiRootDirectory;

    public OllamaCandidateGenerator(
        string ollamaApiUrl = "http://localhost:11434",
        string modelName = "kimi-k2.6:cloud",
        string? wikiRootDirectory = null)
    {
        _ollamaClient = new OllamaApiClient(new Uri(ollamaApiUrl))
        {
            SelectedModel = modelName
        };

        _wikiRootDirectory = wikiRootDirectory ?? Directory.GetCurrentDirectory();
    }

    public async Task<IReadOnlyList<PasswordCandidate>> GenerateCandidatesAsync(
        string recoveredNotes,
        CancellationToken cancellationToken = default)
    {
        string prompt = BuildPrompt(recoveredNotes);

        var responseBuilder = new StringBuilder();

        await foreach (var stream in _ollamaClient.GenerateAsync(
            prompt,
            context: null,
            cancellationToken: cancellationToken))
        {
            if (!string.IsNullOrEmpty(stream?.Response))
            {
                responseBuilder.Append(stream.Response);
            }
        }

        string rawResponse = responseBuilder.ToString();

        var candidates = ParseCandidates(rawResponse);

        if (candidates.Count == 0)
        {
            throw new InvalidOperationException(
                "The model did not return valid password candidates.");
        }

        return candidates;
    }

    private string BuildPrompt(string recoveredNotes)
    {
        return $$"""
            You are assisting in a password reconstruction exercise for a simulated wallet recovery.

            This is an educational exercise using fake data.
            The mock wallet belongs to the user.
            Do not provide hacking instructions.
            Do not suggest brute force tools.
            Do not suggest unauthorized access.
            Do not generate random unrelated strings.

            Your task:
            1. Read the recovered historical notes.
            2. Identify recurring words, themes, dates, numbers, and formatting habits.
            3. Generate exactly 15 structured password candidates ranked by likelihood.
            4. Prefer underscore separators if the notes suggest that style.
            5. Consider important years or numbers as suffixes.
            6. Prefer candidates that follow explicit diary wording.
            7. Return valid JSON only.
            8. Do not wrap the JSON in Markdown.

            Return this JSON shape:

            {
              "candidates": [
                {
                  "rank": 1,
                  "password": "example_candidate",
                  "rationale": "Short explanation"
                }
              ]
            }

            Recovered notes:

            {{recoveredNotes}}
        """;
    }

    private static IReadOnlyList<PasswordCandidate> ParseCandidates(string rawResponse)
    {
        string json = ExtractJsonObject(rawResponse);

        var options = new JsonSerializerOptions
        {
            PropertyNameCaseInsensitive = true
        };

        var parsed = JsonSerializer.Deserialize<CandidateResponse>(json, options);

        return parsed?.Candidates?
            .OrderBy(c => c.Rank)
            .ToList()
            ?? new List<PasswordCandidate>();
    }

    private static string ExtractJsonObject(string text)
    {
        string cleaned = text.Trim();

        cleaned = Regex.Replace(
            cleaned,
            "^```
{% endraw %}
(?:json)?\\s*",
            "",
            RegexOptions.IgnoreCase);

        cleaned = Regex.Replace(
            cleaned,
            "\\s*
{% raw %}
```$",
            "",
            RegexOptions.IgnoreCase);

        int start = cleaned.IndexOf('{');
        int end = cleaned.LastIndexOf('}');

        if (start < 0 || end <= start)
        {
            throw new FormatException("No JSON object found in model response.");
        }

        return cleaned.Substring(start, end - start + 1);
    }
}

public sealed record PasswordCandidate
{
    [JsonPropertyName("rank")]
    public int Rank { get; init; }

    [JsonPropertyName("password")]
    public string Password { get; init; } = "";

    [JsonPropertyName("rationale")]
    public string Rationale { get; init; } = "";
}

public sealed class CandidateResponse
{
    [JsonPropertyName("candidates")]
    public List<PasswordCandidate> Candidates { get; set; } = new();
}

public sealed class MockWalletVault
{
    private static readonly JsonSerializerOptions JsonOptions = new()
    {
        WriteIndented = true,
        PropertyNameCaseInsensitive = true
    };

    [JsonPropertyName("description")]
    public string Description { get; set; } = "Educational mock wallet. This is not a real Bitcoin wallet.";

    [JsonPropertyName("saltBase64")]
    public string SaltBase64 { get; set; } = "";

    [JsonPropertyName("passwordHashBase64")]
    public string PasswordHashBase64 { get; set; } = "";

    public static MockWalletVault CreateFromPassword(string password)
    {
        byte[] salt = RandomNumberGenerator.GetBytes(16);
        byte[] hash = HashPassword(password, salt);

        return new MockWalletVault
        {
            SaltBase64 = Convert.ToBase64String(salt),
            PasswordHashBase64 = Convert.ToBase64String(hash)
        };
    }

    public static MockWalletVault Load(string path)
    {
        string json = File.ReadAllText(path);

        return JsonSerializer.Deserialize<MockWalletVault>(json, JsonOptions)
            ?? throw new InvalidOperationException("Unable to load mock wallet.");
    }

    public void Save(string path)
    {
        string json = JsonSerializer.Serialize(this, JsonOptions);
        File.WriteAllText(path, json);
    }

    public bool Verify(string candidatePassword)
    {
        byte[] salt = Convert.FromBase64String(SaltBase64);
        byte[] expectedHash = Convert.FromBase64String(PasswordHashBase64);
        byte[] actualHash = HashPassword(candidatePassword, salt);

        return CryptographicOperations.FixedTimeEquals(actualHash, expectedHash);
    }

    private static byte[] HashPassword(string password, byte[] salt)
    {
        // Educational local verifier.
        // This is not Bitcoin Core wallet encryption.
        using var pbkdf2 = new Rfc2898DeriveBytes(
            password,
            salt,
            iterations: 100_000,
            hashAlgorithm: HashAlgorithmName.SHA256);

        return pbkdf2.GetBytes(32);
    }
}

public static class DemoData
{
    private const string OldNotesFileName = "old_notes.txt";
    private const string DiaryFileName = "diary_fragment.txt";
    private const string MockWalletFileName = "mock_wallet.json";

    private const string OldNotesText = """
    2014 - bought BTC when it was around 230 USD
    Used police story as password theme before
    Memory + river + sunset were words I liked back then
    Laptop password had underscore format
    Sometimes I append the year to important accounts
    """;

    private const string DiaryFragmentText = """
    Can't believe I finally bought Bitcoin.
    Police documentary inspired me that week.
    Maybe I should combine memory and police somehow.
    Don't forget 2014 was important.
    """;

    public static void EnsureCreated(string dataDirectory, string demoPassword)
    {
        Directory.CreateDirectory(dataDirectory);

        string oldNotesPath = Path.Combine(dataDirectory, OldNotesFileName);
        string diaryPath = Path.Combine(dataDirectory, DiaryFileName);
        string mockWalletPath = Path.Combine(dataDirectory, MockWalletFileName);

        if (!File.Exists(oldNotesPath))
        {
            File.WriteAllText(oldNotesPath, OldNotesText);
        }

        if (!File.Exists(diaryPath))
        {
            File.WriteAllText(diaryPath, DiaryFragmentText);
        }

        if (!File.Exists(mockWalletPath))
        {
            var wallet = MockWalletVault.CreateFromPassword(demoPassword);
            wallet.Save(mockWalletPath);
        }
    }

    public static string ReadAllNotes(string dataDirectory)
    {
        var builder = new StringBuilder();

        foreach (string file in Directory
            .EnumerateFiles(dataDirectory, "*.txt", SearchOption.AllDirectories)
            .OrderBy(f => f))
        {
            builder.AppendLine($"--- {Path.GetFileName(file)} ---");
            builder.AppendLine(File.ReadAllText(file));
            builder.AppendLine();
        }

        return builder.ToString();
    }
}

public static class FallbackCandidateGenerator
{
    public static IReadOnlyList<PasswordCandidate> Generate()
    {
        return new List<PasswordCandidate>
        {
            new()
            {
                Rank = 1,
                Password = "memory_police_2014",
                Rationale = "Direct implementation of diary note: combine memory and police, underscore format, year suffix."
            },
            new()
            {
                Rank = 2,
                Password = "police_memory_2014",
                Rationale = "Reverse order variation using the same strong clues."
            },
            new()
            {
                Rank = 3,
                Password = "memory_river_sunset",
                Rationale = "Uses three liked words with underscore formatting."
            },
            new()
            {
                Rank = 4,
                Password = "police_story_2014",
                Rationale = "References previous police story theme and important year."
            },
            new()
            {
                Rank = 5,
                Password = "river_sunset_memory",
                Rationale = "Alternative ordering of liked words."
            },
            new()
            {
                Rank = 6,
                Password = "memory_documentary_2014",
                Rationale = "Combines memory with police documentary clue and year."
            },
            new()
            {
                Rank = 7,
                Password = "memory_river_2014",
                Rationale = "Liked word pair plus year suffix."
            },
            new()
            {
                Rank = 8,
                Password = "sunset_memory_2014",
                Rationale = "Liked word combination plus year."
            },
            new()
            {
                Rank = 9,
                Password = "police_river_2014",
                Rationale = "Cross-combination of police theme, liked word, and year."
            },
            new()
            {
                Rank = 10,
                Password = "river_memory_2014",
                Rationale = "Alternative liked word pair plus year."
            },
            new()
            {
                Rank = 11,
                Password = "police_sunset_2014",
                Rationale = "Cross-combination of police theme, liked word, and year."
            },
            new()
            {
                Rank = 12,
                Password = "memory_2014",
                Rationale = "Minimal pattern using important word and year."
            },
            new()
            {
                Rank = 13,
                Password = "police_memory_230",
                Rationale = "Uses BTC price clue instead of year."
            },
            new()
            {
                Rank = 14,
                Password = "memory_police_230",
                Rationale = "Price-based variation of the strongest phrase."
            },
            new()
            {
                Rank = 15,
                Password = "sunset_river_2014",
                Rationale = "Nature-themed pair plus year suffix."
            }
        };
    }
}

Example Output

Your result may vary depending on the model, but a successful run may look like this:

This is exactly the concept we want to demonstrate.

The model does not break encryption.

It simply turns messy personal history into a ranked list of likely hypotheses.

What AI Actually Contributes

The difference between brute force and AI reasoning is not magic.

It is context.

Brute force says:

Try everything.

AI-assisted reasoning says:

Try what the human was most likely to create.

In this exercise, the LLM extracted:

Signal	Extracted Insight
`memory`	important word
`police`	important theme
`combine memory and police`	likely word pairing
underscore format	separator style
`2014`	likely suffix
BTC price `230`	alternative numeric suffix
diary wording	word order clue

This changes the search problem from:

Trillions of random guesses

to:

15 structured candidates

That is the power.

AI reduces chaos.

Why This Is Not "AI Cracking Bitcoin"

This point is very important.

Bitcoin was not broken.

Cryptography was not defeated.

The AI did not discover a private key from the blockchain.

The AI did not reverse SHA-256.

The AI did not bypass wallet encryption.

Instead, the AI helped with:

Pattern recognition
File interpretation
Note summarization
Candidate ranking
Human memory reconstruction

That is a completely different category.

A good analogy is this:

Encryption is the locked safe.
AI helps you search your old notebooks for the combination.

The safe is still strong.

The weakness is human memory.

Privacy Warning

This is where we need to be careful.

If you use a cloud model, do not upload:

Real seed phrases
Private keys
Real wallet files
Password databases
Full disk images
Sensitive personal documents

Even if your intention is legitimate, sending secrets to a cloud model can create serious privacy risk.

A safer workflow is:

Sensitive file stays local
    ↓
You extract non-secret clues
    ↓
LLM generates candidate ideas
    ↓
Verification happens locally

For example, instead of sending this:

seed phrase: apple apple apple ...
wallet.dat file attached

Send only sanitized hints like:

I often used words related to memory, police, river, and 2014.
I used underscores in passwords at that time.

The LLM should help with reasoning.

It should not become a place where secrets are stored.

How This Pattern Applies Beyond Bitcoin

This same AI-assisted recovery pattern can apply to many areas:

Old encrypted ZIP archives
Forgotten developer keystores
Legacy configuration files
Personal knowledge archives
Digital estate planning
Old project recovery
Family photo backup restoration
Enterprise documentation reconstruction

The common pattern is:

Messy historical data
    ↓
AI-assisted organization
    ↓
Ranked hypotheses
    ↓
Local verification

This is why I find the story so interesting.

It shows AI being used not as a chatbot, but as a digital archaeologist.

Security Lessons

There is also a defensive lesson here.

If AI can infer human password patterns from old notes, then we should avoid creating passwords from personal context.

Better practices:

Use a password manager
Use long random passwords
Avoid emotional or memorable phrases
Avoid years, birthdays, and repeated themes
Do not store seed phrases digitally
Use hardware wallets for serious crypto storage
Keep offline backups in physically secure locations
Separate password hints from actual recovery material

Human-style passwords are easy to remember.

That is exactly why they can be guessed.

Conclusion

The reported Bitcoin recovery story is not about AI defeating cryptography.

It is about AI helping a person reconstruct forgotten context.

That may become one of AI's most underrated uses.

Not replacing humans.

Not magically solving everything.

But helping us search, organize, and reason through the complexity we created over years of digital life.

In this demo, we used:

Old notes
A diary fragment
Ollama
Kimi
C#
A local mock wallet verifier

And we simulated the same core idea safely:

Forgotten memory → AI reasoning → candidate ranking → local verification

The future of AI may not only be automation.

It may also be recovery.

Recovering old knowledge.

Recovering lost context.

Recovering forgotten work.

Recovering what we once knew but could no longer find.

AI did not break the lock.

It helped us remember where we left the key.

References

OllamaSharp documentation for GenerateAsync, Chat, and OllamaApiClient. (awaescher.github.io)
Ollama API documentation for /api/generate and /api/chat. (github.com)

Love C# & AI!

Forget Your RAG: Build Your Own LLM Wiki in C# with Ollama + Kimi (Step‑by‑Step Guide)

David Au Yeung — Wed, 06 May 2026 09:11:14 +0000

Introduction

Happy coding! Today I want to share a practical AI tutorial in .NET style, with real code, simple architecture, and a result you can run on your own machine.

When many developers start building AI knowledge assistants, the first idea is usually RAG. That is a good choice in many cases, but not always the simplest one. Sometimes, your knowledge base is actually small, focused, and stable. In that lovely situation, building a small LLM Wiki can be a more elegant choice.

Let me tell a short lovely story.

Imagine a small tea house run by a kind grandmother. Every morning, her grandchildren ask the same questions:

Which tea is good for a cold day?
Which dessert has nuts?
What is the house special today?

Now imagine two ways to help them.

The first way is to hire a fast librarian who runs to a giant archive room every time a child asks a question. That is a bit like RAG.
The second way is to write one beautiful, well-organized family handbook and keep it on the table all the time. That is a bit like an LLM Wiki.

If the tea house menu is small and stable, the handbook is often faster, simpler, and more reliable. But if the tea house becomes a huge restaurant chain with thousands of daily updates, you will eventually want the librarian too.

That is the heart of LLM Wiki vs RAG.

In this tutorial, we will build an open-source local LLM Wiki demo in C# using:

.NET 8
Ollama
OllamaSharp
a local markdown-based wiki structure
the kimi-k2.6:cloud Ollama model

By the end, you will have:

a console-based demo app
a LocalWiki folder with markdown files
document ingestion logic
index maintenance logic
wiki question-answering logic
a clear understanding of when to use a wiki instead of RAG

What We Are Building

We are building a small local AI workflow like this:

Prepare a source document.
Send that document to an LLM through Ollama.
Ask the LLM to return structured wiki content.
Save the result as markdown in a local wiki folder.
Update Index.md automatically.
Ask questions against the wiki content.
Let the model answer using the wiki instead of the raw source file.

This is not a full vector database pipeline. It is intentionally lighter.

LLM Wiki vs RAG

Before we code, let us understand the design choice.

What is RAG?

Retrieval-Augmented Generation (RAG) improves LLM output by retrieving relevant information from external sources before generating a response. Instead of depending only on training data, the model gets fresh context from documents, databases, or web content.

Common characteristics of RAG:

dynamic retrieval at question time
usually based on chunking + embeddings + vector search
good for large and changing knowledge bases
better for source attribution and enterprise-scale search
more infrastructure and tuning effort

What is an LLM Wiki?

An LLM Wiki is a curated, structured markdown knowledge base written so the model can reason over it directly. Rather than retrieving many chunks at runtime, you keep important domain knowledge in concise markdown files and pass those files into the model context.

Common characteristics of an LLM Wiki:

markdown-first knowledge organization
compact, human-readable, and model-friendly
great for small and stable domains
simple to maintain for focused use cases
low setup cost compared with a full RAG pipeline

When should you use a Wiki instead of RAG?

A wiki is a strong choice when:

your knowledge base is relatively small
your content changes slowly
you want to ship fast
you prefer markdown and file-based maintenance
you want fewer moving parts
you are building a demo, prototype, internal assistant, or focused domain tool

RAG is usually better when:

you have a very large knowledge base
documents change frequently
you need deep retrieval across many domains
you need richer source attribution and search behavior
your content does not fit comfortably into context

A practical rule of thumb

Start with an LLM Wiki if your knowledge is:

focused
stable
not too large
curated by humans or AI into clean markdown

Move to RAG when your knowledge becomes:

too large
too dynamic
too fragmented
too cross-domain

And yes, a hybrid approach is often best:

use a wiki for stable core knowledge
use RAG for large or fast-changing content

References and background reading

The ideas in this tutorial align with public explanations of RAG and LLM Wiki tradeoffs, including:

Wikipedia on Retrieval-Augmented Generation
AWS explanation of RAG and external knowledge grounding
MindStudio and 99helpers comparisons of LLM Wiki vs RAG for smaller knowledge bases

Prerequisites

Before we begin, make sure you have the following:

Visual Studio or another C# IDE
.NET 8 SDK
Ollama installed locally
the Kimi model available through Ollama
a Windows terminal or PowerShell

To use the model from this demo, run:

ollama run kimi-k2.6:cloud

If Ollama is already running, that is enough for the demo.

Step 1: Create the Console App

If you want to build this from scratch in a new workspace, start with:

dotnet new console -n LLMWikiDemo
cd LLMWikiDemo

In this project, the feature was added into an existing .NET 8 console app, but the same idea applies to a fresh app.

Step 2: Add the NuGet Package

Add OllamaSharp so your C# application can talk to Ollama:

dotnet add package OllamaSharp

In this workspace, the project file already contains:

<PackageReference Include="OllamaSharp" Version="5.4.25" />

Step 3: Define the Architecture

To keep the system architecture simple, we use these parts:

Program.cs as the entry point
LlmWikiManager.cs as the core service
LocalWiki/ as the generated markdown wiki
SCHEMA.md to define the wiki rules
Index.md as the article catalog
Articles/ for wiki pages

The flow is:

Source Document
    -> LlmWikiManager.IngestDocumentAsync(...)
    -> Ollama / Kimi model
    -> JSON-like structured response
    -> Markdown article
    -> Index.md update
    -> QueryWikiAsync(...)
    -> Answer from wiki context

Step 4: Create the Wiki Manager

The main logic lives in Utils/LLMWikiManager.cs.

This class is responsible for:

creating the wiki folders
creating SCHEMA.md and Index.md
sending prompts to Ollama
parsing the model response
writing article markdown
reading article markdown back for Q&A

The manager constructor

We configure the Ollama endpoint and default model here:

public LlmWikiManager(
    string ollamaApiUrl = "http://localhost:11434",
    string modelName = "kimi-k2.6:cloud",
    string? wikiRootDirectory = null)
{
    _ollamaClient = new OllamaApiClient(new Uri(ollamaApiUrl))
    {
        SelectedModel = modelName
    };

    _wikiDirectory = wikiRootDirectory ?? Path.Combine(AppContext.BaseDirectory, "LocalWiki");
    _schemaFilePath = Path.Combine(_wikiDirectory, "SCHEMA.md");
    _indexFilePath = Path.Combine(_wikiDirectory, "Index.md");
    _articlesDirectory = Path.Combine(_wikiDirectory, "Articles");
}

This means the wiki is generated near the app runtime folder, and the model defaults to kimi-k2.6:cloud.

Step 5: Bootstrap the Wiki Structure

We want the app to create the wiki structure automatically if it does not exist.

public async Task EnsureWikiStructureAsync()
{
    Directory.CreateDirectory(_wikiDirectory);
    Directory.CreateDirectory(_articlesDirectory);

    if (!File.Exists(_schemaFilePath))
    {
        await File.WriteAllTextAsync(_schemaFilePath, DefaultSchema);
    }

    if (!File.Exists(_indexFilePath))
    {
        var initialIndex = "# Local Wiki Index" + Environment.NewLine + Environment.NewLine;
        await File.WriteAllTextAsync(_indexFilePath, initialIndex);
    }
}

This is one of the reasons the wiki approach feels nice. It is file-based, easy to inspect, and easy to explain.

Step 6: Stream Text from Ollama

OllamaSharp returns generation results as an async stream, so we collect the response text like this:

private async Task<string> GenerateTextAsync(string prompt)
{
    var builder = new StringBuilder();

    await foreach (var chunk in _ollamaClient.GenerateAsync(prompt))
    {
        if (!string.IsNullOrWhiteSpace(chunk?.Response))
        {
            builder.Append(chunk.Response);
        }
    }

    return builder.ToString();
}

This is a small but important detail. If you try to await the sequence directly, the build will fail. You must use await foreach.

Step 7: Ingest a Source Document

Now comes the most interesting part.

When a source document arrives, we:

read the file
read the schema
ask the model to return structured wiki data
parse the result
create a markdown article
update Index.md

The ingestion prompt

The ingestion prompt in LlmWikiManager.cs looks like this:

var ingestionPrompt = $"""
    You are an AI assistant maintaining a markdown wiki.

    Schema:
    ---
    {schemaContent}
    ---

    Process this source document and respond with ONLY one JSON object using these keys:
    - summaryTitle: concise title for the article
    - summaryFilename: kebab-case markdown filename
    - summaryContent: full markdown article body
    - indexUpdate: one markdown bullet linking article from Index.md

    Source filename: {sourceFileName}
    Source document:
    ---
    {sourceContent}
    ---
 """;

This is a practical pattern:

tell the model who it is
give it the wiki rules
give it the source content
enforce a structured output format

The ingestion method

A simplified view of the ingestion code:

public async Task<LlmWikiIngestionResult> IngestDocumentAsync(string sourceFilePath)
{
    await EnsureWikiStructureAsync();

    var sourceContent = await File.ReadAllTextAsync(sourceFilePath);
    var schemaContent = await File.ReadAllTextAsync(_schemaFilePath);
    var sourceFileName = Path.GetFileName(sourceFilePath);

    var responseText = await GenerateTextAsync(ingestionPrompt);
    var parsed = TryParseIngestionPayload(responseText);

    var summaryTitle = !string.IsNullOrWhiteSpace(parsed?.SummaryTitle)
        ? parsed!.SummaryTitle!
        : $"Summary of {Path.GetFileNameWithoutExtension(sourceFileName)}";

    var summaryFilename = NormalizeSummaryFilename(parsed?.SummaryFilename ?? string.Empty, summaryTitle);

    var summaryContent = !string.IsNullOrWhiteSpace(parsed?.SummaryContent)
        ? parsed!.SummaryContent!
        : BuildFallbackSummaryContent(sourceFileName, sourceContent);

    var summaryFilePath = Path.Combine(_articlesDirectory, summaryFilename);
    await File.WriteAllTextAsync(summaryFilePath, summaryContent);

    var normalizedRelativeArticlePath = $"Articles/{summaryFilename}";
    var indexUpdate = !string.IsNullOrWhiteSpace(parsed?.IndexUpdate)
        ? parsed!.IndexUpdate!.Trim()
        : $"- [{summaryTitle}]({normalizedRelativeArticlePath})";

    // append to Index.md if needed
}

Why fallback logic matters

Real LLMs are helpful, but sometimes they do not follow the JSON contract perfectly.

That is why the demo includes:

JSON extraction from mixed text
deserialization attempts
fallback summary generation
filename normalization
index deduplication

This makes the POC stronger and more production-minded than a fragile one-shot prompt demo.

Step 8: Parse the LLM Response Safely

Structured AI output is never perfect, so the code extracts the JSON object defensively.

private static string? ExtractJsonObject(string text)
{
    if (string.IsNullOrWhiteSpace(text))
    {
        return null;
    }

    var start = text.IndexOf('{');
    var end = text.LastIndexOf('}');

    if (start < 0 || end <= start)
    {
        return null;
    }

    return text[start..(end + 1)];
}

Then we try to deserialize it:

private static LlmWikiIngestionPayload? TryParseIngestionPayload(string responseText)
{
    var rawJson = ExtractJsonObject(responseText);
    if (rawJson is null)
    {
        return null;
    }

    try
    {
        return JsonSerializer.Deserialize<LlmWikiIngestionPayload>(rawJson, new JsonSerializerOptions
        {
            PropertyNameCaseInsensitive = true
        });
    }
    catch
    {
        return null;
    }
}

This is a great lesson for readers: LLM output should be handled like user input. Trust it carefully, never blindly.

Step 9: Query the Wiki

Once the wiki exists, we can query it.

The app reads:

SCHEMA.md
Index.md
the latest markdown articles

Then it builds a prompt for the model.

public async Task<string> QueryWikiAsync(string question)
{
    await EnsureWikiStructureAsync();

    var schemaContent = await File.ReadAllTextAsync(_schemaFilePath);
    var indexContent = await File.ReadAllTextAsync(_indexFilePath);
    var articleContext = await BuildArticleContextAsync(maxArticles: 6, maxCharsPerArticle: 2400);

    var queryPrompt = $"""
        You are an AI assistant answering questions from a local markdown wiki.

        Rules:
        - Use only the provided wiki context.
        - If information is insufficient, explicitly say so.
        - Keep response concise.
        - Cite article filenames used as sources.

        Schema:
        ---
        {schemaContent}
        ---

        Index:
        ---
        {indexContent}
        ---

        Article context:
        ---
        {articleContext}
        ---

        Question: {question}
     """;

    var answer = (await GenerateTextAsync(queryPrompt)).Trim();

    if (string.IsNullOrWhiteSpace(answer))
    {
        return "Insufficient information in the wiki context to answer this question.";
    }

    return answer;
}

This is a wiki-style answer flow, not a vector retrieval flow.

Step 10: Wire Everything in Program.cs

The entry point demonstrates the entire POC.

using MyPlaygroundApp.Utils;

class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("Open-Source LLM Wiki Demo (.NET + Ollama)");
        Console.WriteLine("------------------------------------------");
        Console.WriteLine();

        var wikiManager = new LlmWikiManager(modelName: "kimi-k2.6:cloud");
        await wikiManager.EnsureWikiStructureAsync();

        var demoInputDirectory = Path.Combine(AppContext.BaseDirectory, "DemoInput");
        Directory.CreateDirectory(demoInputDirectory);

        var sourceDocumentPath = Path.Combine(demoInputDirectory, "csharp-ai-benefits.txt");
        var sourceDocumentContent = """
            C# is effective for AI solution development due to strong typing, mature tooling, and excellent package management.
            The .NET ecosystem enables production-ready services, background workers, APIs, and cloud integration.
            Developers can integrate local LLMs using Ollama and open-source libraries such as OllamaSharp and Semantic Kernel.
            This approach is useful for private knowledge workflows like a local markdown wiki with ingestion and Q&A.
        """;

        await File.WriteAllTextAsync(sourceDocumentPath, sourceDocumentContent);

        Console.WriteLine("Ingesting source document into local wiki...");
        var ingestionResult = await wikiManager.IngestDocumentAsync(sourceDocumentPath);
        Console.WriteLine($"Article created: {ingestionResult.SummaryFilename}");
        Console.WriteLine($"Wiki location: {wikiManager.WikiDirectory}");
        Console.WriteLine();

        const string question = "What are the benefits of using C# for local LLM wiki development?";
        Console.WriteLine($"Question: {question}");
        var answer = await wikiManager.QueryWikiAsync(question);
        Console.WriteLine();
        Console.WriteLine("Answer:");
        Console.WriteLine(answer);

        Console.WriteLine();
        Console.WriteLine("Demo complete.");
    }
}

This is excellent for a tutorial because readers can run it and immediately see the full loop.

Step 11: Run the Demo

From the solution root, run:

dotnet run --project .\MyPlaygroundApp\MyPlaygroundApp.csproj

If Ollama is available and kimi-k2.6:cloud is usable, the demo should:

create the wiki structure
ingest the sample source document
write a markdown article
update the index
answer a question from the wiki context

Step 12: Show the Generated Wiki Files

These example results are perfect to show your readers.

`Index.md`

# Local Wiki Index

- [C# for AI Development](Articles/csharp-ai-development.md)

`SCHEMA.md`

# LLM Wiki Schema

## Goal
Maintain a local markdown wiki from source documents.

## Ingestion Workflow
1. Read new source document.
2. Summarize key points with technical accuracy.
3. Create or update one markdown article in `Articles/`.
4. Ensure `Index.md` contains one bullet link per article.
5. Keep filenames kebab-case and `.md`.

## Query Workflow
1. Use only article/index content provided as context.
2. Answer concisely and cite article filenames used.
3. If context is insufficient, say information is insufficient.

`csharp-ai-development.md`

# C# for AI Development

C# is a strong choice for building AI solutions, offering robust language features and a mature ecosystem.

## Key Advantages

- **Strong Typing & Tooling**: Static typing reduces runtime errors, while mature IDEs and debugging tools improve developer productivity.
- **Package Management**: NuGet provides reliable dependency management for complex projects.
- **Production-Ready Infrastructure**: The .NET ecosystem supports building scalable services, background workers, APIs, and seamless cloud integration.

## Local LLM Integration

Developers can run local large language models via **Ollama**, using open-source libraries such as:

- **OllamaSharp**: A C# client for interacting with Ollama.
- **Semantic Kernel**: Microsoft's SDK for integrating AI services into applications.

## Use Cases

This stack is particularly effective for **private knowledge workflows**, such as local markdown wikis with document ingestion and question-answering capabilities, ensuring data remains on-premise.

These examples make the demo much more concrete and easier for readers to trust.

Why This POC Is Good

This POC is simple, but it teaches many important engineering ideas:

local model integration in C#
markdown-based AI knowledge design
AI-assisted ingestion workflow
safe structured output parsing
file-based knowledge management
query-time synthesis from curated context

It is a very good educational bridge between:

plain prompt engineering
file-based knowledge systems
and full RAG architectures

Limitations of This POC

Be honest with your readers. This demo is useful, but it is still a demo.

Current limitations:

it is console-based only
article selection is simple and file-based
there is no embedding or semantic ranking layer
article context size is manually bounded
source attribution is prompt-based, not enforced by retrieval metadata
large wiki collections may require a hybrid or full RAG architecture later

That is okay. Simplicity is a feature here.

How to Extend It Later

If your readers want to continue, they can add:

command-line arguments for custom ingestion and queries
ASP.NET Core Minimal API endpoints
Blazor UI for article management
stronger JSON schema validation
better article ranking before query
Semantic Kernel orchestration
hybrid wiki + RAG support
file watchers for automatic wiki refresh

A nice next-step architecture could be:

LLM Wiki for curated stable knowledge
RAG for large and dynamic long-tail knowledge

That gives the best of both worlds.

Conclusion

We built a practical LLM Wiki POC in C# using .NET 8, Ollama, OllamaSharp, markdown files, and the kimi-k2.6:cloud model.

More importantly, we learned a design lesson that is easy to forget in modern AI work:

Not every problem needs RAG first.

Sometimes, the best answer is a clean, curated, lovingly maintained wiki.

If your knowledge is small, stable, and important, a markdown-first LLM Wiki can be wonderfully effective. It is easy to understand, easy to debug, easy to version-control, and easy to teach.

Then, when your world grows larger, you can invite RAG to the party.

Happy coding, and may your markdown always stay tidy.

Love C# & AI!

Starting to Build a One‑Person Company on Azure with OpenClaw (No Code, Just Chat)

David Au Yeung — Fri, 24 Apr 2026 19:35:25 +0000

This is a submission for the OpenClaw Writing Challenge

What I Built

After chatting with a few OpenClaw experts, I learned that most people use OpenClaw primarily for OPC.

That made me realize that this project could be used as a general platform for building AI staffs, not just for that single use case.

So I spun up OpenClaw on an Azure VM and started building.

I built a beta version of an automated daily campaign-letter summarizer on Azure using OpenClaw. Every morning at 9am, my agent scans a folder of campaign letters, summarizes them, and writes a clean daily report.

The most interesting part?

I didn't write any .claw files, YAML, or Python glue code manually.

Instead, I discovered that OpenClaw can create skills and cron tasks directly through conversation, which turned out to be the most reliable way to build automation.

I chose the cloud for the PoC because it avoids running this on my personal computer. After the trial, I can shut down and delete the Azure resources, minimizing ongoing costs and reducing exposure of my data and environment.

This project became my first step toward a "one-person AI company", a system that runs tasks for me automatically, every day.

How I Used OpenClaw

1. Setting Up the Azure VM

I deployed an Ubuntu VM on Azure to host OpenClaw. This gave me a stable, always-on environment for scheduled tasks.

2. Installing WSL + Ubuntu

Inside the VM, I used WSL to create a clean Ubuntu environment. This kept OpenClaw isolated and easy to reset.

wsl --install

3. Installing OpenClaw

I installed OpenClaw using the official script:

curl "fsSL https://get.openclaw.ai/install.sh | bash

Then launched the TUI:

openclaw tui

This dropped me into the interactive agent environment.

(This is a security reminder. You're worth taking the time to read it.)

4. Upgrading Ollama to Cloud Pro

A free Ollama API key caused authentication and provider errors. Switching to Ollama Cloud Pro solved everything instantly.
(so, I paid for a month for this PoC, which was $20 USD (˵ ͡° ͜ʖ ͡°˵))

My agent now runs on:

ollama/kimi-k2.5:cloud

Then in TUI:

/model ollama/kimi-k2.5:cloud

5. Creating the Skill (Just by Asking)

At first, I tried to follow the docs and create skills manually by writing Python files and placing them under:

~/.openclaw/workspaces/main/skills/

Those never loaded properly in my environment.

The real breakthrough came when I stopped fighting the filesystem and simply asked the agent in chat:

"Create the skill that summarizes campaign letters from a folder."

and showed him the example:

from claw import skill
import os

@skill
def summarize_campaign_letters(folder: str = "~/openclaw/campaign_letters"):
    folder = os.path.expanduser(folder)
    summaries = []

    for filename in os.listdir(folder):
        path = os.path.join(folder, filename)
        if not os.path.isfile(path):
            continue

        with open(path, "r", encoding="utf-8") as f:
            content = f.read()

        summary = skill.llm(
            f"Summarize the following campaign letter in 5 bullet points:\n\n{content}"
        )

        summaries.append(f"## {filename}\n{summary}\n")

    if not summaries:
        return "No campaign letters found."

    return "\n".join(summaries)

Then OpenClaw generated the skill, and the /skill command just worked:

/skill summarize_campaign_letters "~/openclaw/campaign_letters"

Under the hood, the Python script that actually runs lives at:

~/.npm-global/lib/node_modules/openclaw/skills/summarize-campaign-letters/scripts/summarize.py

6. Creating the Daily Automation (Cron via Chat)

My agent didn't have a /schedule command, so OpenClaw offered to create a cron job instead.

I simply chatted:

Yes, create one.
Daily summary at 9am
run /skill summarize_campaign_letters

OpenClaw generated the cron entry automatically.

Reminder: Gateway is running but in read-only mode. The cron job needs write capability to create jobs.

Now every morning at 9am (HKT), the agent runs:

/skill summarize_campaign_letters

and writes the output into my reports folder.

Demo

Here's how the system behaves:

I place text files into the ~/openclaw/campaign_letters folder.
At 9am, the cron job runs.
OpenClaw summarizes each letter.
A new campaign-summary.md appears in my reports folder.

This can easily be extended to:

Email delivery
WhatsApp notifications
PDF OCR
Multi-step workflows

But even the basic version already saves me time every morning.

What I Learned

1. Chat-Driven Creation Beats Manual Files

I tried to manually place Python skills under ~/.openclaw/workspaces/main/skills/ and reload them. But the path and startup/loading behavior made it fragile.

When I simply described what I wanted in natural language, and let OpenClaw use its own skill-creation flow, it was:

Faster
Self‑correcting (the agent asks clarifying questions and fixes its own mistakes)
Far more adaptive to rapid changes

2. Cron Is the Real Scheduler in My Setup

In my setup, the agent didn’t have a /schedule command. But it could:

Inspect existing cron jobs
Propose new ones
Write/update them for me

So instead of fighting for a missing command, I let the agent set up cron directly.

3. You Can Build Automation, But Treat AI Output as Untrusted

OpenClaw can create skills for you, and that's powerful, but it also means the system is "close to" something that can hallucinate.

If the AI generates the wrong skill code, wrong paths, or an unsafe workflow, your automation could run the wrong actions automatically (every day), which is exactly the kind of failure that's easy to miss.

So the key lesson is: use AI for building, but verify before trusting.

For example:

Review the created skills/tasks before enabling the automation
Start with a small test dataset and a short run window
Add guardrails (e.g., permissions, allowed folders, simple sanity checks on outputs)
Keep the blast radius small-especially in the first PoC run

That's how you get the speed of AI-driven setup without letting hallucinations silently turn into risk.

Just remember:

ClawCon Michigan

I didn't attend ClawCon Michigan, but I followed the event online and enjoyed seeing how others used OpenClaw creatively. This challenge pushed me to build something practical and automated, and I'm glad I did.

Love AI!

AI, Hope, and Healing: Can We Build Our Own Personalized mRNA Cancer Vaccine Pipeline?

David Au Yeung — Sat, 18 Apr 2026 08:45:49 +0000

Introduction

When people talk about Artificial Intelligence today, the conversation often revolves around chatbots, image generators, or productivity tools. But a recent story caught my attention and made me rethink what AI might mean for the future of medicine.

An Australian tech entrepreneur, Paul Conyngham, used AI tools, including ChatGPT and Google DeepMind's AlphaFold, to explore a personalized mRNA cancer vaccine for his dog Rosie, who had been diagnosed with terminal cancer. Rosie's condition improved, and the story quickly spread across global media.

This case is not a scientific breakthrough, nor is it a reproducible medical treatment. But it symbolizes something important:

AI is lowering the barrier for ordinary people to understand complex biology.

As someone who has lost both my father and sister to cancer, this story hit close to home. It made me wonder - not whether AI can cure cancer today, but whether AI can help us learn, innovate, and accelerate the path toward better treatments tomorrow.

This article explores:

✅ How tumor DNA sequencing leads to mutation discovery
✅ How DNA mutations become protein mutations
✅ Where AlphaFold fits (and where it does not)
✅ How a simplified C# demo can mirror that real biological flow
✅ Why safety, rigor, and validation always matter

Important: This project is for learning and inspiration only. It is not a medical tool and must not be used for diagnosis, treatment, or experimentation.

From Tumor DNA to Vaccine: The Real Scientific Workflow

To understand Rosie’s story, we need to understand how personalized cancer vaccines are actually developed.

Step 1 - Tumor DNA Sequencing

Cancer begins with DNA mutations.

In real oncology workflows:

A tumor biopsy is taken.
Tumor DNA is sequenced.
The patient’s normal DNA is sequenced.
Bioinformatics pipelines compare the two.
Somatic mutations unique to the tumor are identified.

These mutations are changes in the DNA letters:

A, T, C, G

Example DNA change:

Normal:  CGA
Tumor:   CAT

That may change the encoded amino acid.

Step 2 - DNA Mutation → Protein Mutation

DNA encodes proteins using triplet codons.

Each 3‑base codon → 1 amino acid.

Example:

DNA: CGA → Arginine (R)
DNA: CAT → Histidine (H)

Mutation result:

R175H

Meaning:

Original amino acid: R
Position: 175
New amino acid: H

This is called a missense mutation.

These altered proteins may generate neoantigens - small peptides the immune system has never seen before.

That is the foundation of personalized cancer vaccines.

Step 3 - From Mutated Protein to Neoantigen

The immune system does NOT see full proteins.

It sees short fragments:

Usually 8-11 amino acids
Presented by HLA molecules

So the real pipeline becomes:

Tumor DNA → Protein mutation → Mutant peptide → HLA binding prediction → Vaccine candidate

This requires:

Variant calling pipelines
Peptide extraction algorithms
HLA binding prediction models
Immunogenicity scoring
Wet‑lab validation
Clinical trials

AI assists parts of this process.

It does not replace biological validation.

Where AlphaFold Fits, and Where It Does Not

AlphaFold provides precomputed 3D structure predictions for wild‑type proteins.

These models are available through the official AlphaFold Protein Structure Database, jointly operated by Google DeepMind and EMBL‑EBI.

AlphaFold does not:

Identify mutations
Predict immune response
Predict neoantigen binding
Design vaccines
Predict mutated protein structures
Replace clinical validation

However, AlphaFold can help provide structural context:

Is the mutated residue surface‑exposed?
Is it inside a functional domain?
Is it near an active site?

This is context, not immunogenic proof.

How Our Educational C# Demo Mirrors the Real Pipeline

We simulate the workflow safely:

Real World	Demo Equivalent
Tumor sequencing	Synthetic mutation injection
Variant calling	Protein comparison
Missense mutation	Amino acid change string
Neoantigen extraction	9‑mer peptide builder
mRNA construct	Codon assembly

This preserves the shape of the real scientific pipeline without claiming medical validity.

Full Educational C# Example

DNA → Protein → Mutation Detection → Neoantigen → mRNA Construct

This demo:

Fetches a wild-type protein sequence from the AlphaFold API (with a safe fallback sequence if the API is unavailable).
Reverse-translates the protein into a synthetic coding DNA sequence.
Introduces a synthetic tumor-like point mutation in DNA.
Translates mutated DNA back into protein.
Detects amino acid changes (missense-style mutation strings, e.g., A11T).
Extracts 9-mer mutant peptide windows as neoantigen candidates.
Assembles those peptide candidates into a simplified educational mRNA sequence.

The AlphaFold API retrieves precomputed wild‑type models from the official database.

It does not run new structure predictions.

✅Program.cs

using MyPlaygroundApp.Utils;

class Program
{
    static async Task Main(string[] args)
    {
        Console.WriteLine("DNA -> Protein Mutation Detection Demo");
        Console.WriteLine("----------------------------------------");
        Console.WriteLine();

        string accession = "Q5VSL9";

        using var client = new AlphaFoldClient();
        var alphaEntry = await client.GetFirstPredictionAsync(accession);

        if (alphaEntry == null || string.IsNullOrWhiteSpace(alphaEntry.Sequence))
        {
            Console.WriteLine("AlphaFold fetch failed. Using synthetic fallback sequence.");
            alphaEntry = new AlphaFoldPrediction
            {
                Gene = accession,
                Sequence = "MKWVTFISLLFLFSSAYSRGVFRRDAHKSEVAHRFKDLGE"
            };
        }

        Console.WriteLine($"Gene: {alphaEntry.Gene}");
        Console.WriteLine($"Protein Length: {alphaEntry.Sequence.Length}");
        Console.WriteLine();

        string referenceProtein = alphaEntry.Sequence;
        string referenceDna = DnaUtils.ReverseTranslateProtein(referenceProtein);

        Console.WriteLine("Generated dummy coding DNA.");
        Console.WriteLine($"DNA length: {referenceDna.Length}");
        Console.WriteLine();

        string mutatedDna = DnaUtils.IntroducePointMutation(referenceDna, codonIndex: 10);

        Console.WriteLine("Introduced synthetic somatic mutation.");
        Console.WriteLine();

        string mutatedProtein = DnaUtils.TranslateDna(mutatedDna);
        var mutations = MutationDetector.FindMutations(referenceProtein, mutatedProtein);

        var neoantigens = mutations
            .Select((m, index) =>
            {
                var positionDigits = new string(m.Where(char.IsDigit).ToArray());
                var position = int.TryParse(positionDigits, out var parsed) ? parsed : 1;
                var mutationIndex = Math.Max(0, Math.Min(mutatedProtein.Length - 1, position - 1));
                var start = Math.Max(0, mutationIndex - 4);
                var length = Math.Min(9, mutatedProtein.Length - start);
                var peptide = mutatedProtein.Substring(start, length).PadRight(9, 'A');

                return new NeoantigenSummary
                {
                    Rank = index + 1,
                    Gene = alphaEntry.Gene,
                    SourceMutation = m,
                    MutantPeptideSequence = peptide,
                    CompositeScore = 0.9 - (index * 0.05)
                };
            })
            .ToList();

        var codons = new Dictionary<char, string>
        {
            ['A'] = "GCC",
            ['C'] = "UGC",
            ['D'] = "GAC",
            ['E'] = "GAG",
            ['F'] = "UUC",
            ['G'] = "GGC",
            ['H'] = "CAC",
            ['I'] = "AUC",
            ['K'] = "AAG",
            ['L'] = "CUG",
            ['M'] = "AUG",
            ['N'] = "AAC",
            ['P'] = "CCC",
            ['Q'] = "CAG",
            ['R'] = "CGG",
            ['S'] = "AGC",
            ['T'] = "ACC",
            ['V'] = "GUG",
            ['W'] = "UGG",
            ['Y'] = "UAC"
        };

        var mrnaBuilder = new System.Text.StringBuilder();
        foreach (var peptide in neoantigens.Select(n => n.MutantPeptideSequence))
        {
            foreach (var aa in peptide)
            {
                mrnaBuilder.Append(codons.GetValueOrDefault(aa, "NNN"));
            }
        }

        var mrnaSequence = mrnaBuilder.Length > 0 ? mrnaBuilder.ToString() : "AUG";

        Console.WriteLine("Detected Amino Acid Mutations:");
        foreach (var m in mutations)
        {
            Console.WriteLine($" - {m}");
        }

        Console.WriteLine();
        Console.WriteLine("Neoantigens:");
        foreach (var neo in neoantigens)
        {
            Console.WriteLine($" - #{neo.Rank} {neo.MutantPeptideSequence} ({neo.SourceMutation})");
        }

        Console.WriteLine();
        Console.WriteLine($"mRNA Sequence: {mrnaSequence}");

        Console.WriteLine();
        Console.WriteLine("Demo complete.");
    }
}

✅ AlphaFold Client

public sealed class AlphaFoldClient : IDisposable
{
    private readonly HttpClient _http;
    private static readonly Uri PrimaryBaseAddress = new("https://alphafold.com/api/");
    private static readonly Uri SecondaryBaseAddress = new("https://alphafold.ebi.ac.uk/api/");

    public AlphaFoldClient(HttpClient? httpClient = null)
    {
        _http = httpClient ?? new HttpClient
        {
            BaseAddress = PrimaryBaseAddress
        };

        _http.Timeout = TimeSpan.FromSeconds(30);
        _http.DefaultRequestHeaders.Accept.ParseAdd("application/json");
        _http.DefaultRequestHeaders.UserAgent.ParseAdd("Mozilla/5.0 (Windows NT 10.0; Win64; x64) MyPlaygroundApp/1.0");
    }

    public async Task<AlphaFoldPrediction?> GetFirstPredictionAsync(string accession, CancellationToken cancellationToken = default)
    {
        try
        {
            var encodedAccession = Uri.EscapeDataString(accession);
            var list = await TryGetPredictionListAsync(PrimaryBaseAddress, encodedAccession, cancellationToken)
                ?? await TryGetPredictionListAsync(SecondaryBaseAddress, encodedAccession, cancellationToken);

            if (list is null)
            {
                return null;
            }

            return list?.FirstOrDefault();
        }
        catch
        {
            return null;
        }
    }

    private async Task<List<AlphaFoldPrediction>?> TryGetPredictionListAsync(Uri baseAddress, string encodedAccession, CancellationToken cancellationToken)
    {
        try
        {
            _http.BaseAddress = baseAddress;
            using var response = await _http.GetAsync($"prediction/{encodedAccession}", cancellationToken);
            if (!response.IsSuccessStatusCode)
            {
                return null;
            }

            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<List<AlphaFoldPrediction>>(json,
                new JsonSerializerOptions
                {
                    PropertyNameCaseInsensitive = true
                });
        }
        catch
        {
            return null;
        }
    }

    public void Dispose()
    {
        _http.Dispose();
    }
}

public class AlphaFoldPrediction
{
    [JsonPropertyName("sequence")]
    public string Sequence { get; set; } = "";

    [JsonPropertyName("gene")]
    public string Gene { get; set; } = "";
}

✅ DNA Utility (Translation + Mutation)

public static class DnaUtils
{
    // Non-technical explanation:
    // DNA is written with four letters (A, T, C, G). Cells read DNA in groups of 3 letters called "codons".
    // Each codon maps to one protein building block (an amino acid), represented here by a single letter.
    // Example: TTT -> F (Phenylalanine).
    // This table uses the standard genetic code and includes all codons (including stop codons marked as '*').
    private static readonly Dictionary<string, char> CodonTable = new()
    {
        ["TTT"] = 'F', ["TTC"] = 'F', ["TTA"] = 'L', ["TTG"] = 'L',
        ["TCT"] = 'S', ["TCC"] = 'S', ["TCA"] = 'S', ["TCG"] = 'S',
        ["TAT"] = 'Y', ["TAC"] = 'Y', ["TAA"] = '*', ["TAG"] = '*',
        ["TGT"] = 'C', ["TGC"] = 'C', ["TGA"] = '*', ["TGG"] = 'W',

        ["CTT"] = 'L', ["CTC"] = 'L', ["CTA"] = 'L', ["CTG"] = 'L',
        ["CCT"] = 'P', ["CCC"] = 'P', ["CCA"] = 'P', ["CCG"] = 'P',
        ["CAT"] = 'H', ["CAC"] = 'H', ["CAA"] = 'Q', ["CAG"] = 'Q',
        ["CGT"] = 'R', ["CGC"] = 'R', ["CGA"] = 'R', ["CGG"] = 'R',

        ["ATT"] = 'I', ["ATC"] = 'I', ["ATA"] = 'I', ["ATG"] = 'M',
        ["ACT"] = 'T', ["ACC"] = 'T', ["ACA"] = 'T', ["ACG"] = 'T',
        ["AAT"] = 'N', ["AAC"] = 'N', ["AAA"] = 'K', ["AAG"] = 'K',
        ["AGT"] = 'S', ["AGC"] = 'S', ["AGA"] = 'R', ["AGG"] = 'R',

        ["GTT"] = 'V', ["GTC"] = 'V', ["GTA"] = 'V', ["GTG"] = 'V',
        ["GCT"] = 'A', ["GCC"] = 'A', ["GCA"] = 'A', ["GCG"] = 'A',
        ["GAT"] = 'D', ["GAC"] = 'D', ["GAA"] = 'E', ["GAG"] = 'E',
        ["GGT"] = 'G', ["GGC"] = 'G', ["GGA"] = 'G', ["GGG"] = 'G'
    };

    private static readonly Dictionary<char, string> ReverseTable =
        CodonTable.GroupBy(x => x.Value)
                  .ToDictionary(g => g.Key, g => g.First().Key);

    // Reads DNA in 3-base codons and converts each recognized codon into one amino acid.
    public static string TranslateDna(string dna)
    {
        var protein = new List<char>();
        for (int i = 0; i + 2 < dna.Length; i += 3)
        {
            var codon = dna.Substring(i, 3);
            if (CodonTable.TryGetValue(codon, out char aa))
                protein.Add(aa);
        }
        return new string(protein.ToArray());
    }

    // Converts an amino-acid sequence into a synthetic coding DNA string using one representative codon per amino acid.
    public static string ReverseTranslateProtein(string protein)
    {
        return string.Concat(protein.Select(aa =>
            ReverseTable.ContainsKey(aa) ? ReverseTable[aa] : "GCT"));
    }

    // Simulates a single point mutation and prefers a non-synonymous change (amino acid actually changes).
    public static string IntroducePointMutation(string dna, int codonIndex)
    {
        var pos = codonIndex * 3;
        if (pos + 2 >= dna.Length)
        {
            return dna;
        }

        var originalCodon = dna.Substring(pos, 3);
        if (!CodonTable.TryGetValue(originalCodon, out var originalAminoAcid))
        {
            return dna;
        }

        var arr = dna.ToCharArray();
        var bases = new[] { 'A', 'T', 'C', 'G' };

        for (var offset = 0; offset < 3; offset++)
        {
            var index = pos + offset;
            var originalBase = arr[index];

            foreach (var candidateBase in bases)
            {
                if (candidateBase == originalBase)
                {
                    continue;
                }

                arr[index] = candidateBase;
                var mutatedCodon = new string(arr, pos, 3);

                if (!CodonTable.TryGetValue(mutatedCodon, out var mutatedAminoAcid))
                {
                    continue;
                }

                if (mutatedAminoAcid != originalAminoAcid && mutatedAminoAcid != '*')
                {
                    return new string(arr);
                }
            }

            arr[index] = originalBase;
        }

        return dna;
    }
}

✅ Mutation Detector

public static class MutationDetector
{
    public static List<string> FindMutations(string reference, string mutated)
    {
        var mutations = new List<string>();
        int len = Math.Min(reference.Length, mutated.Length);

        for (int i = 0; i < len; i++)
        {
            if (reference[i] != mutated[i])
            {
                mutations.Add($"{reference[i]}{i + 1}{mutated[i]}");
            }
        }

        return mutations;
    }
}

Example Output

This mirrors:

Tumor DNA mutation → missense change → neoantigen candidate → mRNA construct

Safely and conceptually.

Why This Matters

Without explaining the mutation pipeline clearly, people might think:

"AI designs cancer vaccines."

It does not.

The real power lies in combining:

Sequencing
Variant calling
Structural biology
Immunology
AI-assisted analysis
Clinical validation

AI amplifies understanding.

It does not replace medicine.

Conclusion

AI is transforming how we think about biology, not by giving us instant cures, but by giving us tools to understand, explore, and innovate. Stories like Rosie’s remind us that hope often begins with curiosity, and that technology can empower people in ways we never imagined.

But technology alone is not enough. For AI‑enabled healthcare to truly benefit patients, we need thoughtful collaboration between researchers, clinicians, policymakers, and regulatory bodies. That means updating outdated frameworks, supporting responsible innovation, and building pathways that allow safe, evidence‑based personalized medicine to reach the people who need it.

Let's use AI not just to make life easier, but to make life better.

Reference:

unwire.hk: 愛狗患癌工程師搵 AI 幫手 ChatGPT 設計癌症疫苗腫瘤縮 75% 重拾活力
Yahoo Finance: Man's dog was riddled with tumors and dying. He used ChatGPT to design a custom cancer vaccine, stunning researchers
AlphaFold: Programmatic access API endpoints

Love C# & AI & Life!

My 2026 Milestone #1: Achieved Alibaba Cloud Product Capability Certification (AI Stack Delivery Engineer)!

David Au Yeung — Mon, 30 Mar 2026 17:33:42 +0000

On March 5, 2026, I achieved the

Product Capability Certification: Apsara Stack AI Stack Delivery

under Alibaba Cloud.

This certification is currently more recognized within China and the Alibaba Cloud partner ecosystem, so I'd like to share some context for my global followers about what it represents - and why it matters in today's AI infrastructure landscape.

Why Does Alibaba Cloud Offer an On‑Prem AI Solution?

When most people think of Alibaba Cloud, they think of public cloud services - ECS, OSS, databases, and cloud-native platforms.

However, enterprise AI adoption has introduced new requirements:

Large Language Model (LLM) deployment
GPU-intensive workloads
Data sovereignty and regulatory compliance
Low-latency internal AI systems
Fully private AI environments

Many industries - especially finance, government, telecom, and large manufacturing - cannot move sensitive data to public cloud AI services.

To address this, Alibaba Cloud provides AI Stack as part of Apsara Stack, its enterprise-grade on-prem cloud platform.

Think of it as:

Cloud-native AI capability deployed inside your own data center.

What Is AI Stack?

AI Stack is a full-stack private AI infrastructure platform built on Apsara Stack, designed for enterprise environments.

It spans multiple layers of the stack:

1️⃣ Infrastructure Layer (IaaS)

High-performance GPU servers (PCIe / high-density architecture)
Multi-node GPU cluster orchestration
High-speed networking
Storage systems

2️⃣ Platform Layer (PaaS)

Database services (e.g., PolarDB, MySQL)
Middleware and application runtime services
Logging and monitoring services
API gateway and service management
Identity and access control (RBAC)

These PaaS components support:

Model metadata storage
Logging and audit trails
Configuration management
Service orchestration
Enterprise governance

3️⃣ AI Service Layer

Model inference engines
Internal AI service exposure (API-based)
SaaS-style enterprise AI services
MaaS (Model as a Service) enablement

It is not just hardware.

It is not just AI software.

It is an integrated enterprise AI cloud stack running inside a private data center.

Why This Matters in 2026

Today, most AI discussions focus on:

Model size (70B, 200B+)
Benchmarks
Prompt engineering

But what often gets overlooked is the infrastructure layer.

Running large models in production requires:

High-density GPU architecture
High-speed interconnect design
Power and cooling planning
Performance validation
Operational monitoring
SLA-backed maintenance processes

AI innovation is not only about building models -

it's about delivering them reliably at enterprise scale.

This certification focuses on that operational and delivery foundation.

About the Certification

The official certification is:

Product Capability Certification: Apsara Stack AI Stack Delivery

Category: Product Capability Certification

Exam Duration: 90 minutes

Format: 50 questions (single-choice and multiple-choice)

Testing Option: Online, non-proctored

Language: Chinese

Course Duration: 160 minutes (on-demand)

⚠️ Important clarification:

This certification is currently available only to Alibaba Cloud Partners.

It is designed for engineers and service providers responsible for delivering AI-driven solutions on Apsara Stack for enterprise customers.

Course Coverage

The official preparation course covers:

AI Stack Product Overview
AI Stack Architecture and Console Introduction
AI Stack Delivery and Deployment Overview
AI Stack Hardware Maintenance Process

The focus is strongly on delivery execution and operational readiness - not just theoretical architecture diagrams.

What You Should Know Before Taking This Exam

This is not an entry-level certification. It assumes real infrastructure experience.

1️⃣ Cloud & Infrastructure Fundamentals

Compute, storage, networking basics
Virtualization and containerization
IAM and RBAC concepts

2️⃣ GPU & AI Infrastructure Basics

PCIe vs high-density GPU architecture
Importance of inter-GPU bandwidth
Inference vs training fundamentals
Performance factors (precision, concurrency, throughput)

3️⃣ Enterprise AI Delivery Mindset

AI Stack delivery requires understanding:

Site survey and power planning
GPU density and rack design
High-speed networking requirements
Deployment workflows (single-node vs multi-node clusters)
Acceptance testing processes
SLA models (NBD, 7×24×4, etc.)
Structured troubleshooting methodology

It also helps to understand how infrastructure enables:

Private AI platforms
Internal SaaS-style AI services
Enterprise MaaS (Model as a Service)
Hybrid AI architectures

What This Exam Really Tests

This exam emphasizes real-world delivery scenarios, not memorization.

It tests whether you understand:

Architecture trade-offs (cost vs performance vs scalability)
Deployment processes
Failure handling under operational pressure
Enterprise-grade AI operations
Hardware maintenance procedures

In simple terms:

It's not just about running a model.

It's about delivering AI infrastructure as a reliable enterprise system.

Why This Is Relevant Beyond Alibaba Cloud

Even if you are not in the Alibaba Cloud ecosystem, the global trend is clear:

Enterprises increasingly demand private AI capabilities
GPU clusters are becoming core infrastructure
AI infrastructure engineering is emerging as a specialized discipline

Understanding how AI platforms are delivered on-prem broadens your architectural perspective - even if you primarily work with AWS, Azure, or GCP.

Cloud is no longer just public cloud.

Hybrid and private AI infrastructure are becoming strategic enterprise investments.

Where to Learn More

This certification is offered through Alibaba Cloud Academy:

https://www.alibabacloud.com/en/academy/product-capability-certification-ai-stack-delivery

Alibaba Cloud Academy is the official training and certification division of Alibaba Cloud, offering professional certifications, capability certifications, e-learning courses, and hands-on labs.

However, please note again:

This specific certification is currently restricted to Alibaba Cloud Partners.

Reflection

Previously, I achieved the Microsoft Azure Solutions Architect Expert certification, which focuses heavily on cloud architecture design.

This milestone complements that experience by focusing on:

AI infrastructure delivery
Enterprise on-prem cloud platforms
GPU cluster deployment
Operational execution

One validates architecture thinking.

The other validates delivery execution.

Both perspectives are essential in today's AI-driven enterprise environment.

What's Next?

With certifications in both:

Microsoft Azure (cloud architecture)
Alibaba Cloud AI Stack Delivery (enterprise AI infrastructure)

I will continue deepening my focus on:

Enterprise AI architecture
Hybrid AI platform design
Large-scale GPU infrastructure optimization

Excited for what 2026 will bring.

Here's to building not just cloud solutions -

but real AI infrastructure for enterprises.

Love AI!

PostgreSQL SQL Recap: Building Strong Foundational SQL Skills

David Au Yeung — Sat, 07 Feb 2026 07:29:28 +0000

1. Introduction

PostgreSQL (Postgres) is a powerful, open‑source relational database known for its reliability and strong SQL compliance. If you understand how to:

Design tables
Insert and query data
Join tables together
Aggregate and filter results

you already have the tools needed for most production systems.

We'll learn these concepts using:

Customers
Products
Orders
Order items
Promotions

2. Exercise Setup - Core Tables

Customers Table

Stores customer information.

CREATE TABLE Customers (
    CustomerID      BIGSERIAL PRIMARY KEY,
    LastName        VARCHAR(100) NOT NULL,
    FirstName       VARCHAR(100) NOT NULL,
    DOB             DATE NOT NULL,
    IsDeleted       BOOLEAN NOT NULL DEFAULT FALSE,
    CreateBy        VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
    CreateDate      TIMESTAMP NOT NULL DEFAULT NOW(),
    ModifyBy        VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
    ModifyDate      TIMESTAMP NOT NULL DEFAULT NOW(),
    CHECK (EXTRACT(YEAR FROM DOB) >= 1900)
);

Products Table

Stores products available for purchase.

CREATE TABLE Products (
    ProductID         BIGSERIAL PRIMARY KEY,
    ProductName       VARCHAR(1000) NOT NULL,
    ProductCode       VARCHAR(1000) NOT NULL,
    AvailableQuantity INT NOT NULL,
    IsDeleted         BOOLEAN NOT NULL DEFAULT FALSE,
    CreateBy          VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
    CreateDate        TIMESTAMP NOT NULL DEFAULT NOW(),
    ModifyBy          VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
    ModifyDate        TIMESTAMP NOT NULL DEFAULT NOW(),
    CHECK (AvailableQuantity >= 0)
);

Orders Table

Represents a purchase made by a customer.

CREATE TABLE Orders (
    OrderID       BIGSERIAL PRIMARY KEY,
    CustomerID    BIGINT,
    OrderNumber   VARCHAR(1000) NOT NULL,
    OrderDate     TIMESTAMP NOT NULL,
    IsDeleted     BOOLEAN NOT NULL DEFAULT FALSE,
    CreateBy      VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
    CreateDate    TIMESTAMP NOT NULL DEFAULT NOW(),
    ModifyBy      VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
    ModifyDate    TIMESTAMP NOT NULL DEFAULT NOW(),
    FOREIGN KEY (CustomerID) REFERENCES Customers(CustomerID)
);

OrderItems Table

Breaks orders into product line items.

CREATE TABLE OrderItems (
    OrderItemID BIGSERIAL PRIMARY KEY,
    OrderID     BIGINT,
    ProductID   BIGINT,
    Quantity    INT NOT NULL,
    IsDeleted   BOOLEAN NOT NULL DEFAULT FALSE,
    CreateBy    VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
    CreateDate  TIMESTAMP NOT NULL DEFAULT NOW(),
    ModifyBy    VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
    ModifyDate  TIMESTAMP NOT NULL DEFAULT NOW(),
    FOREIGN KEY (OrderID) REFERENCES Orders(OrderID),
    FOREIGN KEY (ProductID) REFERENCES Products(ProductID),
    CHECK (Quantity > 0)
);

3. Promotions Setup

Promotions Table

CREATE TABLE Promotions (
    PromotionID   BIGSERIAL PRIMARY KEY,
    PromotionName VARCHAR(1000),
    PromotionCode VARCHAR(1000),
    ActiveFrom    TIMESTAMP NOT NULL DEFAULT '1900-01-01',
    ActiveTo      TIMESTAMP NOT NULL DEFAULT '2999-12-31',
    IsActive      BOOLEAN NOT NULL DEFAULT TRUE,
    IsDeleted     BOOLEAN NOT NULL DEFAULT FALSE,
    CreateBy      VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
    CreateDate    TIMESTAMP NOT NULL DEFAULT NOW(),
    ModifyBy      VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
    ModifyDate    TIMESTAMP NOT NULL DEFAULT NOW()
);

OrderPromotions Table

(One order can apply multiple promotions)

CREATE TABLE OrderPromotions (
    OrderPromotionID BIGSERIAL PRIMARY KEY,
    OrderID          BIGINT,
    PromotionID      BIGINT,
    IsDeleted        BOOLEAN NOT NULL DEFAULT FALSE,
    CreateBy         VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
    CreateDate       TIMESTAMP NOT NULL DEFAULT NOW(),
    ModifyBy         VARCHAR(100) NOT NULL DEFAULT 'SYSTEM',
    ModifyDate       TIMESTAMP NOT NULL DEFAULT NOW(),
    FOREIGN KEY (OrderID) REFERENCES Orders(OrderID),
    FOREIGN KEY (PromotionID) REFERENCES Promotions(PromotionID)
);

4. Insert Sample Data

Customers

INSERT INTO Customers (LastName, FirstName, DOB) VALUES
('Au Yeung', 'David', '1980-12-31'),
('Chan', 'Peter', '1982-01-15');

Products

INSERT INTO Products (ProductName, ProductCode, AvailableQuantity) VALUES
('Android Phone', 'A0001', 100),
('iPhone', 'I0001', 100),
('iPad', 'I0002', 100);

Orders and Order Items

INSERT INTO Orders (CustomerID, OrderNumber, OrderDate)
VALUES (1, 'ORD0001', NOW());

INSERT INTO OrderItems (OrderID, ProductID, Quantity)
VALUES (1, 2, 10);

INSERT INTO Orders (CustomerID, OrderNumber, OrderDate)
VALUES (2, 'ORD0002', NOW());

INSERT INTO OrderItems (OrderID, ProductID, Quantity)
VALUES (2, 1, 5);

Promotions

INSERT INTO Promotions (PromotionName, PromotionCode, ActiveFrom, ActiveTo) VALUES
('New Year Discount', 'NY2025', '2026-01-01', '2026-01-31'),
('VIP Customer Promo', 'VIP10', '2026-01-01', '2999-12-31');

Order Promotions

INSERT INTO OrderPromotions (OrderID, PromotionID) VALUES
(1, 1),
(1, 2);

INSERT INTO OrderPromotions (OrderID, PromotionID) VALUES
(2, 1);

Inspect the Data

SELECT * FROM Customers;
SELECT * FROM Products;
SELECT * FROM Orders;
SELECT * FROM OrderItems;
SELECT * FROM Promotions;
SELECT * FROM OrderPromotions;

5. Ten Foundational SQL Questions

Which promotions are currently active?
Which promotions have never been used?
How many promotions are applied to each order?
Which orders have more than one promotion?
List all customers and their orders (including customers with none).
What is the total quantity ordered per product?
Which products have never been ordered?
What is the latest order for each customer?
Which orders were created in the last 30 days?
Which promotion is used the most?

6. Answers

1. Active Promotions

SELECT *
FROM Promotions
WHERE IsActive = TRUE
  AND IsDeleted = FALSE
  AND NOW() BETWEEN ActiveFrom AND ActiveTo;

2. Promotions Never Used

SELECT p.*
FROM Promotions p
LEFT JOIN OrderPromotions op
    ON p.PromotionID = op.PromotionID
    AND op.IsDeleted = FALSE
WHERE op.OrderPromotionID IS NULL;

3. Promotion Count per Order

SELECT OrderID, COUNT(*) AS PromotionCount
FROM OrderPromotions
WHERE IsDeleted = FALSE
GROUP BY OrderID;

4. Orders with Multiple Promotions

SELECT OrderID
FROM OrderPromotions
WHERE IsDeleted = FALSE
GROUP BY OrderID
HAVING COUNT(*) > 1;

5. Customers and Their Orders

SELECT c.CustomerID, c.FirstName, c.LastName, o.OrderID, o.OrderDate
FROM Customers c
LEFT JOIN Orders o
    ON c.CustomerID = o.CustomerID
    AND o.IsDeleted = FALSE;

6. Total Quantity per Product

SELECT p.ProductName, SUM(oi.Quantity) AS TotalOrdered
FROM Products p
JOIN OrderItems oi ON p.ProductID = oi.ProductID
WHERE oi.IsDeleted = FALSE
GROUP BY p.ProductName;

7. Products Never Ordered

SELECT p.*
FROM Products p
LEFT JOIN OrderItems oi
    ON p.ProductID = oi.ProductID
    AND oi.IsDeleted = FALSE
WHERE oi.OrderItemID IS NULL;

8. Latest Order per Customer

WITH cte AS (
    SELECT *,
           ROW_NUMBER() OVER (
               PARTITION BY CustomerID
               ORDER BY OrderDate DESC
           ) AS rn
    FROM Orders
    WHERE IsDeleted = FALSE
)
SELECT *
FROM cte
WHERE rn = 1;

9. Orders in the Last 30 Days

SELECT *
FROM Orders
WHERE OrderDate >= NOW() - INTERVAL '30 days'
  AND IsDeleted = FALSE;

10. Most Used Promotion

SELECT p.PromotionName, COUNT(*) AS UsageCount
FROM Promotions p
JOIN OrderPromotions op
    ON p.PromotionID = op.PromotionID
WHERE op.IsDeleted = FALSE
GROUP BY p.PromotionName
ORDER BY UsageCount DESC
LIMIT 1;

7. Conclusion

This PostgreSQL recap covered the most important SQL foundations:

Table design with primary and foreign keys
One‑to‑many and many‑to‑many relationships
JOIN, GROUP BY, and HAVING
Window functions for real business problems
Writing SQL that reflects real‑world questions

If you can comfortably understand and write these queries, you already have strong SQL fundamentals, regardless of database size or system complexity.

Feel free to extend this schema, add more data, or challenge yourself with new questions.

That's how real SQL mastery is built.

Step-by-Step Guide: Build a CRUD Blazor App with Entity Framework and PostgreSQL

David Au Yeung — Tue, 20 Jan 2026 03:05:17 +0000

Introduction

Happy New Year 2026 to all! This year, I want to share more basic must-learn knowledge on .NET. This tutorial is my first sharing on dev.to this year. Happy to see you all again.

Entity Framework (EF) is Microsoft's object-relational mapper (ORM) for .NET. It simplifies data access by allowing you to work with databases using .NET objects, eliminating the need for most data-access code. In this tutorial, we'll build a simple CRUD (Create, Read, Update, Delete) Blazor Server app using EF Core with PostgreSQL. We'll cover setting up the project, defining models, seeding data, and creating a basic UI for managing customers.

By the end, you'll have a functional app demonstrating EF's power for database operations.

Prerequisites

Before we begin, ensure you have the following:

Visual Studio or any C# IDE (e.g., VS Code).
.NET 10 SDK installed (download from Microsoft's site).
PostgreSQL installed and running (download from EnterpriseDB). Set up a database (e.g., "BlazorDemo") and note the connection details.

Step 1: Setting Up the Blazor Project

Create a new Blazor Server app:

dotnet new blazorserver --force

This scaffolds a basic Blazor Server project.

Step 2: Adding Entity Framework Packages

Add the necessary NuGet packages for EF Core and PostgreSQL:

dotnet add package Microsoft.EntityFrameworkCore
dotnet add package Microsoft.EntityFrameworkCore.Tools
dotnet add package Npgsql.EntityFrameworkCore.PostgreSQL

Microsoft.EntityFrameworkCore: Core EF functionality.
Microsoft.EntityFrameworkCore.Tools: For migrations and database commands.
Npgsql.EntityFrameworkCore.PostgreSQL: PostgreSQL provider.

Step 3: Creating Models

Define your data models. Create a Models folder and add classes like Customer.cs:

using System.ComponentModel.DataAnnotations;

namespace BlazorWithEntityFramework.Models
{
    public class Customer
    {
        [Key]
        public long CustomerId { get; set; }

        [Required]
        [StringLength(1000)]
        public string CustomerNumber { get; set; } = string.Empty;

        [Required]
        [StringLength(100)]
        public string LastName { get; set; } = string.Empty;

        [Required]
        [StringLength(100)]
        public string FirstName { get; set; } = string.Empty;

        [Required]
        public DateTime Dob { get; set; }

        public bool IsDeleted { get; set; } = false;

        [StringLength(100)]
        public string CreateBy { get; set; } = "SYSTEM";

        public DateTime CreateDate { get; set; } = DateTime.UtcNow;

        [StringLength(100)]
        public string ModifyBy { get; set; } = "SYSTEM";

        public DateTime ModifyDate { get; set; } = DateTime.UtcNow;
    }
}

Product.cs:

using System.ComponentModel.DataAnnotations;

namespace BlazorWithEntityFramework.Models
{
    public class Product
    {
        [Key]
        public long ProductId { get; set; }

        [Required]
        [StringLength(1000)]
        public string ProductName { get; set; } = string.Empty;

        [Required]
        [StringLength(1000)]
        public string ProductCode { get; set; } = string.Empty;

        [Required]
        [Range(0, int.MaxValue)]
        public int AvailableQuantity { get; set; }

        public bool IsDeleted { get; set; } = false;

        [StringLength(100)]
        public string CreateBy { get; set; } = "SYSTEM";

        public DateTime CreateDate { get; set; } = DateTime.UtcNow;

        [StringLength(100)]
        public string ModifyBy { get; set; } = "SYSTEM";

        public DateTime ModifyDate { get; set; } = DateTime.UtcNow;

        public ICollection<OrderItem> OrderItems { get; set; } = new List<OrderItem>();
    }
}

Order.cs:

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace BlazorWithEntityFramework.Models
{
    public class Order
    {
        [Key]
        public long OrderId { get; set; }

        public long? CustomerId { get; set; }

        [Required]
        [StringLength(1000)]
        public string OrderNumber { get; set; } = string.Empty;

        [Required]
        public DateTime OrderDate { get; set; }

        public bool IsDeleted { get; set; } = false;

        [StringLength(100)]
        public string CreateBy { get; set; } = "SYSTEM";

        public DateTime CreateDate { get; set; } = DateTime.UtcNow;

        [StringLength(100)]
        public string ModifyBy { get; set; } = "SYSTEM";

        public DateTime ModifyDate { get; set; } = DateTime.UtcNow;

        [ForeignKey("CustomerId")]
        public Customer? Customer { get; set; }

        public ICollection<OrderItem> OrderItems { get; set; } = new List<OrderItem>();
    }
}

OrderItem.cs:

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace BlazorWithEntityFramework.Models
{
    public class OrderItem
    {
        [Key]
        public long OrderItemId { get; set; }

        public long? OrderId { get; set; }

        public long? ProductId { get; set; }

        [Required]
        [Range(1, int.MaxValue)]
        public int Quantity { get; set; }

        public bool IsDeleted { get; set; } = false;

        [StringLength(100)]
        public string CreateBy { get; set; } = "SYSTEM";

        public DateTime CreateDate { get; set; } = DateTime.UtcNow;

        [StringLength(100)]
        public string ModifyBy { get; set; } = "SYSTEM";

        public DateTime ModifyDate { get; set; } = DateTime.UtcNow;

        [ForeignKey("OrderId")]
        public Order? Order { get; set; }

        [ForeignKey("ProductId")]
        public Product? Product { get; set; }
    }
}

Step 4: Setting Up the DbContext

Create a Data folder and add AppDbContext.cs:

using Microsoft.EntityFrameworkCore;
using BlazorWithEntityFramework.Models;

namespace BlazorWithEntityFramework.Data
{
    public class AppDbContext : DbContext
    {
        public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }

        public DbSet<Customer> Customers { get; set; }
        public DbSet<Product> Products { get; set; }
        public DbSet<Order> Orders { get; set; }
        public DbSet<OrderItem> OrderItems { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);

            // Seed data
            modelBuilder.Entity<Customer>().HasData(
                new Customer
                {
                    CustomerId = 1,
                    CustomerNumber = "CUST0001",
                    LastName = "Au Yeung",
                    FirstName = "David",
                    Dob = new DateTime(1980, 12, 31, 0, 0, 0, DateTimeKind.Utc),
                    IsDeleted = false,
                    CreateBy = "SYSTEM",
                    CreateDate = DateTime.UtcNow,
                    ModifyBy = "SYSTEM",
                    ModifyDate = DateTime.UtcNow
                },
                new Customer
                {
                    CustomerId = 2,
                    CustomerNumber = "CUST0002",
                    LastName = "Chan",
                    FirstName = "Peter",
                    Dob = new DateTime(1982, 1, 15, 0, 0, 0, DateTimeKind.Utc),
                    IsDeleted = false,
                    CreateBy = "SYSTEM",
                    CreateDate = DateTime.UtcNow,
                    ModifyBy = "SYSTEM",
                    ModifyDate = DateTime.UtcNow
                }
            );

            modelBuilder.Entity<Product>().HasData(
                new Product
                {
                    ProductId = 1,
                    ProductName = "Android Phone",
                    ProductCode = "A0001",
                    AvailableQuantity = 100,
                    IsDeleted = false,
                    CreateBy = "SYSTEM",
                    CreateDate = DateTime.UtcNow,
                    ModifyBy = "SYSTEM",
                    ModifyDate = DateTime.UtcNow
                },
                new Product
                {
                    ProductId = 2,
                    ProductName = "iPhone",
                    ProductCode = "I0001",
                    AvailableQuantity = 100,
                    IsDeleted = false,
                    CreateBy = "SYSTEM",
                    CreateDate = DateTime.UtcNow,
                    ModifyBy = "SYSTEM",
                    ModifyDate = DateTime.UtcNow
                }
            );

            modelBuilder.Entity<Order>().HasData(
                new Order
                {
                    OrderId = 1,
                    CustomerId = 1,
                    OrderNumber = "ORD0001",
                    OrderDate = DateTime.UtcNow,
                    IsDeleted = false,
                    CreateBy = "SYSTEM",
                    CreateDate = DateTime.UtcNow,
                    ModifyBy = "SYSTEM",
                    ModifyDate = DateTime.UtcNow
                }
            );

            modelBuilder.Entity<OrderItem>().HasData(
                new OrderItem
                {
                    OrderItemId = 1,
                    OrderId = 1,
                    ProductId = 2,
                    Quantity = 10,
                    IsDeleted = false,
                    CreateBy = "SYSTEM",
                    CreateDate = DateTime.UtcNow,
                    ModifyBy = "SYSTEM",
                    ModifyDate = DateTime.UtcNow
                }
            );
        }
    }
}

Step 5: Configuring the Connection String

In appsettings.json, add:

{
  "ConnectionStrings": {
    "DefaultConnection": "Host=localhost;Database=BlazorDemo;Username=yourusername;Password=yourpassword"
  }
}

Update Program.cs to register the DbContext:

builder.Services.AddDbContext<AppDbContext>(options => options.UseNpgsql(builder.Configuration.GetConnectionString("DefaultConnection")));

And ensure DB creation:

using (var scope = app.Services.CreateScope())
{
    var db = scope.ServiceProvider.GetRequiredService<AppDbContext>();
    db.Database.EnsureCreated();
}

Step 6: Creating Migrations and Updating the Database

Generate and apply migrations:

dotnet ef migrations add InitialCreate
dotnet ef database update

EnsureCreated() in Program.cs ensures the database is created and seeded on startup. This works alongside migrations for a demo. Note that in production, you might prefer migrations exclusively for better control.

Step 7: Building the CRUD UI

Create a page like Pages/Customers.razor for managing customers:

@page "/customers"
@inject AppDbContext DbContext

<h3>Customers</h3>

@if (customers == null)
{
    <p>Loading...</p>
}
else
{
    <table class="table">
        <thead>
            <tr>
                <th>ID</th>
                <th>Customer Number</th>
                <th>Last Name</th>
                <th>First Name</th>
                <th>DOB</th>
                <th>Actions</th>
            </tr>
        </thead>
        <tbody>
            @foreach (var customer in customers.Where(c => !c.IsDeleted))
            {
                <tr>
                    <td>@customer.CustomerId</td>
                    <td>@customer.CustomerNumber</td>
                    <td>@customer.LastName</td>
                    <td>@customer.FirstName</td>
                    <td>@customer.Dob.ToShortDateString()</td>
                    <td>
                        <button class="btn btn-primary" @onclick="() => EditCustomer(customer)">Edit</button>
                        <button class="btn btn-danger" @onclick="() => DeleteCustomer(customer)">Delete</button>
                    </td>
                </tr>
            }
        </tbody>
    </table>

    <button class="btn btn-success" @onclick="AddCustomer">Add New Customer</button>

    @if (isEditing)
    {
        <div class="modal" style="display:block;">
            <div class="modal-content">
                <h4>@(editingCustomer.CustomerId == 0 ? "Add" : "Edit") Customer</h4>
                <form>
                    <div class="form-group">
                        <label>Customer Number</label>
                        <input type="text" class="form-control" @bind="editingCustomer.CustomerNumber" />
                    </div>
                    <div class="form-group">
                        <label>Last Name</label>
                        <input type="text" class="form-control" @bind="editingCustomer.LastName" />
                    </div>
                    <div class="form-group">
                        <label>First Name</label>
                        <input type="text" class="form-control" @bind="editingCustomer.FirstName" />
                    </div>
                    <div class="form-group">
                        <label>DOB</label>
                        <input type="date" class="form-control" @bind="editingCustomer.Dob" />
                    </div>
                    <button type="button" class="btn btn-primary" @onclick="SaveCustomer">Save</button>
                    <button type="button" class="btn btn-secondary" @onclick="CancelEdit">Cancel</button>
                </form>
            </div>
        </div>
    }
}

@code {
    private List<Customer> customers = new();
    private Customer editingCustomer = new();
    private bool isEditing = false;

    protected override async Task OnInitializedAsync()
    {
        await LoadCustomers();
    }

    private async Task LoadCustomers()
    {
        customers = await DbContext.Customers.AsNoTracking().ToListAsync();
    }

    private void AddCustomer()
    {
        editingCustomer = new Customer { Dob = DateTime.UtcNow };
        isEditing = true;
    }

    private void EditCustomer(Customer customer)
    {
        editingCustomer = new Customer
        {
            CustomerId = customer.CustomerId,
            CustomerNumber = customer.CustomerNumber,
            LastName = customer.LastName,
            FirstName = customer.FirstName,
            Dob = customer.Dob,
            IsDeleted = customer.IsDeleted,
            CreateBy = customer.CreateBy,
            CreateDate = customer.CreateDate,
            ModifyBy = "USER",
            ModifyDate = DateTime.UtcNow
        };
        isEditing = true;
    }

    private async Task SaveCustomer()
    {
        if (editingCustomer.CustomerId == 0)
        {
            DbContext.Customers.Add(editingCustomer);
        }
        else
        {
            var existing = await DbContext.Customers.FindAsync(editingCustomer.CustomerId);
            if (existing != null)
            {
                DbContext.Entry(existing).CurrentValues.SetValues(editingCustomer);
            }
        }
        await DbContext.SaveChangesAsync();
        isEditing = false;
        await LoadCustomers();
    }

    private void CancelEdit()
    {
        isEditing = false;
    }

    private async Task DeleteCustomer(Customer customer)
    {
        var existing = await DbContext.Customers.FindAsync(customer.CustomerId);
        if (existing != null)
        {
            existing.IsDeleted = true;
            existing.ModifyBy = "USER";
            existing.ModifyDate = DateTime.UtcNow;
            DbContext.Customers.Update(existing);
        }
        await DbContext.SaveChangesAsync();
        await LoadCustomers();
    }
}

Add navigation in NavMenu.razor.

Step 8: Running the App

Run the app:

dotnet run

Navigate to /customers to test CRUD operations.

Conclusion

You've built a CRUD Blazor app with EF and PostgreSQL! EF simplifies database interactions, and Blazor provides a seamless UI. Experiment with more entities or features like validation.

Feel free to ask questions or expand on this. Happy coding!

Love C#!

Run SQLite in the Browser with Blazor WebAssembly (WASM) : A Practical Step‑by‑Step Guide

David Au Yeung — Sat, 27 Dec 2025 04:28:11 +0000

Introduction

In this exercise, we'll learn how to run a real SQLite database entirely in the browser using Blazor WebAssembly and sql.js.

No server.

No connection string.

No Docker.

Everything runs inside the user's browser tab, powered by WebAssembly.

We'll build a simple Blazor page that loads the popular Chinook sample database, runs SQL queries client-side, and renders the results in a table.

This approach works great for:

Offline‑first demos and prototypes
Data exploration tools
Training content and workshops
Scenarios where you want "database feel" without any backend

Step 1: Add sql.js to Your Blazor WebAssembly App

First, we need the sql.js library (SQLite compiled to WebAssembly for browsers).

Create a folder under wwwroot:

wwwroot/sqljs/

Download the following files from the official sql.js GitHub releases (or a CDN) and place them in wwwroot/sqljs/:

Your structure should look like:

wwwroot/
  sqljs/
    sql-wasm.js
    sql-wasm.wasm

Step 2: Create a Thin JavaScript Wrapper

Next, we create a small JavaScript interop layer that:

Loads sql-wasm.js and initializes SQL.js
Opens databases from byte arrays
Executes SQL and returns rows as JavaScript objects
Exports and closes databases

Add a new file: wwwroot/sqljs/sqljsInterop.js:

window.sqliteJs = {
  init: async () => {
    try {
      console.log("sqliteJs.init: Starting initialization...");
      if (window.SQL) {
        console.log("sqliteJs.init: Already initialized");
        return true;
      }

      console.log("sqliteJs.init: Loading sql-wasm.js...");
      await new Promise((resolve, reject) => {
        const s = document.createElement("script");
        s.src = "/sqljs/sql-wasm.js";
        s.onload = () => {
          console.log("sqliteJs.init: sql-wasm.js loaded successfully");
          resolve();
        };
        s.onerror = (e) => {
          console.error("sqliteJs.init: Failed to load sql-wasm.js", e);
          reject(e);
        };
        document.head.appendChild(s);
      });

      console.log("sqliteJs.init: Initializing SQL.js...");
      window.SQL = await initSqlJs({
        locateFile: f => {
          console.log("sqliteJs.init: Locating file:", f);
          return "/sqljs/" + f;
        }
      });

      window._dbs = {};
      console.log("sqliteJs.init: Initialization complete");
      return true;
    } catch (error) {
      console.error("sqliteJs.init: Error during initialization", error);
      throw error;
    }
  },

  openDb: (bytes) => {
    try {
      console.log("sqliteJs.openDb: Opening database, bytes:", bytes ? bytes.length : 0);
      const db = bytes ? new SQL.Database(new Uint8Array(bytes))
                       : new SQL.Database();
      const id = crypto.randomUUID();
      window._dbs[id] = db;
      console.log("sqliteJs.openDb: Database opened with ID:", id);
      return id;
    } catch (error) {
      console.error("sqliteJs.openDb: Error opening database", error);
      throw error;
    }
  },

  exec: (id, sql, params) => {
    try {
      console.log("sqliteJs.exec: Executing query", { id, sql, params });
      const db = window._dbs[id];
      if (!db) {
        throw new Error("Database not found: " + id);
      }
      const stmt = db.prepare(sql);
      if (params) stmt.bind(params);
      const rows = [];
      while (stmt.step()) rows.push(stmt.getAsObject());
      stmt.free();
      console.log("sqliteJs.exec: Query returned", rows.length, "rows");
      return rows;
    } catch (error) {
      console.error("sqliteJs.exec: Error executing query", error);
      throw error;
    }
  },

  export: (id) => {
    try {
      console.log("sqliteJs.export: Exporting database", id);
      return window._dbs[id].export();
    } catch (error) {
      console.error("sqliteJs.export: Error exporting database", error);
      throw error;
    }
  },

  close: (id) => {
    try {
      console.log("sqliteJs.close: Closing database", id);
      window._dbs[id].close();
      delete window._dbs[id];
    } catch (error) {
      console.error("sqliteJs.close: Error closing database", error);
      throw error;
    }
  }
};

Step 3: Reference the Interop Script in `index.html`

Blazor WebAssembly apps use wwwroot/index.html as the host page.

Open wwwroot/index.html and add the sql.js interop script before the Blazor script:

<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>WASMDemowithBlazorApp</title>
    <base href="/" />
    <link rel="preload" id="webassembly" />
    <link rel="stylesheet" href="lib/bootstrap/dist/css/bootstrap.min.css" />
    <link rel="stylesheet" href="css/app.css" />
    <link rel="icon" type="image/png" href="favicon.png" />
    <link href="WASMDemowithBlazorApp.styles.css" rel="stylesheet" />
    <script type="importmap"></script>
</head>

<body>
    <div id="app">
        <svg class="loading-progress">
            <circle r="40%" cx="50%" cy="50%" />
            <circle r="40%" cx="50%" cy="50%" />
        </svg>
        <div class="loading-progress-text"></div>
    </div>

    <div id="blazor-error-ui">
        An unhandled error has occurred.
        <a href="." class="reload">Reload</a>
        <span class="dismiss">🗙</span>
    </div>

    <!-- sql.js interop -->
    <script src="/sqljs/sqljsInterop.js"></script>

    <!-- Blazor WebAssembly -->
    <script src="_framework/blazor.webassembly#[.{fingerprint}].js"></script>
</body>

</html>

Step 4: Create a C# `SqlJsService` for JS Interop

Now we wrap the JavaScript API with a clean C# service.

Add a new class: Services/SqlJsService.cs:

using System.Text.Json;
using Microsoft.JSInterop;

namespace WASMDemowithBlazorApp.Services;

public class SqlJsService
{
    private readonly IJSRuntime _js;
    private bool _init;

    public SqlJsService(IJSRuntime js)
    {
        _js = js;
    }

    public async Task InitAsync()
    {
        if (_init)
        {
            return;
        }

        await _js.InvokeVoidAsync("sqliteJs.init");
        _init = true;
    }

    public Task<string> OpenAsync(byte[]? bytes = null)
    {
        return _js.InvokeAsync<string>("sqliteJs.openDb", bytes).AsTask();
    }

    public async Task<List<Dictionary<string, object>>> QueryAsync(
        string id,
        string sql,
        object[]? args = null)
    {
        var raw = await _js.InvokeAsync<object>("sqliteJs.exec", id, sql, args);

        // Convert JS objects -> JSON -> Dictionary<string, object>
        return JsonSerializer.Deserialize<List<Dictionary<string, object>>>(
                   JsonSerializer.Serialize(raw))
               ?? new List<Dictionary<string, object>>();
    }

    public Task<byte[]> ExportAsync(string id)
    {
        return _js.InvokeAsync<byte[]>("sqliteJs.export", id).AsTask();
    }

    public Task CloseAsync(string id)
    {
        return _js.InvokeVoidAsync("sqliteJs.close", id).AsTask();
    }
}

using Microsoft.AspNetCore.Components.Web;
using Microsoft.AspNetCore.Components.WebAssembly.Hosting;
using WASMDemowithBlazorApp;
using WASMDemowithBlazorApp.Services;

var builder = WebAssemblyHostBuilder.CreateDefault(args);
builder.RootComponents.Add<App>("#app");
builder.RootComponents.Add<HeadOutlet>("head::after");

builder.Services.AddScoped(sp => new HttpClient
{
    BaseAddress = new Uri(builder.HostEnvironment.BaseAddress)
});

// Register SQL.js service
builder.Services.AddScoped<SqlJsService>();

await builder.Build().RunAsync();

Step 5: Add the Chinook SQLite Database

We'll use the classic Chinook sample database (music store data).

Create a folder:

wwwroot/
  chinook/
    chinook.sqlite

Download Chinook_Sqlite.sqlite from the Chinook GitHub repo and rename it to chinook.sqlite.
Place it under wwwroot/chinook/chinook.sqlite.

This file will be served as a static asset and loaded into memory by the browser.

Step 6: Build the Blazor Page to Query SQLite

Now we create a Blazor component that:

Loads the database file via HttpClient
Opens it with SqlJsService
Executes a SELECT against the Album table
Renders the first 10 albums

Create Pages/Chinook.razor:

@page "/chinook"
@inject Services.SqlJsService Sql
@inject HttpClient Http
@implements IAsyncDisposable

<PageTitle>Chinook Database</PageTitle>

<h1>Chinook Database Demo</h1>

<p>This page demonstrates client-side SQLite using sql.js in Blazor WebAssembly.</p>

@if (rows == null)
{
    <p><em>Loading database...</em></p>
}
else if (errorMessage != null)
{
    <div class="alert alert-danger" role="alert">
        <strong>Error:</strong> @errorMessage
    </div>
}
else
{
    <h3>Albums (First 10)</h3>
    <table class="table">
        <thead>
            <tr>
                <th>Album ID</th>
                <th>Title</th>
            </tr>
        </thead>
        <tbody>
            @foreach (var r in rows)
            {
                <tr>
                    <td>@r["AlbumId"]</td>
                    <td>@r["Name"]</td>
                </tr>
            }
        </tbody>
    </table>
}

@code {
    string? dbId;
    List<Dictionary<string, object>>? rows;
    string? errorMessage;

    protected override async Task OnInitializedAsync()
    {
        try
        {
            Console.WriteLine("Starting SQL initialization...");
            await Sql.InitAsync();
            Console.WriteLine("SQL initialized successfully");

            Console.WriteLine("Fetching database file...");
            var bytes = await Http.GetByteArrayAsync("chinook/chinook.sqlite");
            Console.WriteLine($"Database loaded: {bytes.Length} bytes");

            Console.WriteLine("Opening database...");
            dbId = await Sql.OpenAsync(bytes);
            Console.WriteLine($"Database opened with ID: {dbId}");

            Console.WriteLine("Executing query...");
            rows = await Sql.QueryAsync(
                dbId,
                "SELECT AlbumId, Title AS Name FROM Album LIMIT 10"
            );
            Console.WriteLine($"Query returned {rows.Count} rows");
        }
        catch (Exception ex)
        {
            errorMessage = $"{ex.GetType().Name}: {ex.Message}";
            Console.WriteLine($"Error: {errorMessage}");
            Console.WriteLine($"Stack trace: {ex.StackTrace}");
        }
    }

    public async ValueTask DisposeAsync()
    {
        if (dbId != null)
        {
            try
            {
                await Sql.CloseAsync(dbId);
            }
            catch
            {
                // Ignore dispose errors
            }
        }
    }
}

Finally, add a nav link (optional, but nice) in Layout/NavMenu.razor:

<div class="nav-item px-3">
    <NavLink class="nav-link" href="chinook">
        <span class="bi bi-database" aria-hidden="true"></span> Chinook DB
    </NavLink>
</div>

Step 7: Run and See the Result

Run the Blazor WebAssembly app:

dotnet run

Navigate to:

https://localhost:xxxx/chinook

You should see:

A loading message
Then a table of the first 10 albums from the Album table rendered directly from SQLite in the browser.

No API controller. No EF Core. Just pure WASM + Blazor + sql.js.

What We Learned (and Things to Be Careful About)

While wiring this up, a few important lessons surfaced:

Static file locks during build
- Visual Studio may complain that chinook.sqlite is in use during build if some process has it open.
- If you see IOException: The process cannot access the file ... chinook.sqlite, close any external tools (SQLite browser, etc.) and stop the running dev server before rebuilding.
SQLite table names are case-sensitive here
- The Chinook schema uses Album, not albums.
- A tiny mismatch like FROM albums results in Error: no such table: albums deep in a JS stack trace.
- When troubleshooting, run a quick SELECT name FROM sqlite_master WHERE type='table'; using a local SQLite client to confirm table names.
Blazor + JSInterop error surfacing
- SQL errors show up first in the browser console (JS), then are re-thrown into .NET as JSException.
- Logging in both C# (Console.WriteLine) and JS (console.log, console.error) makes it much easier to trace problems across the boundary.
Disposal still matters in WebAssembly
- Even though everything is in-memory, it's good practice to implement IAsyncDisposable on your Blazor components and close the in-memory databases when the component is torn down.
- This keeps your in-browser resources tidy, especially if you open multiple databases.
Script load order is important
- sqljsInterop.js must load before Blazor starts calling sqliteJs.init.
- Keep the interop <script> tag before _framework/blazor.webassembly*.js in index.html.

These small details are easy to miss when you're new to mixing Blazor, JS interop, and WebAssembly, but they're exactly what make the experience smooth once you know them.

Summary

In this exercise, we:

Integrated sql.js (SQLite on WebAssembly) into a Blazor WebAssembly app.
Created a JavaScript interop layer to load, open, query, export, and close SQLite databases in the browser.
Wrapped that logic in a C# SqlJsService, exposing a clean async API.
Loaded the Chinook sample database from wwwroot, executed a SQL query against the Album table, and rendered results in a Blazor component.
Learned several practical troubleshooting tips for working with Blazor + WebAssembly + JS interop.

With this foundation, you can:

Build offline data explorers
Ship demo apps that "feel" like full-stack but run entirely in the browser
Prototype data-driven features without standing up real infrastructure

Love C# & Blazor WASM!

Build a Bi‑Directional TOON Parser in C#: Convert TOON JSON with Ease

David Au Yeung — Mon, 08 Dec 2025 08:49:41 +0000

Introduction

Toon (Token-Oriented Object Notation) is a newly promoted format designed specifically for saving LLM tokens.
It is compact, human-readable, extremely lightweight, and optimized for AI workflows where every token counts.

Compared to JSON, TOON reduces noise, avoids unnecessary braces/quotes, and stores structured data in a flat and token-efficient way. With the rise of AI prompting and agent-based architectures, TOON is quickly becoming a favorite among developers and ML engineers.

In this guide, you will learn how to build a complete bi-directional TOON parser in C#:
✔ TOON → JSON
✔ JSON → TOON
✔ Fully automatic, scalable, and easy to extend

This works on .NET 6, .NET 8, and .NET 9, and requires no external dependencies.

Step 1: Create the `ToonConverter` Class

We will build a utility class that contains:

• ParseToon() converts TOON into a C# dictionary
• ToonToJson() converts TOON into JSON
• JsonToToon() converts JSON back into TOON

Create a new file named ToonConverter.cs and insert the following code:

using System.Text.Json;
using System.Text.Json.Nodes;

public static class ToonConverter
{
    // --------------------------------------
    // 1. TOON → OBJECT (Dictionary)
    // --------------------------------------
    public static Dictionary<string, List<Dictionary<string, string>>> ParseToon(string toon)
    {
        var result = new Dictionary<string, List<Dictionary<string, string>>>();
        var lines = toon.Split('\n', StringSplitOptions.RemoveEmptyEntries)
                        .Select(x => x.Trim()).ToList();

        int i = 0;

        while (i < lines.Count)
        {
            if (!lines[i].Contains("{"))
            {
                i++;
                continue;
            }

            string header = lines[i];
            i++;

            string name = header[..header.IndexOf("[")];

            string fieldBlock = header[(header.IndexOf("{") + 1)..header.IndexOf("}")];

            string[] fields = fieldBlock.Split(',')
                                        .Select(f => f.Trim()).ToArray();

            var rows = new List<Dictionary<string, string>>();

            while (i < lines.Count && !lines[i].Contains("{"))
            {
                if (string.IsNullOrWhiteSpace(lines[i]))
                {
                    i++;
                    continue;
                }

                var vals = lines[i].Split(",").Select(v => v.Trim()).ToArray();

                var obj = new Dictionary<string, string>();
                for (int f = 0; f < fields.Length; f++)
                    obj[fields[f]] = vals[f];

                rows.Add(obj);
                i++;
            }

            result[name] = rows;
        }

        return result;
    }

    // --------------------------------------
    // 2. TOON → JSON
    // --------------------------------------
    public static string ToonToJson(string toon)
    {
        var obj = ParseToon(toon);
        return JsonSerializer.Serialize(obj, new JsonSerializerOptions { WriteIndented = true });
    }

    // --------------------------------------
    // 3. JSON → TOON
    // --------------------------------------
    public static string JsonToToon(string json)
    {
        JsonNode root = JsonNode.Parse(json)!;

        var sb = new System.Text.StringBuilder();

        foreach (var block in root.AsObject())
        {
            string name = block.Key;

            if (block.Value is not JsonArray arr)
                continue;

            if (arr.Count == 0)
                continue;

            // Extract fields from first object
            var first = arr[0]!.AsObject();
            var fields = first.Select(x => x.Key).ToList();

            sb.Append($"{name}[{arr.Count}]{{");
            sb.Append(string.Join(",", fields));
            sb.AppendLine("}:");

            // Add rows
            foreach (JsonNode? row in arr)
            {
                var obj = row!.AsObject();
                sb.AppendLine(string.Join(",", fields.Select(f => obj[f]!.ToString())));
            }

            sb.AppendLine();
        }

        return sb.ToString().Trim();
    }
}

Step 2: Try TOON → JSON Conversion

Example TOON format:

Characters[3]{Name,Age,Role}:
Alice,25,Warrior
Bob,30,Mage
Charlie,22,Rogue

Items[2]{ItemName,Quantity,Price}:
Sword,5,100
Potion,20,10

Convert it:

string toonData = @"
 Characters[3]{Name,Age,Role}:
 Alice,25,Warrior
 Bob,30,Mage
 Charlie,22,Rogue

 Items[2]{ItemName,Quantity,Price}:
 Sword,5,100
 Potion,20,10
";

string json = ToonConverter.ToonToJson(toonData);
Console.WriteLine(json);

Output:

Clean, structured, ready for APIs or storage.

Step 3: JSON → TOON Conversion

Given JSON:

{
  "Characters": [
    {
      "Name": "Alice",
      "Age": "25",
      "Role": "Warrior"
    },
    {
      "Name": "Bob",
      "Age": "30",
      "Role": "Mage"
    },
    {
      "Name": "Charlie",
      "Age": "22",
      "Role": "Rogue"
    }
  ],
  "Items": [
    {
      "ItemName": "Sword",
      "Quantity": "5",
      "Price": "100"
    },
    {
      "ItemName": "Potion",
      "Quantity": "20",
      "Price": "10"
    }
  ]
}

Convert it back:

string toonFromJson = ToonConverter.JsonToToon(json);
Console.WriteLine(toonFromJson);

Output:

Perfect round-trip.

Step 4: Integrate Into Your Project

This parser works great for:

• AI agents
• LLM prompt optimization
• Memory-efficient data transfer
• Chat-based structured data
• Internal DSLs
• Config files for AI workflows

Because TOON is extremely tiny, your prompts stay clean and token-friendly.

Summary

In this article, we learned how to:

✔ Create a lightweight bi-directional TOON parser
✔ Convert TOON → JSON
✔ Convert JSON → TOON
✔ Support multi-block, multi-row structured data

TOON is fast becoming the JSON‑alternative for the AI era, and having your own parser gives you maximum flexibility for future workflows.

If you enjoyed this guide, follow me on DEV for more C#, .NET, and AI‑related tutorials.

Love C# & AI!

Will Reasoning Become the New Turing Test? Let's play a Sherlock Holmes game

David Au Yeung — Mon, 17 Nov 2025 16:09:41 +0000

Introduction

I've been thinking about the Turing Test again. The classic experiment where a machine "passes" by imitating human conversation now feels… complete. The game has been played and, in many ways, won.

But that leaves me with a harder question: Does AI really have intelligence?

A few nights ago, I caught a re-broadcast of a Sherlock Holmes-like film Death on the Nile on TV. Watching "Holmes" unravel impossibilities with cool precision, I couldn't help but wonder: What if the next great test for intelligence isn't conversation, but reasoning?

Maybe the mystery case, not the chat window, will define the next Turing Test.

The Turing Test: A Starting Point, Not the Finish Line

In 1950, Alan Turing asked a timeless question: "Can machines think?" His "Imitation Game" proposed a provocative challenge: if a computer could convincingly mimic a human in conversation, it could be considered intelligent.

For decades, that was our benchmark.

But as modern chatbots and large language models have shown, passing for human in conversation is no longer such a remarkable feat. What the Turing Test revealed, in hindsight, is that fluency isn't understanding. It measures surface behavior, not mental depth - speech without comprehension, cleverness without consciousness.

🕵️ Sherlock Holmes and the "New Turing Test"

So what if we moved beyond imitation and into inference?

Imagine a system judged not by its ability to make small talk, but by:

how clearly it explains its reasoning,
how flexibly it revises its conclusions when new evidence appears,
and how carefully it weighs competing hypotheses.

That would be a test not of mimicry, but of coherent thought: a new kind of Turing Test for an age more interested in truth than trickery.

Let's Play an Easy-Level Game: The Moonlit Murder

To explore this idea, I tested an AI with a mystery case.

During the Tang Dynasty, in the great city of Chang'an, a renowned physician named Xu Ren was found dead in his locked study. The door and windows were sealed from the inside - a perfect "locked room" puzzle.

Neighbors heard a single dull thud in the moonlit night… then silence.

Three suspects soon emerged:

🩺 Sun Cheng "The Apprentice"
- Claim: Grinding herbs in the courtyard.
- Motive: Anger - the master planned to pass the clinic to another apprentice.
- Weapon: A heavy wooden pestle.
💔 Lady Lin "The Neighboring Widow"
- Claim: Hanging laundry in her yard.
- Motive: Revenge - she blamed Xu Ren for her husband's death.
- Weapon: A small fruit knife.
🐎 Zhao An "The Guard"
- Claim: On patrol nearby.
- Motive: Resentment - Xu Ren had reported him for bribery.
- Weapon: An iron baton.

Crime Scene:

An overturned cabinet, a shattered porcelain cup, and a pot of still-warm ginseng tea.

Beneath the window lay a set of women's footprints, but oddly large and unnatural.

🧩 Questions:

Who killed Xu Ren?
How was the door locked from inside?
What's with those strange footprints?

🤖 The AI's Deduction

When I presented the mystery to the AI, it approached the case methodically, laying out the physical scene, possible motives, and logical inconsistencies.

It reasoned that the "dull sound" suggested a blunt weapon, that the "female" footprints were likely a disguise, and that a string or hooked rod could have been used to relock the room from outside.

Step by step, it eliminated suspects until one clear picture formed:

Killer: Sun Cheng, the apprentice.

Method: Drugged ginseng tea, fatal strike with a wooden pestle, staged locked room using a string latch trick.

Footprints: Oversized women's shoes faked to implicate Lady Lin.

The conclusion matched the official solution almost perfectly.

🧠 Discovery Through the Game

But what fascinated me most wasn't the AI's answer.

It was my own reaction.

As I reviewed its reasoning, I found myself thinking:

The result is surprising, but the reasoning is more important than getting the answer right.

That thought caught me off guard. Somewhere in the middle of this little Tang Dynasty murder game, I realized the real test wasn't whether the AI could solve the puzzle, it was whether both of us could appreciate the process of reasoning itself.

The Turing Test measures mimicry.

This, however, felt closer to understanding: the deliberate weighing of evidence, the awareness of uncertainty, and the ability to tell a coherent story about why something makes sense.

Conclusion: From Imitation to Understanding

In the end, Sun Cheng turned out to be the killer, but the real insight was something else entirely.

The experiment revealed that reasoning isn't just a mechanical chain of logic; it's a narrative of understanding. When AI can walk that narrative transparently, not just arrive at truth, but show how it gets there: it begins to touch something profoundly human.

Perhaps that's the next frontier.

The new Turing Test may not ask, "Can a machine talk like us?"

but rather, "Can it reason with clarity, humility, and truth - like a good detective under the moon?"

💳 Building a Lightweight PayPal Payment Gateway Service in C#

David Au Yeung — Wed, 12 Nov 2025 13:10:42 +0000

Introduction

Processing online payments is one of the core parts of modern web applications. Whether you're selling subscriptions, digital goods, or services, integrating a secure and reusable payment gateway should be simple and clean.

In this guide, you'll learn how to build a reusable PayPal Payment Service in C#, built for dependency injection, making it easy to plug into your ASP.NET Core apps.

We'll use the PayPal REST API, connecting to the Sandbox environment for safe testing.

Why a Service-Based Architecture?

In production apps, putting payment logic directly into controllers (or Program.cs) quickly becomes messy.

A service-based design makes it easy to:

Inject payment functionality anywhere
Reuse core logic across multiple controllers or jobs
Centralize configuration (e.g., PayPal credentials)
Unit test using mock interfaces

That's what we'll build next: a self-contained, secure IPayPalService implementation.

Prerequisites

You'll need:

A PayPal Developer Account https://developer.paypal.com
A Sandbox App with Client ID and Secret
.NET SDK (6.0 or later)
Newtonsoft.Json package

API Credentials:

Install dependencies:

dotnet add package Newtonsoft.Json

Step 1: Create the PayPal Service Interface

This defines what your service can do, keeping it easy to stub for testing.

public interface IPayPalService
{
    Task<string> CreatePaymentAsync(decimal amount, string currency, string description);
    Task<string> ExecutePaymentAsync(string paymentId, string payerId);
}

Step 2: Implement the PayPal Service

This class handles authentication, payment creation, and execution.

It's structured for reuse and injected HttpClient for proper connection management.

using Microsoft.Extensions.Configuration;
using Newtonsoft.Json;
using System.Net.Http.Headers;
using System.Text;

public class PayPalService : IPayPalService
{
    private readonly HttpClient _client;
    private readonly string _clientId;
    private readonly string _clientSecret;
    private readonly string _baseUrl;

    public PayPalService(HttpClient client, IConfiguration config)
    {
        _client = client;
        _clientId = config["PayPal:ClientId"];
        _clientSecret = config["PayPal:ClientSecret"];
        _baseUrl = config.GetValue<string>("PayPal:BaseUrl") ?? "https://api.sandbox.paypal.com";
    }

    public async Task<string> CreatePaymentAsync(decimal amount, string currency, string description)
    {
        var token = await GetAccessTokenAsync();
        _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

        var payment = new
        {
            intent = "sale",
            payer = new { payment_method = "paypal" },
            transactions = new[]
            {
                new { amount = new { total = amount.ToString("F2"), currency }, description }
            },
            redirect_urls = new
            {
                return_url = "https://example.com/success",
                cancel_url = "https://example.com/cancel"
            }
        };

        var json = JsonConvert.SerializeObject(payment);
        var response = await _client.PostAsync($"{_baseUrl}/v1/payments/payment",
            new StringContent(json, Encoding.UTF8, "application/json"));

        return await response.Content.ReadAsStringAsync();
    }

    public async Task<string> ExecutePaymentAsync(string paymentId, string payerId)
    {
        var token = await GetAccessTokenAsync();
        _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

        var body = new { payer_id = payerId };
        var json = JsonConvert.SerializeObject(body);

        var response = await _client.PostAsync($"{_baseUrl}/v1/payments/payment/{paymentId}/execute",
            new StringContent(json, Encoding.UTF8, "application/json"));

        return await response.Content.ReadAsStringAsync();
    }

    private async Task<string> GetAccessTokenAsync()
    {
        var auth = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{_clientId}:{_clientSecret}"));
        _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", auth);

        var form = new StringContent("grant_type=client_credentials",
            Encoding.UTF8, "application/x-www-form-urlencoded");

        var response = await _client.PostAsync($"{_baseUrl}/v1/oauth2/token", form);
        var content = await response.Content.ReadAsStringAsync();

        if (!response.IsSuccessStatusCode)
            throw new Exception($"Failed to get token: {response.StatusCode} - {content}");

        var token = JsonConvert.DeserializeObject<TokenResponse>(content);
        return token.access_token;
    }

    private class TokenResponse
    {
        public string access_token { get; set; }
        public int expires_in { get; set; }
    }
}

Step 3: Configure the Service in `Program.cs`

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Configuration;

var builder = WebApplication.CreateBuilder(args);

// Add configuration
builder.Configuration.AddJsonFile("appsettings.json");

// Register HttpClient + PayPal service
builder.Services.AddHttpClient<IPayPalService, PayPalService>();

var app = builder.Build();

app.MapGet("/create-payment", async (IPayPalService payPalService) =>
{
    var result = await payPalService.CreatePaymentAsync(25.00m, "USD", "Test Product");
    return Results.Content(result, "application/json");
});

app.Run();

Example `appsettings.json`

{
  "PayPal": {
    "ClientId": "YOUR_PAYPAL_CLIENT_ID",
    "ClientSecret": "YOUR_PAYPAL_SECRET",
    "BaseUrl": "https://api.sandbox.paypal.com"
  }
}

(Better store the credential in environment variables)

Step 4: Try It in Sandbox

1) Run your app:

   dotnet run

2) Visit:

   http://localhost:5000/create-payment

3) You should see a PayPal JSON response similar to this:

{
  "id": "PAYID-NEKHSNA8G910153S62578812",
  "intent": "sale",
  "state": "created",
  "payer": {
    "payment_method": "paypal"
  },
  "transactions": [
    {
      "amount": {
        "total": "25.00",
        "currency": "USD"
      },
      "description": "Test Product",
      "related_resources": []
    }
  ],
  "create_time": "2025-11-12T12:10:28Z",
  "links": [
    {
      "href": "https://api.sandbox.paypal.com/v1/payments/payment/PAYID-NEKHSNA8G910153S62578812",
      "rel": "self",
      "method": "GET"
    },
    {
      "href": "https://www.sandbox.paypal.com/cgi-bin/webscr?cmd=_express-checkout&token=EC-1KS533720P2426713",
      "rel": "approval_url",
      "method": "REDIRECT"
    },
    {
      "href": "https://api.sandbox.paypal.com/v1/payments/payment/PAYID-NEKHSNA8G910153S62578812/execute",
      "rel": "execute",
      "method": "POST"
    }
  ]
}

4) From this response, take note of:

id → The payment ID (PAYID-...) for later execution
approval_url → The URL where you redirect the user to confirm the payment
execute link → Used to finalize (capture) the payment after the user approves it

To test the flow, redirect your user to the approval URL. Once the buyer completes the transaction in the sandbox UI, PayPal will return them to your return_url along with the paymentId and PayerID parameters.

You can then use those values to call your /execute-payment endpoint.

Step 5: (Optional) Execute and Confirm the Payment

Once PayPal redirects users back to your site with a paymentId and PayerId, execute the payment:

app.MapPost("/execute-payment", async (string paymentId, string payerId, IPayPalService payPalService) =>
{
    var result = await payPalService.ExecutePaymentAsync(paymentId, payerId);
    return Results.Content(result, "application/json");
});

Why This Design is Good

Reusable: Inject IPayPalService anywhere: controllers, APIs, or background workers.

Clean Configuration: Credentials and base URL in appsettings.json.

Testable: Mock the interface in unit tests.

Scalable: Add more gateways (Stripe, Razorpay, etc.) behind different service implementations.

This structure follows SOLID and modern ASP.NET Core best practices.

Next Steps

Add webhook handling for automatic payment updates
Support subscriptions or invoicing
Use IOptions<PayPalOptions> for typed configuration
Switch to live mode when ready (`https://api.paypal.com)

Conclusion

By wrapping PayPal's REST API in a C# service with dependency injection, you create a flexible, maintainable payment gateway integration suitable for real-world apps.

This design simplifies future enhancements, improves testability, and allows clean extension to other providers.

Love C#!

Getting Started with Azure Functions: A Beginner's Guide

David Au Yeung — Thu, 06 Nov 2025 02:13:19 +0000

Introduction

Azure Functions is a powerful serverless compute service that allows you to execute event-triggered code without worrying about managing infrastructure. It's ideal for lightweight tasks, automation workflows, or building application components that are triggered on demand.

In this article, we will walk through creating your first Azure Function using an HTTP trigger written in C#. You'll also learn how to run the function locally, deploy it to Azure, and explore other trigger types to unlock the full potential of Azure Functions.

Example: Azure Function with HTTP Trigger (C#)

Goal

The goal is to create an Azure Function that responds to an HTTP request with a personalized message.

Prerequisites

Before you get started, ensure you have the following:

1) Azure account (sign up for a free trial on the Azure Portal if needed).
2) Azure Functions Core Tools (a CLI for local development).

To install Azure Functions Core Tools:

npm install -g azure-functions-core-tools@4 --unsafe-perm true

3) Visual Studio Code or Visual Studio (optional, for code editing).
4) .NET SDK (required for C# development).

Step 1: Create a Function Project

1) Open your terminal and initialize a new Azure Functions project:

   func init MyHttpFunction --dotnet

This creates a new project folder called MyHttpFunction.

2) Add a new HTTP-triggered function:

   cd MyHttpFunction
   func new --name HttpExample --template "Http trigger"

When prompted, set the Authorization level to Anonymous for testing purposes.

Step 2: Code Your Function

Open the file HttpExample.cs in the MyHttpFunction folder. You'll see the following code:

using System.IO;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;

namespace MyHttpFunction
{
    public static class HttpExample
    {
        [FunctionName("HttpExample")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req,
            ILogger log)
        {
            log.LogInformation("C# HTTP trigger function processed a request.");

            string name = req.Query["name"];

            string responseMessage = string.IsNullOrEmpty(name)
                ? "This HTTP triggered function executed successfully. Pass a name in the query string or in the request body for a personalized response."
                : $"Hello, {name}. This HTTP triggered function executed successfully.";

            return new OkObjectResult(responseMessage);
        }
    }
}

Key Features of This Function:

Accepts HTTP GET or POST requests.
Looks for a query parameter named name.
Returns a greeting message based on the input.

Step 3: Run Locally

To test your function locally:

1) Start the Azure Functions runtime:

   func start

You'll see output similar to:

  Functions:
           HttpExample: [GET,POST] http://localhost:7071/api/HttpExample
   For detailed output, run func with --verbose flag.

2) Open a browser or use a tool like Postman or curl to test the function:

   curl "http://localhost:7071/api/HttpExample?name=DEVTo"

The response will be:

   Hello, DEVTo. This HTTP triggered function executed successfully.

Step 4.1: Deploy to Azure (Optional 1: Azure CLI)

To install Azure CLI:

Invoke-WebRequest -Uri https://aka.ms/installazurecliwindows -OutFile .\AzureCLI.msi
Start-Process msiexec.exe -Wait -ArgumentList "/I AzureCLI.msi /quiet"
Remove-Item .\AzureCLI.msi

or download here

1) Log in to Azure CLI:

   az login

2) Create a resource group:

   az group create --name Testing1 --location canadacentral

3) Create a Function App in Azure:

   az functionapp create \
     --resource-group Testing1 \
     --consumption-plan-location canadacentral \
     --runtime dotnet \
     --functions-version 4 \
     --name MyHttpFunction \
     --storage-account <your-azure-storage-account-name>

Tip: You can create a storage account using az storage account create if needed.

4) Deploy your function to Azure:

   func azure functionapp publish MyHttpFunction

After deployment, you'll get a URL like:

   https://myhttpfunction-dcgnazf2faa6back.canadacentral-01.azurewebsites.net/api/HttpExample?code=<FUNCTION_KEY>

Test it with:

   curl "https://myhttpfunction-dcgnazf2faa6back.canadacentral-01.azurewebsites.net/api/HttpExample?name=DEVTo&code=<FUNCTION_KEY>"

Step 4.2: Deploy to Azure (Optional 1: Azure Portal)

1) Go to Azure Portal.
2) Search for Function App and create one.

3) Navigate to the new create function MyHttpFunction.

3) Go to the Configuration and set SCM Basic Auth Publishing Credentials "ON".

4) Go back to Overview and click "Get publish profile" to download profile.

5) Publish your app via Visual Studio by "Import Profile".

6) Click "Publish".

7) You could find your site in profile, and test it with your app keys.

(⚠️⚠️⚠️ DON'T show your keys to others ⚠️⚠️⚠️)

Optional: Use a Timer Trigger

Want to schedule your function to run periodically? Use a Timer Trigger:

1) Create a new Timer-triggered function:

   func new --name TimerExample --template "Timer trigger"

2) Modify the TimerExample.cs file:

   [FunctionName("TimerExample")]
   public static void Run([TimerTrigger("0 */5 * * * *")] TimerInfo myTimer, ILogger log)
   {
       log.LogInformation($"C# Timer trigger function executed at: {DateTime.Now}");
   }

This function runs every 5 minutes based on the provided CRON expression.

Other Common Triggers

Azure Functions supports a variety of triggers beyond HTTP and Timer. Some examples include:

Trigger Type	Description
HTTP Trigger	Respond to web requests.
Timer Trigger	Run on a schedule.
Blob Trigger	Execute when a blob is uploaded to Azure Storage.
Queue Trigger	Process messages in a queue.
Event Hub Trigger	Respond to events published to an Event Hub.

Want More Use Cases?

Here are some advanced use cases to explore:

A Queue-triggered function to process queued messages.
A Blob-triggered function to analyze uploaded files.
A Durable Function for orchestrating long-running workflows.
A Query function to interact with a database or external APIs.

Conclusion

Azure Functions provides a flexible, scalable, and cost-efficient way to build event-driven applications. Whether responding to HTTP requests, processing storage events, or running scheduled tasks, Azure Functions can handle it all with ease.

Now that you've built and deployed your first Azure Function, explore the many possibilities it offers to take your applications to the next level!

References

Love C# & Azure