Congrats to the team to provide the new Gemma 3 models and the new endpoint on the Google AI API. The announcement blog - https://blog.google/technology/developers/gemma-3/ - reads wonderfully. Until someone puts it to the test...

Create AI with advanced text and visual reasoning capabilities

Easily build applications that analyze images, text, and short videos, opening up new possibilities for interactive and intelligent applications

HTTP 400: "Image input modality is not enabled for models/gemma-3-27b-it"
HTTP 400: "Audio input modality is not enabled for models/gemma-3-27b-it"

Tried different images (png, jpg, bmp), video (mp4) and PDF documents - both via inlineData and per File API using fileData attributes.

Create AI-driven workflows using function calling

Gemma 3 supports function calling and structured output to help you automate tasks and build agentic experiences.

HTTP 400: "Function calling is not enabled for models/gemma-3-27b-it"
HTTP 400: "Json mode is not enabled for models/gemma-3-27b-it"
HTTP 400: "Enum mode is not enabled for models/gemma-3-27b-it"

System Instruction

HTTP 400: "Developer instruction is not enabled for models/gemma-3-27b-it"

Code execution?

It's not explicitly mentioned in the blog. What's the situation here? Right now...

HTTP 400: "Code execution is not enabled for models/gemma-3-27b-it"

Candidate count > 1?

It's not explicitly mentioned in the blog. What's the situation here? Right now...

HTTP: "Multiple candidates is not enabled for models/gemma-3-27b-it"

Not sure what's the issue is...

However, with the announcement blog I would kind of expect that the mentioned features are available and operational from day 0 on. And not hoping for the best and then those are being added at a later stage.

I'm not sure whether those features have been disabled for the gemma3 model in the Gemini API and the model itself might be capable to deal with everything, like when used locally or deployed in Vertex AI or Cloud Run with GPU...

What are your observations?

Recently, while developing some changes in the Gemini SDK for .NET and given a reported issue on GitHub I had a look at the possibilities of passing an object as the expected structured output in JSON format in order to get the response from the Gemini API.

Turns out it's not trivial and there are several options available, each with of their own obstacles. Let's have a look...

JSON schema exporter in .NET 9

First, I came across a new feature in .NET 9 - JSON schema exporter.

The JsonSchemaExporter class, introduced in .NET 9, lets you extract JSON schema documents from .NET types using either a JsonSerializerOptions or JsonTypeInfo instance. The resultant schema provides a specification of the JSON serialization contract for the .NET type. The schema describes the shape of what would be serialized and what can be deserialized.

Although interesting, it's too new and the Gemini SDK for .NET needs support for previous versions of .NET including .NET Framework. So, not an option yet.

NJsonSchema by Rico Suter

Next, I found the NJsonSchema library and gave it a try. The library is well written and actively maintained. Also, the package supports .NET Framework 4.6.2 or higher, .NET Standard 2.0, and .NET 6.0 or higher. Sounds like the perfect candidate to integrate into my SDK.

However, I noticed that there are slight differences between the available documentation and the latest version 11.x of the NuGet package. Using the previous, latest version 10.x of the package solved that.

Unfortunately, I ran into the problem described below regarding the generation of `type` keys as arrays of principle types, and I couldn't find a solution to output a single string value (as expected by the Gemini API).

The latest version seems to migrate from `Newtonsoft.Json` to `System.Text.Json` but that process has not been completed yet. Throughout the Gemini SDK for .NET I'm using `System.Text.Json` everywhere as much as possible. I think the test projects still use `Newtonsoft.Json`indirectly somehow. Anyway, I didn't like adding another JSON library to the SDK and I couldn't resolve the described issue with the `type` array, so not an option.

json-everything by Greg Dennis

Lastly, I came across the json-everything library which generated the JSON schema as expected by the Gemini API. The NuGet package is compatible with .NET Standard 2.0 (which works for .NET Framework 4.7.1 or higher, IIRC) as well as .NET 8.0 or higher. As I ditched support for .NET 6.0 recently in the SDK it's a match.

Serialization of .NET types to JSON and JSON

Yes, you read this correctly. Most commonly the Gemini SDK for .NET has to serialize the payload for the REST API endpoint requests. That's regular stuff and nothing special about it using `System.Text.Json`.

/// <summary>
/// Return serialized JSON string of request payload.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
protected string Serialize<T>(T request)
{
	return JsonSerializer.Serialize(request, _options);
}

However, to generate a structured output one has to provide a JSON Schema describing the object used for the response. JSON schema uses a defined syntax to describe objects which is different from a regular object serialization. Hence the need to integrate one of the previously mentioned libraries in order to be generate a JSON schema based on a .NET type.

One of the solutions is to implement a specialized JSON converter and attribute the property to use it. Here's how it's done in the SDK.

/// <summary>
/// Optional. Output response schema of the generated candidate text when response mime type can have schema.
/// </summary>
/// <remarks>
/// Schema can be objects, primitives or arrays and is a subset of [OpenAPI schema](https://spec.openapis.org/oas/v3.0.3#schema).
/// If set, a compatible response_mime_type must also be set. Compatible mimetypes: `application/json`: Schema for JSON response.
/// </remarks>
[JsonConverter(typeof(ResponseSchemaJsonConverter))]
public object? ResponseSchema { get; set; }

A custom converter needs to overwrite two methods - Read and Write. See further details about How to write custom converters for JSON serialization (marshalling) in .NET. Here's the current implementation (kindly ignore Read as its not used).

#if NET472_OR_GREATER || NETSTANDARD2_0
using System;
using System.Text.Json;
using System.Text.Json.Serialization;
#endif
using Json.Schema;
using Json.Schema.Generation;

namespace Mscc.GenerativeAI
{
    /// <summary>
    /// Custom JSON converter to serialize and deserialize JSON schema.
    /// </summary>
    public sealed class ResponseSchemaJsonConverter : JsonConverter<object>
    {
        /// <inheritdoc cref="JsonConverter"/>
        public override object? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
        {
            return JsonSerializer.Deserialize<dynamic>(reader.GetString()!, options);
        }

        /// <inheritdoc cref="JsonConverter"/>
        public override void Write(
            Utf8JsonWriter writer,
            object value,
            JsonSerializerOptions options)
        {
            var type = value.GetType();
            // How to figure out: type vs anonymous vs dynamic?
            if (type.Name.Substring(0,Math.Min(type.Name.Length, 20)).Contains("AnonymousType"))
            {
                var newOptions = new JsonSerializerOptions(options);
                newOptions.Converters.Remove(this);
                JsonSerializer.Serialize(writer, value, value.GetType(), newOptions);
            }
            else
            {
                var config = new SchemaGeneratorConfiguration()
                {
                    PropertyNameResolver = PropertyNameResolvers.CamelCase
                };
                var schemaBuilder = new JsonSchemaBuilder();
                var schema = schemaBuilder.FromType(type, config).Build();
                JsonSerializer.Serialize(writer, schema, schema.GetType(), options);
            }
        }
    }
}

As you see, there's still of room to improve the implementation. For once, I'm struggling with the serialization of types from the `System.Dynamic` namespace, eg. ExpandoObject. Why? Because this generates (again) additional JSON keys like `readOnly` which are rejected. Right now, it's not clear to me whether it's a specs problem against JSON Schema or an incompatibility on the side of the Gemini API.

Note: The boolean keywords `readOnly`and `writeOnly` are part of the JSON Schema Annotations and have been added in draft 7.

Feel free to drop a note or hint in the article comments below. Or create a PR in the repository on GitHub.

Following is the post I published on the Build with Google AI Forum:

Incompatibility issue in the Gemini API regarding JSON Schema

I'm facing an issue regarding the generation of JSON Schema used as value of GenerationConfig.ResponseSchema given the following scenario. The class is defined like this

class Recipe {
    public string Name { get; set; }
}

Which is then passed into the property as a list / array in order to retrieve multiple suggestions from the Gemini API.

var generationConfig = new GenerationConfig()
{
    ResponseMimeType = "application/json",
    ResponseSchema = new List<Recipe>()
};

The generated output looks like this

{
  "model" : "models/gemini-1.5-pro-latest",
  "contents" : [ {
    "role" : "user",
    "parts" : [ {
      "text" : "List a few popular cookie recipes."
    } ]
  } ],
  "generationConfig" : {
    "responseMimeType" : "application/json",
    "responseSchema" : {
      "type" : "array",
      "items" : {
        "type" : "object",
        "properties" : {
          "name" : {
            "type" : [ "string", "null" ]
          }
        },
        "required" : [ "name" ]
      }
    }
  }
}

Specifying the property Name as a nullable string. This is conform with the specs of type according to https://json-schema.org/understanding-json-schema/reference/type allowing  instances that can be of multiple primitive types.

The type keyword may either be a string or an array:
**     If it's a string, it is the name of one of the basic types above.*
**     If it is an array, it must be an array of strings, where each string is the name of one of the basic types, and each element is unique. In this case, the JSON snippet is valid if it matches any of the given types.*

See also https://json-schema.org/draft/2020-12/json-schema-core#section-7.6.1 and following paragraphs.

Currently, the Gemini API returns an HTTP 400 Bad Request with this information.

{
  "error": {
    "code": 400,
    "message": "Invalid JSON payload received. Unknown name \"type\" at 'generation_config.response_schema.items.properties[0].value': Proto field is not repeating, cannot start list.\nInvalid JSON payload received. Unknown name \"type\" at 'generation_config.response_schema.items.properties[1].value': Proto field is not repeating, cannot start list.",
    "status": "INVALID_ARGUMENT",
    "details": [
      {
        "@type": "type.googleapis.com/google.rpc.BadRequest",
        "fieldViolations": [
          {
            "field": "generation_config.response_schema.items.properties[0].value",
            "description": "Invalid JSON payload received. Unknown name \"type\" at 'generation_config.response_schema.items.properties[0].value': Proto field is not repeating, cannot start list."
          },
          {
            "field": "generation_config.response_schema.items.properties[1].value",
            "description": "Invalid JSON payload received. Unknown name \"type\" at 'generation_config.response_schema.items.properties[1].value': Proto field is not repeating, cannot start list."
          }
        ]
      }
    ]
  }
}

The error message essentially showing "type": Proto field is not repeating, cannot start list.

And therefor indicating that the value of type cannot be a list/array of primitives types.

Adding to this observation on the API side, using the same response schema in AIS gives me the following error message on Save.

Sorry to say but this seems to be a short-coming on Gemini's side regarding the interpretation of JSON Schema specifications.

Similarly, I'm getting HTTP 400 Bad Request responses when other keys, like eg. "readOnly" and others are used in the schema definition.

This doesn't align with the specs of JSON Schema.

Changing the type value to a single primitive type returns an HTTP 200 OK.

{
  "model" : "models/gemini-1.5-pro-latest",
  "contents" : [ {
    "role" : "user",
    "parts" : [ {
      "text" : "List a few popular cookie recipes."
    } ]
  } ],
  "generationConfig" : {
    "responseMimeType" : "application/json",
    "responseSchema" : {
      "type" : "array",
      "items" : {
        "type" : "object",
        "properties" : {
          "name" : {
            "type" : "string"
          }
        }
      }
    }
  }
}

and the result as expected.

{
  "candidates" : [ {
    "content" : {
      "parts" : [ {
        "text" : "[{\"name\": \"Chocolate Chip Cookies\"}, {\"name\": \"Peanut Butter Cookies\"}, {\"name\": \"Oatmeal Raisin Cookies\"}, {\"name\": \"Snickerdoodles\"}, {\"name\": \"Shortbread Cookies\"}]"
      } ],
      "role" : "model"
    },
    "finishReason" : "STOP",
    "avgLogprobs" : -0.009499770402908326
  } ],
  "usageMetadata" : {
    "promptTokenCount" : 8,
    "candidatesTokenCount" : 45,
    "totalTokenCount" : 53
  },
  "modelVersion" : "gemini-1.5-pro-002"
}

Someone else observing this issue?
Right now, this seems to be an issue with the Gemini API not accepting a conforming JSON Schema with multiple primitive types as the type definition of a property.

Assistance please. Thanks.

Recently I have been watching the travel documentary "James May, our man in India". One of the episodes, in particular #2, while he is visiting Delhi and Agra, it hit a chord in my memories. Time to write about my trip to India and speaking at the C# Corner Annual Conference 2017.

C# Corner Annual Conference 2017, Delhi
(the link might probably not work anymore)

It all started during 2016 when the founder of C# Corner Mahesh Chand invited me to come to and speak at the conference in 2016 already. Unfortunately, it was a quite short-noticed call and I had bookings for business scheduled already. Then, about the end of December fellow MVP and MSCC community member Chervine Bhiwoo sent me an email to check my Inbox for a potential speaking engagement with C# Corner Conference 2017. And indeed in early January Praveen Kumar and I had some conversation about potential submissions. We quickly agreed on the title of the talk and the rest was all about travel preparations.

Travelling to India

Whether you are Mauritian or not like in my case, India seems to ask quite a number of citizens to apply for a VISA to enter the country. The application process can be initiated online easily. For the actual VISA I went to the High Commission in Port Louis to pay the fees, drop off my passport and collect it after a week or so. The officer at the High Commission was very forth coming and friendly. Overall a pleasant experience to obtain a VISA for India.

Note: The fees for a VISA depend on your citizenship; Mauritians pay less than what I paid for.

For the arrangements for air travel there are multiple options available. Among them are flights on Air Mauritius, Air India, Emirates and others. I do not recall whether there is a direct flight between Delhi and Mauritius though. Probably yes but limited to certain days of the week only. Given the marginal difference in total travel time inclusive stop-over and the comfort offered by the airline, I booked my trip on Emirates with the usual short stop in Dubai. Otherwise, it would have been a stop-over in Chennai or Bangalore.

With the additional flexibility of multiple flights per day I opted for Emirates, again. And I even got a nice deal to upgrade to Business Class.

First impressions

After two unspectacular flights I arrived safely in Delhi during the afternoon. And thanks to the organised airport transfer it was a breeze to experience the traffic first-hand. Whew, I mean driving in Mauritius can be an adventure sometimes in certain areas but this topped everything. It is scary and fascinating at the same time, not sure whether I can describe it using words only. A three-lane road has five to six vehicles of any kind next to each other, ranging from bicycles to auto-rickshaw - aka tuk tuk) to busses and heavyload lorries. And everyone is honking.

Thankfully Manish is used to all of this and we arrived at the hotel in adequate time just to discover another novelty for me. The hotel, or more likely any hotel, seems to be a miniature fortress I got the impression. Heavy fencing around the property, armed units with machine guns slung over their shoulder, car inspection with mirrors to check for explosives, X-ray security scanners for your luggage, and metal detectors for people. Never seen this before...

Anyway, there was a heartwarming reception procedure while waiting for the check-in process to be completed. A bit exhausted I happily reached the hotel room to stretch out and relax a bit. My community fellow and room-mate Chervine arrived a day earlier.

Later this evening, we met with Dhananjay (DJ) Kumar and we talked a bit about Mauritius, India, developer communities in general, and all kind of other interesting topics. Totally unexpected and surprising, DJ gifted me the book "The power of habit" by Charles Duhigg. Very much appreciated.

After a wonderful speakers dinner organised by C# Corner it was time to call it a day as there had been plans made for us the next day. This meant to catch some Zzzz's and then wake up earlier than usual.

Road trip to Mathura

Guess what? It's Uber time! First time, riding on an Uber... It was booked by our hosts in order to meet other speakers for today's trip to Mathura. Speaking in front of CS students at one of the local universities. Initially the Uber trip started quite good, the driver came to the hotel in time and we were off for a quick 30 minutes drive to join the others. And then he fell asleep on the wheel...

After the second time grazing the wall in the middle of the highway, the traffic separation, we all urged the driver to stop the car instantly and we hauled another Uber to continue the trip safely. With quite some delay we met with a fellow from C# Corner and we were finally off to Mathura.

Interestingly, the Yamuna Expressway passes along the Buddh International Circuit where the Indian Grand Prix in Formula One used to be. A track dominated by Sebastian Vettel during its short period on the F1 calendar. For the final stretch from the expressway to Mathura we drove on regular roads. We even had to take a diversion through the fields to reach the GLA University in Mathura.

Joining the other speakers and checking out the agenda of the day there was little perparations for my talk on "Advantages and Opportunities of Cross-Platform Development". During my session I explained to the students present the different options and tools available to dive into cross-platform development. Afterwards, there had been quite a number of questions regarding Cordova, Xamarin and Electron which I gladly answered to my best knowledge. I wasn't aware about certain customs, the whole at the university we have been treated with utterly importance. I felt as some kind of celebrity; just showing up and taking the stage to talk. Positive although unusual impressions.

The trip back to Delhi got us into a bit of rush hour. I mean, it's not like there's no traffic all day long but around early evening it seems to intensify by a magnitude or two. Mind-boggling driving experience! Compared to that, driving in Mauritius is like secured road education for young learners at kindergarten. And I figured that the constant honking is just a way to say 'Hello, I'm doing great and I'm an active participant on the road'. Nothing special about that.

We rounded up the day with a speakers dinner back at the hotel. Some of the seasoned speakers shared their experience on delivering a great talk and offered their valuable advice to others. Again, it was a very pleasant activity and well received.

The conference

Despite my session being scheduled during the early afternoon, I woke up quite early to seize the opportunity to explore the conference venue. There were multiple rooms for the tracks and a large exhibition area for vendors and partners of the event. Big style stuff and very much like any of the European conferences I attended in the past. The registration desks were already buzzing with people. Everyone being really excited about the big day.

As mentioned, there were multiple tracks in parallel and my session had been assigned to Track 1 which was occupying the main hall with the largest amount of seats. Whew, no pressure ;-)

Throughout the day it became appeared that we experienced an increasing delay regarding the starting times of the sessions. Well, nothing to worry about in India, and I have to admit that I was glad for some extra time to prepare myself for the talk. Quick hardware check and also verifying that all code samples and demos were working as expected and I was ready to rumble. It didn't go as smoothly as I hoped for but I had some source code to show on how to develop .NET Core applications on Linux. Back in the days I used Visual Studio Code and the `dotnet` CLI to convey the message to the audience.

Afterwards, I had some great conversation with Joseph Guadagno about the Microsoft MVP program in general, and we cross-checked our list of MVP contacts. It was pretty amusing to exchange stories regarding some of the folks we both know. Later on, I chit-chatted a bit with Magnus Mårtensson, David McCarter, Pinal Dave, and a couple more speakers about their activities related to .NET, SQL Server and of course the C# Corner community. The had been numerous nuggets of great advice for growing our community in Mauritius and I got some ideas for the annual Developers Conference in Mauritius, too.

Later that evening, all speakers and helpers of the conference were invited for a treat: Speakers dinner at a rooftop club in one of the suburbs of Delhi. Great fun I can tell you. And very interesting conversations, lots of jokes and laughter, and finally some great snacks to enjoy. Dunno when but it must have been after midnight that I dropped dead into my bed.

Agra

A day to relax and go sight-seeing. Chervine came up with the idea of visiting places. First and foremost, the Taj Mahal.

Exploring Delhi

Last day in India for this trip and my flight is early in the evening. Hence, we decided to explore the city of Delhi. After a savvy breakfast Chervine and I were

Personal thoughts

It's quite difficult to express my experience and impressions of India, in particular due to the very short stay, into the right words. Let me say it like this:

It's overwhelming - in any sense and direction!

The first thing that hit me was the incredible amount of people nearly everywhere. Then there is the adventure of road traffic. Frankly, I wouldn't dare to drive around Delhi myself. Not because I don't know how to drive but probably regarding the level of interactions, the level of concentration, and the uncommon levels of sound (honk honk). It's too crowded, perhaps chaotic at certain stages but that's the beauty of it I would say.

Those few days in the state of Uttar Pradesh (UP) were really amazing and I had a great time mingling with other speakers and attendees of the C# Corner Annual Conference. The trips to Mathura and Agra gave me a small glimpse of the beauty of this humongous country called India. Walking through one of the many markets in Delhi and exploring the small shops surrounding it was mesmerising. Seeing the India Gate, the triumphal arch in Delhi, as well as Rashtrapati Bhavan with large park area was a nice treat at the end of my visit.

I'm hoping that this isn't my last trip to India. There are surely other cities like Darjeeling, Chennai, Bangalore, Mumbai, etc. worth a visit. Let's see what the future holds.

My thanks and gratitude to the community fellows at C# Corner. Keep shining!

Despite best effort and preparation of your precious source code one day you might be facing the situation that there is one or more files in your development workspace that doesn't belong into your git repository.

In general, that's a scenario to use the .gitignore file and exclude such file(s) from being considered or tracked for your repository. This works great but requires that you cover all your tracks regarding potential files, file extensions or folders you don't want to set under version control. Predicting the future is hard.

Plus, changes and audits happen. Meaning, a previously added file should be ignored from now on. Excluding such file in .gitignore won't work as expected out of the box. Such a file needs to be untracked first, and then excluded.

Behold a single one

To untrack a single file that has already been added/initialized to your repository, i.e., stop tracking the file but not delete it from your system use:

git rm --cached filename

To undo the previous command, add that single file back using git add filename.

Hold my beer!

Occasionally, there is more than a single file to handle. Here's how to untrack every file that is now in your .gitignore and then add all other files back.

First commit any outstanding code changes!

Then, run this command to untrack everything.

git rm -r --cached .

This removes any changed files from the index (staging area).

Afterwards, add everything back into the index, now respecting .gitignore excluding certain files and folders.

git add .

Note: Make sure to commit all your important changes before running git add . Otherwise, you will lose any changes to other files.

Complete the changes by commit.

git commit -m ".gitignore is now working"

Note of caution

Please be careful, when you push this to a repository and pull from somewhere else into a state where those files are still tracked, those files will be deleted.

This quickstart shows you how to get started with the Gemini API in Vertex AI on Google Cloud using an SDK for .NET called Mscc.GenerativeAI.

Prerequisites

To complete this quickstart locally, ensure that your .NET development meets the following requirements:

• .NET 6+ or
• .NET Framework 4.7.2+
• Account on Google Cloud

The NuGet package also supports .NET Standard 2.0.

Get set up on Google Cloud

To get you started using Vertex AI, follow the instructions in the official guide. You need to complete the following steps:

• Set up a project
• Enable billing for the Google Cloud project
• Enable Vertex AI APIs
• Install the Google Cloud CLI
• Set up Application Default Credentials (ADC)

In conclusion, you need the project ID associated with your project, and choose a supported region.

In order to keep private, sensitive information and secrets out of your source code repositories, it is recommended to use either Environment Variables, User Secrets, or a Key/Secrets Manager to retrieve data like an API key.

Here, I'm going to create an .env file and place it into the project folder with the following content.

GOOGLE_PROJECT_ID=<your project ID>
GOOGLE_REGION=us-central1

To access the value of a variable that is defined in a .env file, use $dotenv. More details are described under Environment Variables  in the official documentation.

Set the file properties with a Build action of None and copy instructions of Copy, if newer.

<None Update=".env" Condition="Exists('.env')">
    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>

Install the SDK / NuGet package

The SDK for .NET for the Gemini API is contained in the Mscc.GenerativeAI package. Install the dependency using dotnet CLI:

dotnet add package Mscc.GenerativeAI

See README for alternative options, like the NuGet Package Manager.

Note: This is a quickstart to Gemini on Vertex AI. If you need additional authentication options see README of Mscc.GenerativeAI and consider to add the package reference Mscc.GenerativeAI.Google which is based on the .NET Cloud Client Libraries.

Initialize the Generative Model

Before you can make any API calls, you need to add a reference to the namespace Mscc.GenerativeAI and initialize the Generative Model.

using Mscc.GenerativeAI;

var vertexAI = new VertexAI(
    projectId: Environment.GetEnvironmentVariable("GOOGLE_PROJECT_ID"), 
    region: Environment.GetEnvironmentVariable("GOOGLE_REGION"));
var model = vertexAI.GenerativeModel(model: Model.Gemini10Pro);

The necessary access token to authenticate against Google Cloud is retrieved from the Application Default Credentials or the Google Client Library, in case that you are using the Mscc.GenerativeAI.Google package.

Generate Text

var prompt = "Write a poem about Japanese koi.";
var responseStream = model.GenerateContentStream(prompt);

// Use StringBuilder to append the streamed responses
await foreach (var response in responseStream)
{
    var response = await model.GenerateContent();
    // optional, check for response.Candidates[0].FinishReason
    Console.WriteLine(response.Text);
}

Note: The package Mscc.GenerativeAI offers a unified developer experience across Google AI and Vertex AI provided by the interface IGenerativeAI. Meaning, the non-streaming method `GenerateContent` is available in Vertex AI and works as expected.

What's next

Explore the README of the NuGet package which has more samples documented. All unit tests are accessible in the GitHub repository:

GitHub - mscraftsman/generative-ai: Gemini AI Client for .NET

Gemini AI Client for .NET. Contribute to mscraftsman/generative-ai development by creating an account on GitHub.

GitHubmscraftsman

If you're new to generative AI models, you might want to look at the concepts guide and the Gemini API overview before trying a quickstart.

What's the difference from Google AI Gemini API

The Vertex AI Gemini API and Google AI Gemini API both let you incorporate the capabilities of Gemini models into your applications. The platform that's right for you depends on your goals.

The Vertex AI Gemini API is designed for developers and enterprises for use in scaled deployments. It offers features such as enterprise security, data residency, performance, and technical support. If you're an existing Google Cloud customer or deploy medium to large scale applications, you're in the right place.

If you're a hobbyist, student, or developer who is new to Google Cloud, try the Google AI Gemini API, which is suitable for experimentation, prototyping, and small deployments. If you're looking for a way to use Gemini directly from your mobile and web apps, see the Google AI SDKs for Android, Swift, and web.

This quickstart shows you how to get started with the Gemini API using an SDK for .NET called Mscc.GenerativeAI.

Prerequisites

To complete this quickstart locally, ensure that your .NET development meets the following requirements:

• .NET 6+ or
• .NET Framework 4.7.2+

The NuGet package also supports .NET Standard 2.0.

Set up your API key

To use the Gemini API, you'll need an API key. If you don't already have one, create a key in Google AI Studio.

In order to keep private, sensitive information and secrets out of your source code repositories, it is recommended to use either Environment Variables, User Secrets, or a Key/Secrets Manager to retrieve data like an API key. Here, I'm going to create an .env file and place it into the project folder with the following content.

GOOGLE_API_KEY=<The generated Gemini API key>

To access the value of a variable that is defined in a .env file, use $dotenv. More details are described under Environment Variables  in the official documentation.

Set the file properties with a Build action of None and copy instructions of Copy, if newer.

<None Update=".env" Condition="Exists('.env')">
    <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</None>

Install the SDK / NuGet package

The SDK for .NET for the Gemini API is contained in the Mscc.GenerativeAI package. Install the dependency using dotnet CLI:

dotnet add package Mscc.GenerativeAI

See README for alternative options, like the NuGet Package Manager.

Initialize the Generative Model

Before you can make any API calls, you need to add a reference to the namespace Mscc.GenerativeAI and initialize the Generative Model.

using Mscc.GenerativeAI;

var googleAI = new GoogleAI(apiKey: Environment.GetEnvironmentVariable("GOOGLE_API_KEY");
var model = googleAI.GenerativeModel(model: Model.GeminiPro);

Generate Text

var response = await model.GenerateContent("Write a story about a magic backpack.");
Console.WriteLine(response.Text);

What's next

Explore the README of the NuGet package which has more samples documented. All unit tests are accessible in the GitHub repository:

GitHub - mscraftsman/generative-ai: Gemini AI Client for .NET

Gemini AI Client for .NET. Contribute to mscraftsman/generative-ai development by creating an account on GitHub.

GitHubmscraftsman

If you're new to generative AI models, you might want to look at the concepts guide and the Gemini API overview before trying a quickstart.

Providing release notes for a NuGet package is an essential part of the development and distribution of the package itself. Commonly it shall be the first source of information to describe latest updates regarding the improvements and changes.

However, the current way of authoring release notes in a .NET project is sub-optimal. The following approach might offer a simpler way to achieve this including formatting and additional purpose on GitHub.

The situation (you might be facing)

On the one side, the Release notes element or PackageReleaseNotes of the MSBuild property in the .csproj project file is quite limited regarding formatting options. And it is cumbersome to update it with release information continuously. Especially while using the single line text entry in the properties page of Visual Studio.

Other the other hand, the PackageReadmeFile element provides a bit more freedom to describe a package, however, it is linked only. And on top of that, it is not even exposed in the user interface of the project properties.

So, having an external resource like a Markdown file that is not only linked could be an interesting alternative. The information is stored outside the project file, is easier to edit, and provides rich formatting options including images, bullet lists and hyperlinks.

A solution

Luckily, similar to pushing a package to a network share or to a NuGet source feed we can leverage another MSBuild task to take the content of that Markdown file and inject it into the package description.

Note: For a code base that is hosted in a (public) repository on GitHub (or BitBucket, Azure DevOps, Google Cloud Source Repositories, etc) using CHANGELOG.md instead of release notes might be a better choice of file name.

Let's start with a fresh CHANGELOG.md that we place in the root of the project folder.

# Changelog (Release Notes)

All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html) (SemVer).

## [Unreleased]

### Added
### Changed
### Fixed

As you might see in the file content already we are following a suggested format to maintain the change log and we are establishing Semantic Versioning right from the beginning. The content is written in Markdown and apart from using your favourite IDE which might have an integrated viewer for Markdown it is a commonly used and understood formatting syntax among developers. Markdown can also be transformed to other output formats like HTML or PDF. Think of pandoc as a utility tool to generate a different output, or maybe any kind of static web page generator like Hugo, et al.

Now, with the CHANGELOG.md file in place (and under version control) it is time to use an MSBuild task to read the content of the file and inject it into the project properties. Add a new Target element in your .csproj file with the following content, probably near the bottom area.

	<Target Name="InjectPackageReleaseNotesFromFile" BeforeTargets="GenerateNuspec" Condition="Exists('CHANGELOG.md')">
		<PropertyGroup>
			<PackageReleaseNotes>$([System.IO.File]::ReadAllText("$(MSBuildProjectDirectory)/CHANGELOG.md"))</PackageReleaseNotes>
		</PropertyGroup>
	</Target>

According to the BeforeTarget attribute this task is executed before generating the NuGet specification file .nuspec. A process that happens after successful compilation of the project or solution and as the name suggests before the actual NuGet package is created. Sounds perfect.

The task itself creates or updates the XML element PackageReleaseNotes in the project file and replaces the value with the complete content of the CHANGELOG.md file. To avoid any compilation issues the Condition attributes checks for the existence of the referenced file prior to executing the task.

To keep yourself and maybe other team members informed, place the following remark in the original Release notes of the project properties.

<PackageReleaseNotes>(Package release notes are in CHANGELOG.md)</PackageReleaseNotes>

Alternatively, leave it blank.

The result

Using Markdown to create richly formatted release notes compared to plain text might be a welcoming piece of documentation.

Here's how it looks in the NuGet Gallery.

In comparison the same release notes on GitHub.

With a small amount of extra work same CHANGELOG.md could be used as a source of GitHub Pages and be part of a generated, static website of your project.

What's got that to do with versioning?

The change log is already using semantic versioning to document changes. So, while already using this approach to inject the release notes into the NuGet package... Why not doing the same for the version of the package.

Instead of fiddling around in the project properties or updating the .csproj file directly, wouldn't be better to have a VERSION file in the root folder and its content is replacing the Version element during the compilation process.

Put the following lines once in your project file, and it's done.

<Version>$([System.IO.File]::ReadAllText("$(MSBuildProjectDirectory)/../../VERSION"))</Version>	

The path might be different for you and depending on how you structured your project. I put that VERSION file into the root folder of the repository because I'm using it for multiple projects simultaneously. A lazy way to keep the version information of related projects / packages in the same solution synchronized.

Both approaches - CHANGELOG.md and VERSION - are used in the NuGet packages Mscc.GenerativeAI*. It's an open-source library to integrate Google Gemini into .NET applications.

The repository of Gemini AI Client for .NET and ASP.NET Core is hosted on GitHub.

Final thought

Apart from maintaining those two files in the repository manually, they could have been generated or updated automatically by a continuous integration (CI) pipeline.

However, I leave that to you.

Perhaps a future blog article, who knows...

In a previous article on Create NuGet packages with Visual Studio / Visual Studio Code the software development lifecycle (SDLC) from build, pack, and deployment is done manually. Which can be quite time-consuming, tedious and tends to be error-prone given human interaction necessary. How about automating that process completely using Google Build?

What's Google Build?

Shortly said, Cloud Build is a service that executes your builds on Google Cloud. Or perhaps more precisely.

Cloud Build, Google Cloud’s continuous integration (CI) and continuous delivery (CD) platform, lets you build software quickly across all languages.

There are various machine types available and you can create a private pool for specific machine configurations or requirements.

The interesting part for single developers and probably small(er) teams is that Google Build offers a free tier which includes 2,500 build-minutes (at the time of writing) which can be used to automate quite some tasks.

Learn more about Google Cloud Build Pricing.

How to get started?

Navigate to Google Cloud Console, select your project and then enable the Google Build API for that project (and associated billing account).

Or if you prefer to use the gcloud CLI tool run the following command.

gcloud services enable cloudbuild.googleapis.com

If you are prompted to authorize the gcloud CLI, enter your credentials. Once the API is enabled, you can use the gcloud CLI to manage your builds. For example, to create a build, run the following command:

gcloud builds submit --config cloudbuild.yaml	

Which gives us the next glue. We need a build configuration file that instructs Google Build what to do. A basic build configuration file is described in the documentation: Create a build configuration file.

Use build configuration file

Writing such a build configuration file from scratch manually would be quite time consuming and probably a journey of trials and errors. Let Duet AI do the boring parts for us.

How to use Google Build to automate the build process?

Build, pack and push

steps:
- name: 'gcr.io/cloud-builders/dotnet'
  args: ['build', '-c', 'Release', 'src/Mscc.GenerativeAI.csproj']
- name: 'gcr.io/cloud-builders/dotnet'
  args: ['pack', '-c', 'Release', 'src/Mscc.GenerativeAI.csproj', '-o', 'output/']
- name: 'gcr.io/cloud-builders/dotnet'
  args: ['nuget', 'push', 'output/*.nupkg', '-k', '${_NUGET_API_KEY}', '-s', 'https://api.nuget.org/v3/index.json']

options:
  substitutions:
    _NUGET_API_KEY: YOUR_NUGET_API_KEY

Those are exactly the steps we did manually previously.

1. Build the .NET solution in Release configuration
2. Pack and put the assembly into the output folder
3. Push the generated package to NuGet using an API key

That's a solid fundament and I didn't have to look up the name of the cloud builder. Cloud builders are container images with common languages and tools installed in them.

Meaning, we are effectively pulling a Docker image by its container name from Google's Container Registry and use it to execute the arguments specified. The source code for these builders is available in the cloud builders GitHub repository. The Cloud Build developer community provides additional open-source builders that you can use to execute your tasks. And lastly, you can create your own custom builder for use in your builds.

A few options

As part of the options section you could also specify the machineType used to run those steps. The default machine type is e2-standard-2 with 2 CPUs. Which should be sufficient for the majority of build tasks and is also covered by the free tier of Google Build mentioned at the beginning.

Now, the final part of the build config file is the value of the NuGet API key, and how it can be injected into the build process. Substituting variable values can be achieved in different ways. There is a list of default substitutions, the possibility to work with user-defined substitutions, and even dynamic substitutions which are evaluated during the building process.

Submit to Google Build

Again, asking Duet AI.

How do I submit this configuration to Google Build with substitutions?

To submit your build configuration file to Google Build, you can use the gcloud builds submit command. The following command will submit the build configuration file that you have provided to Google Build:

gcloud builds submit --config cloudbuild.yaml --substitutions _NUGET_API_KEY=YOUR_NUGET_API_KEY

This command will start a build using the configuration that you have provided, with the substitution _NUGET_API_KEY set to the value YOUR_NUGET_API_KEY. You can track the progress of your build by using the gcloud builds list command. Here's an interesting part of the build process.

Starting Step #1
Step #1: Already have image (with digest): gcr.io/cloud-builders/dotnet
Step #1: Microsoft (R) Build Engine version 16.2.37902+b5aaefc9f for .NET Core
Step #1: Copyright (C) Microsoft Corporation. All rights reserved.
Step #1: 
Step #1:   Restore completed in 322.89 ms for /workspace/src/Mscc.GenerativeAI.csproj.
Step #1: /usr/share/dotnet/sdk/2.1.818/Microsoft.Common.CurrentVersion.targets(1175,5): error MSB3644: The reference assemblies for .NETFramework,Version=v4.7.2 were not found. To resolve this, install the Developer Pack (SDK/Targeting Pack) for this framework version or retarget your application. You can download .NET Framework Developer Packs at https://aka.ms/msbuild/developerpacks [/workspace/src/Mscc.GenerativeAI.csproj]
Finished Step #1
ERROR
ERROR: build step 1 "gcr.io/cloud-builders/dotnet" failed: step exited with non-zero status: 1

Given the .NET versions used the default container image is going to fail. Why?

Because it is based on the SDK for .NET Core 2.1! See GitHub

The project used targets newer .NET versions, and so we need a newer Docker image that we can retrieve from the Microsoft Container Registry (MCR). So, to migrate to the official dotnet image, make the following changes to your cloudbuild.yaml:

- name: 'gcr.io/cloud-builders/dotnet'
+ name: 'mcr.microsoft.com/dotnet/sdk:8.0'
+ entrypoint: 'dotnet'

Remove the original cloud builder provided by Google Container Registry (GCR) and add the most recent Docker image with .NET 8.0 SDK from the MCR.

The updated build config file looks like so.

steps:
# Build the project
- name: 'mcr.microsoft.com/dotnet/sdk:8.0'
  entrypoint: 'dotnet'
  args: ['build', '-c', 'Release', 'src/Mscc.GenerativeAI.csproj']
# Pack the NuGet package
- name: 'mcr.microsoft.com/dotnet/sdk:8.0'
  entrypoint: 'dotnet'

... skipped for brevity

Which returns the expected outcome.

... skipped for brevity
Step #0:   Mscc.GenerativeAI -> /workspace/src/bin/Release/net8.0/Mscc.GenerativeAI.dll
Step #0:   Successfully created package '/workspace/src/bin/Release/Mscc.GenerativeAI.0.4.4.nupkg'.
Step #0: 
Step #0: Build succeeded.
Step #0: 

... skipped for brevity

Step #0:     142 Warning(s)
Step #0:     0 Error(s)
Step #0: 
Step #0: Time Elapsed 00:00:20.87
Finished Step #0
Starting Step #1
Step #1: Already have image (with digest): mcr.microsoft.com/dotnet/sdk:8.0
Step #1: MSBuild version 17.9.4+90725d08d for .NET
Step #1:   Determining projects to restore...
Step #1:   All projects are up-to-date for restore.
Step #1:   Successfully created package '/workspace/output/Mscc.GenerativeAI.0.4.4.nupkg'.
Finished Step #1
Starting Step #2
Step #2: Already have image (with digest): mcr.microsoft.com/dotnet/sdk:8.0
Step #2: Pushing Mscc.GenerativeAI.0.4.4.nupkg to 'https://www.nuget.org/api/v2/package'...
Step #2:   PUT https://www.nuget.org/api/v2/package/
Step #2:   Created https://www.nuget.org/api/v2/package/ 742ms
Step #2: Your package was pushed.
Finished Step #2
PUSH
DONE

A successfully completed build, pack and push of the NuGet package.

Tune the build config file

While using the dotnet Docker image to build, pack and push the NuGet package we might want to reduce the generated output a little bit. In particular regarding the first time experience and telemetry opt-out. Therefore, add the following env block into the options.

options:
  env:
  - 'DOTNET_CLI_TELEMETRY_OPTOUT=true'
  - 'DOTNET_SKIP_FIRST_TIME_EXPERIENCE=true'

The resulting build configuration file should look similar to this.

# outline the steps to build a .NET project, pack it as Nuget package and push it to Nuget source feed
steps:
# Build the project
- name: 'mcr.microsoft.com/dotnet/sdk:8.0'
  entrypoint: 'dotnet'
  args: ['build', '-c', 'Release', 'src/Mscc.GenerativeAI.csproj']
# Pack the NuGet package
- name: 'mcr.microsoft.com/dotnet/sdk:8.0'
  entrypoint: 'dotnet'
  args: ['pack', '-c', 'Release', 'src/Mscc.GenerativeAI.csproj', '-o', 'output/']
# Push the package to NuGet source feed
- name: 'mcr.microsoft.com/dotnet/sdk:8.0'
  entrypoint: 'dotnet'
  args: ['nuget', 'push', 'output/*.nupkg', '-k', '${_NUGET_API_KEY}', '-s', 'https://api.nuget.org/v3/index.json']

options:
  substitutionOption: 'ALLOW_LOOSE'
  env:
  - 'DOTNET_CLI_TELEMETRY_OPTOUT=true'
  - 'DOTNET_SKIP_FIRST_TIME_EXPERIENCE=true'
substitutions:
  _NUGET_API_KEY: YOUR_NUGET_API_KEY

Eventually, it is considerable to use a separate API key for NuGet specifically used for the Google Build submission compared to the one used while doing it manually. I have several API keys in place.

Where's the actual automation?

Up till now, we have reduced manual labour by using a scripted approach. However, there is no automated process, at least not yet. To achieve an automated publication of a NuGet package we need a trigger. A trigger would initiate the Google Build submission based on a specific interaction, like say pushing a commit to the repository, merging a pull request, or perhaps run at a certain time every day.

Cloud Build uses build triggers to enable CI/CD automation. You can configure triggers to listen for incoming events, such as when a new commit is pushed to a repository or when a pull request is initiated, and then automatically execute a build when new events come in.

Create a Cloud Trigger to start an automated Cloud Build whenever there are changes to the source code. For that, we need to know where the code repository is located and establish a connection in Cloud Build. Your repositories in Cloud Source Repositories are connected to Cloud Build by default. If you are connecting an external repository, such as one hosted on GitHub or Bitbucket, you will need admin-level permissions on the repository to initially connect your repository to Cloud Build.

Learn more about Create and manage build triggers.

Connect a GitHub repository

The sample source code is hosted on GitHub. This gives us two options, either we add a new remote to our local workspace and mirror the source code, or we create a trigger with a connection to the GitHub repository. Let's go for the connection.

Open the Triggers section of Cloud Build in the Google Cloud Console.

Click on Connect Repository in the top area and complete the connection.

In case of first connection, GitHub asks for your consent to authorize Google Cloud Build to access your repositories.

Eventually, the list of repositories on GitHub might be incomplete.

Click on Edit repositories on GitHub to extend the Repository access.

After adding the target repository, we can establish the connection to use in Cloud Build.

Create a Cloud Trigger

Last, we create a trigger using the connection. You can accept the suggested one at the end of the connection or create a new trigger.

Click on Create sample trigger and you are done.

Out of laziness I created the sample trigger but I'm going to edit it directly afterwards. Why? Because I don't like the suggested name,  the suggested description, I don't want the trigger to monitor every branch but the main, and most importantly the substitution variables are missing.

The following gcloud command creates the same trigger including the user-defined substitutions.

    gcloud builds triggers create github \
    --name="nuget-build-push" \
    --description="Build, pack and push to NuGet on main branch" \
    --region="us-central1" \
    --repo-name="generative-ai" \
    --repo-owner="mscraftsman" \
    --branch-pattern="^main$" \
    --build-config="cloudbuild.yaml" \
    --substitutions="_NUGET_API_KEY=YOUR_NUGET_API_KEY"

The result should look like this.

Created [https://cloudbuild.googleapis.com/v1/projects/...].
NAME              CREATE_TIME                STATUS
nuget-build-push  2024-03-03T06:44:22+00:00

Learn more about Create and manage build triggers.

Showtime!

I made some changes to my source code and I'm about to push those commits.

After click on Sync Changes, I open the History section of Cloud Build to check the status.

You can directly observe the build steps and see the result of each in the details of a build.

The substitution variables, here the NuGet API key, have been applied and the package has been pushed to nuget.org successfully.

Now with a complete, working CI/CD pipeline using Google Cloud Build, I can concentrate on the source code and the implementation of new features. Gone are the boring and error-prone, manual steps to build, pack and push a new version of the NuGet package.

What a breeze!

But there is more...

Avoid too many builds

There are reasons you don't want to trigger a new build automatically, like i.e. fixing a typo, amending the documentation, or adding a new test, etc. Any kind of changes to the repository that would not justify / satisfy the deployment of a new version of a NuGet package.

Triggers in Cloud Build provide at least two ways to reduce unnecessary builds and avoid wasting valuable build-minutes in your billing account.

Use files filter

In such case, you can either specify an Included files filter or an Ignored files filter using glob strings to define which files need to be affected or shall be ignored to trigger a build.

The corresponding gcloud options are called --included-files and ignored-files to manage when a build is triggered or not.

The structure of my public GitHub generative-ai used here in the article, has a folder called src that contains the source code of the actual NuGet package. With an included files filter of src/** I define that only changes affecting at least one included file will trigger a build.

Note: ** is a recursive version of * which matches all files and directories in the selected directory and its subdirectories.

Skipping a build trigger

Additionally, there is the ability to skip a build trigger based on a single commit message. In such scenarios, you can include [skip ci] or [ci skip] in the commit message, and a build will not be invoked.

If you want to run a build on that commit later, use the Run trigger button in the Triggers page.

Learn more about Cloud Build triggers.

Using NuGet packages gives developers a great amount of flexibility and fast pace to implement their own ideas. Whether you are using packages from other authors or prefer to use your own ones. The following article summarises my findings in how to get started building NuGet packages with Visual Studio, Visual Studio Code, or even the command line only.

During one of the last assignments and more recently working on some Gemini AI related coding I came across the need for NuGet packages.

What is NuGet?

An essential tool for any modern development platform is a mechanism through which developers can create, share, and consume useful code. Often such code is bundled into "packages" that contain compiled code (as DLLs) along with other content needed in the projects that consume these packages.

For more background information I highly recommend reading Taking on DLL hell and follow-up articles by David Ebbo.

For .NET (including .NET Core), the Microsoft-supported mechanism for sharing code is NuGet, which defines how packages for .NET are created, hosted, and consumed, and provides the tools for each of those roles.

Following is the flow of NuGet package.

Learn more about NuGet in the documentation.

Although there are multiple tools to handle NuGet packages this article is mainly focusing on the dotnet CLI tool.

Creating a new project

Whether you start with a clean slate or converting/extending an existing project is nearly the same experience. For clarity I'm going to create a new dotnet project and guide you through the steps to add more functionality to the NuGet package.

dotnet new classlib

Despite having no functionality it is already possible to create a NuGet package using such an empty project.

dotnet pack

However, you would be stuck with the default values for the moment. Which we won't accept.

"Don't accept the defaults!" – Abel Wang

The command output has the full path information to the generated .nupkg file. Which is a ZIP archive and can be inspected either using an archive manager or the built-in features of the file manager.

Targeting a .NET version

While creating a new project you either use the target versions of .NET or the project template defines it for you. When you open a .NET project file, usually a csproj file for C# you might notice the XML element TargetFramework.

<Project Sdk="Microsoft.NET.Sdk"> 
  <PropertyGroup> 
    <TargetFramework>netstandard2.0</TargetFramework> 
  </PropertyGroup> 
</Project>

The allowed value of TargetFramework are .NET specific version moniker and instructs the compiler which version of .NET to target for your assembly.

Multi-targeting .NET versions

You have seen it already with numerous other NuGet packages that are targetting multiple versions of .NET. Ranging from elderly versions of .NET Framework, and therefore Windows only, to the latest preview versions of .NET (Core). How is this done? Using .NET ability to allow targetting multiple versions using one single project.

Open your .NET project .csproj file and change the TargetFramework element to its plural version TargetFrameworks and add more target framework monikers (TFM) separated by semicolons, like so.

<Project Sdk="Microsoft.NET.Sdk"> 
  <PropertyGroup> 
    <TargetFrameworks>netstandard2.0;net8.0</TargetFrameworks> 
  </PropertyGroup> 
</Project>

Learn more about multi-targetting for NuGet packages and how to support multiple .NET versions in your project file.

Package attributes in your project file

There are a number of attributes for NuGet packages that can be added to the project file. Newer versions of Visual Studio (2022 and onwards) provide better options and most of those values can be configured in the IDE under the properties of the project.

As we are using MSBuild to pack the assembly and create the NuGet package, we use MSBuild properties to configure and describe the attributes of the package. Let's have a look at some essential MSBuild properties which might cover the majority of needs.

<Project Sdk="Microsoft.NET.Sdk"> 
  <PropertyGroup> 
    <TargetFramework>netstandard2.0</TargetFramework> 
    <PackageId>MSCC.GenerativeAI</PackageId> 
    <Version>0.5.42</Version> 
    <Description> 
      A simple package to integrate generative AI into an application. 
    </Description> 
   <PackageProjectUrl>https://mscraftsman.github.io/</PackageProjectUrl> 
    <RepositoryUrl>https://github.com/mscraftsman/generative-ai</RepositoryUrl> 
    <Authors>Jochen Kirstätter</Authors> 
    <Copyright>Copyright (c) Jochen Kirstätter</Copyright> 
    <PackageReadmeFile>README.md</PackageReadmeFile> 
    <PackageIcon>mscc-nuget.png</PackageIcon> 
    <PackageTags>genAI;Generative AI;Gemini;Vertex AI</PackageTags> 
    <PackageLicenseFile>LICENSE</PackageLicenseFile> 
    <PackageRequireLicenseAcceptance>False</PackageRequireLicenseAcceptance> 
    <PackageReleaseNotes>- Update README.md</PackageReleaseNotes> 
    <GeneratePackageOnBuild>True</GeneratePackageOnBuild> 
  <PropertyGroup> 
</Project>

The package identifier and the version number uniquely identify the exact code that's contained in the package. This is important to know. Once a package has been added to a NuGet source it cannot be modified anymore or replaced. Any changes to the source code or package properties require a new build and pack process. Hence, the package identifier and the version number uniquely identify the exact code that's contained in the package.

A list of all MSBuild properties is found in the reference section of the documentation: NuGet pack and restore as MSBuild targets.

After package creation you can still check and inspect the generated .nupkg file to see whether all intended content is present.

Note: A NuGet package with the .nupkg extension is simply a ZIP file. To easily examine any package's contents, change the extension to .zip and expand its contents as usual. Just be sure to change the extension back to .nupkg before attempting to upload it to a host.

This also allows you to quickly review the generated .nuspec file.

You can check all assets needed per targetted .NET version.

Using a NuSpec file

In case that the available MSBuild properties are not sufficient enough to define all package atrributes, it is still possible to add a .nuspec file to the project with more details.

Learn more about packing using a .nuspec file.

Deploy a NuGet package

After completing the dotnet pack command you can distribute the .nupkg file to a shared store or publish it to a NuGet source.

Use a network drive

Because pack and restore are MSBuild targets, you can access them to enhance your workflow. For example, let's say you want to copy your package to a network share after packing it. You can do that by adding the following in your project file:

<Target Name="CopyPackage" AfterTargets="Pack"> 
  <Copy 
    SourceFiles="$(OutputPath)..\$(PackageId).$(PackageVersion).nupkg" 
    DestinationFolder="\\myshare\packageshare\" /> 
</Target>

Azure Artifacts

Quite often there is a correlation between projects written in .NET and using Azure DevOps for continuous integration (CI) and continuous deployment (CD). One and more pipelines in Azure DevOps are used to create, pack, and deploy projects.

The resulting assemblies, or in this case, the NuGet package can then be pushed to Azure Artifacts and accessed by other developer that have access to that store.

Probably, it is an option to distribute NuGet packages among smaller teams of developers. More on this approach below.

NuGet Gallery

If you are comfortable publishing your package to the rest of the world then the NuGet Gallery might be your first choice to spread your codes. Setting up an account is straight forward and a matter of seconds using a Microsoft account.

Then upload the .nupkg file to the nuget.org web portal and you are officially published as a NuGet package maintainer.

Alternatively, you can push the package using a command line. To push packages to nuget.org with a command line, you can use either dotnet.exe or nuget.exe v4.1.0 or above, which implement the required NuGet protocols.

All the necessary steps are largely described in Push NuGet packages in the official documentation.

Third party systems

There are other free and proprietary solutions to handle packages and source feeds within your organisation. In the past I used to work with the likes of ProGet and MyGet.

BTW, all that could be integrated into a CI/CD pipeline with minimal effort.

Summary

Using NuGet packages whether in context of private, in-house development or public sets boundaries between different responsibilities, capabilities, and functionalities of an application. Furthermore, it allows that development can be done as independent units and provides more stability across multiple projects and therefore development teams. New versions of packages can be developed without having concerns to break existing projects by others that are incorporating that functionality. And with access to previous versions of a NuGet package software developers have peace of mind regarding their decision when to upgrade and more importantly that a rollback is possible anytime in case there might be breaking changes.

Access to pre-release versions of a NuGet package can easily be handled alongside the releases of stable versions.

Naming things in information technology is a hard nut to crack, and so it is not surprising that recent announcements about the line of Gemini products might be confusing. This article focuses on using the Vertex AI Gemini API provided by Google Cloud Platform.

Generative AI on Vertex AI (also known as genAI or gen AI) gives you access to Google's large generative AI models so you can test, tune, and deploy them for use in your AI-powered applications.

It's the professional or enterprise offering compared to the consumer oriented AI Studio. Access to Vertex AI Gemini API is currently offered through SDKs for various programming languages like Python, Go, Node.js, and Java.

Set up Vertex AI

First, you need an account on Google Cloud. If you don't already have one you can sign up and benefit from $US 300 credits to start with.

To use Vertex AI it is necessary to create or use an existing project, billing needs to be enabled for that project, and the Vertex AI API needs to be enabled.

Then navigate to the Artificial Intelligence section, choose Vertex AI menu and open the Multimodal entry under Vertex AI Studio. This should be your launch base to prompts and the documentation, if necessary.

Gemini API offerings

The Vertex AI Gemini API contains the publisher endpoints for the Gemini models developed by Google DeepMind.

• Gemini 1.0 Pro is designed to handle natural language tasks, multiturn text and code chat, and code generation.
• Gemini 1.0 Pro Vision supports multimodal prompts. You can include text, images, and video in your prompt requests and get text or code responses.

Set up Visual Studio

With the release of Visual Studio 2022 Version 17.5 there is a new feature available that allows for better, faster API development using .http/.rest files with an integrated HTTP client. Those files enable you to "run" your API endpoints and manipulate various REST calls to iterate within parameters and see the outputs in a structured way. Learn more about Visual Studio 2022 - 17.5 release announcement.

Similar to the set up procedures for Getting started with Gemini using Visual Studio create a project, probably a web application or API one and create an .http file to start with.

In order to keep private, sensitive information and secrets out of your source code repositories, it is recommended to use either Environment Variables, User Secrets, or Azure Key Vault to retrieve data like the project ID or an access token. Here, I'm going to create an .env file and place it into the project folder with the following content.

PROJECT_ID=<your Google Cloud project ID>
ACCESS_TOKEN=<your access token to Google Cloud>

To access the value of a variable that is defined in a .env file, use $dotenv. More details are described under Environment Variables  in the official documentation.

After you logged into Google Cloud either using the Console Shell or the gcloud CLI tool (recommended) you can retrieve the access token with the following command.

$ gcloud auth print-access-token

Copy and paste the output as value of the ACCESS_TOKEN variable into your .env file. In case that the next request is still not authorized, make a small change to the .http fle content and try again. There seems to be a slight delay or synchronisation issue in the integrated REST client.

Use the Vertex AI Gemini API

The documentation on Google Cloud describes the Generative AI foundational model reference in general, and its Gemini API in particular. Here, there are two API endpoints of interest.

https://{REGION}-aiplatform.googleapis.com/v1/projects/{PROJECT_ID}/locations/{REGION}/publishers/google/models/gemini-1.0-pro:streamGenerateContent

https://{REGION}-aiplatform.googleapis.com/v1/projects/{PROJECT_ID}/locations/{REGION}/publishers/google/models/gemini-1.0-pro-vision:streamGenerateContent

The difference between both is simply the selection of model - gemini-1.0-pro and gemini-1.0-pro-vision. There is the method streamGenerateContent only to generate information based on the data and prompts you send to the API.

Use the Gemini 1.0 Pro model

The Gemini 1.0 Pro (gemini-1.0-pro) model is tailored for natural language tasks such as classification, summarization, extraction, and writing.

Generate text from text

Send a text prompt to the model. The Gemini 1.0 Pro (gemini-1.0-pro) model provides a streaming response mechanism: streamGenerateContent. With this approach, you don't need to wait for the complete response; you can start processing fragments as soon as they're accessible.

@projectId={{$dotenv PROJECT_ID}}
@accessToken={{$dotenv ACCESS_TOKEN}}
@region=us-central1
@model=gemini-1.0-pro
@apiEndpoint={{region}}-aiplatform.googleapis.com

# Send a text-only request
POST https://{{apiEndpoint}}/v1/projects/{{projectId}}/locations/{{region}}/publishers/google/models/{{model}}:streamGenerateContent
Authorization: Bearer {{accessToken}}
Content-Type: application/json

{
  "contents": {
    "role": "USER",
    "parts": { "text": "Why is the sky blue?" }
  }
}

Working with configuration parameters

Every prompt you send to the model includes parameter values that control how the model generates a response. The model can generate different results for different parameter values. Learn more about model parameters.

Also, you can use safety settings to adjust the likelihood of getting responses that may be considered harmful. By default, safety settings block content with medium and/or high probability of being unsafe content across all dimensions. Learn more about safety settings.

@projectId={{$dotenv PROJECT_ID}}
@accessToken={{$dotenv ACCESS_TOKEN}}
@region=us-central1
@model=gemini-1.0-pro
@apiEndpoint={{region}}-aiplatform.googleapis.com

# Send a text-only request with model parameters and safety settings
POST https://{{apiEndpoint}}/v1/projects/{{projectId}}/locations/{{region}}/publishers/google/models/{{model}}:streamGenerateContent
Authorization: Bearer {{accessToken}}
Content-Type: application/json

{
  "contents": {
    "role": "USER",
    "parts": { "text": "Why is the sky blue?" }
  },
  "generation_config": {
    "temperature": 0.2,
    "top_p": 0.1,
    "top_k": 16,
    "max_output_tokens": 2048,
    "candidate_count": 1,
    "stop_sequences": []
  },
  "safety_settings": {
    "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
    "threshold": "BLOCK_LOW_AND_ABOVE"
  }
}

Multi-turn conversations (chat)

The Gemini 1.0 Pro model supports natural multi-turn conversations and is ideal for text tasks that require back-and-forth interactions. Specify the role field only if the content represents a turn in a conversation. You can set role to one of the following values: user, model.

@projectId={{$dotenv PROJECT_ID}}
@accessToken={{$dotenv ACCESS_TOKEN}}
@region=us-central1
@model=gemini-1.0-pro
@apiEndpoint={{region}}-aiplatform.googleapis.com

# Using multi-turn conversations (chat)
POST https://{{apiEndpoint}}/v1/projects/{{projectId}}/locations/{{region}}/publishers/google/models/{{model}}:streamGenerateContent
Authorization: Bearer {{accessToken}}
Content-Type: application/json

{
  "contents": [
    {
      "role": "user",
      "parts": [
        { "text": "Hello" }
      ]
    },
    {
      "role": "model",
      "parts": [
        { "text": "Hello! I am glad you could both make it." }
      ]
    },
    {
      "role": "user",
      "parts": [
        { "text": "So what is the first order of business?" }
      ]
    }
  ]
}

The first order of business is to introduce ourselves and get to know each other.

Use the Gemini 1.0 Pro Vision model

The Gemini 1.0 Pro Vision (gemini-1.0-pro-vision) is a multimodal model that supports adding image and video in text or chat prompts for a text response.

Note: Text-only prompts are not supported by the Gemini 1.0 Pro Vision model. Instead, use the Gemini 1.0 Pro model for text-only prompts.

Generate text from a local image

Specify the base64 encoding of the image or video to include inline in the prompt and the mime_type field. The supported MIME types for images include image/png and image/jpeg.

@projectId={{$dotenv PROJECT_ID}}
@accessToken={{$dotenv ACCESS_TOKEN}}
@region=us-central1
@model=gemini-1.0-pro-vision
@apiEndpoint={{region}}-aiplatform.googleapis.com

# Generate text from a local image. 
# Command Prompt base64 conversion used: certutil -encodehex -f "scones.jpg" "output.txt" 0x40000001 1>nul
POST https://{{apiEndpoint}}/v1/projects/{{projectId}}/locations/{{region}}/publishers/google/models/{{model}}:streamGenerateContent
Authorization: Bearer {{accessToken}}
Content-Type: application/json

{
  "contents": {
    "role": "USER",
    "parts": [
      {
        "text": "What is this picture?"
      },
      {
        "inline_data": {
          "mime_type":"image/jpeg",
          "data": "/9j/4AAQSkZJRgA...Wup/9k="
        }
      }
    ]
  }
}

Here's the excerpt from the streamed response.

The picture shows a table with a cup of coffee, a bowl of blueberries, and several blueberry scones. There are also pink flowers on the table.

Here are the steps to get the sample image and encode it in base64. The image is available here. It has been resized to a width of 512px prior to base64 encoding.

https://storage.googleapis.com/generativeai-downloads/images/scones.jpg

On Windows use a Command Prompt with the certutil command.

> certutil -encodehex -f "scones.jpg" "output.txt" 0x40000001 1>nul

Whereas on Linux or macOS use the base64 command to encode the image.

$ base64 -w0 scones.jpg > output.txt

Note: At the time of writing .http/.rest files in Visual Studio 2022 do not provide a functionality to read external files directly.

Generate text from an image on Google Cloud Storage

Specify the Cloud Storage URI of the image to include in the prompt. The bucket that stores the file must be in the same Google Cloud project that's sending the request. You must also specify the mime_type field. The supported image MIME types include image/png and image/jpeg.

@projectId={{$dotenv PROJECT_ID}}
@accessToken={{$dotenv ACCESS_TOKEN}}
@region=us-central1
@model=gemini-1.0-pro
@apiEndpoint={{region}}-aiplatform.googleapis.com

# Generate text from an image on Google Cloud Storage.
POST https://{{apiEndpoint}}/v1/projects/{{projectId}}/locations/{{region}}/publishers/google/models/{{model}}:streamGenerateContent
Authorization: Bearer {{accessToken}}
Content-Type: application/json

{
  "contents": {
    "role": "USER",
    "parts": [
      {"text": "Is it a cat?"},
      {"file_data": {
        "mime_type": "image/jpeg",
        "file_uri": "gs://cloud-samples-data/generative-ai/image/320px-Felis_catus-cat_on_snow.jpg"
      }}
    ]
  }
}

A cat with gray and black stripes is walking in the snow.

Generate text from a video file

Specify the Cloud Storage URI of the video to include in the prompt. The bucket that stores the file must be in the same Google Cloud project that's sending the request. You must also specify the mime_type field. The supported MIME types for video include video/mp4.

@projectId={{$dotenv PROJECT_ID}}
@accessToken={{$dotenv ACCESS_TOKEN}}
@region=us-central1
@model=gemini-1.0-pro
@apiEndpoint={{region}}-aiplatform.googleapis.com

# Generate text from a video file.
# Using Google Storage as a source.
POST https://{{apiEndpoint}}/v1/projects/{{projectId}}/locations/{{region}}/publishers/google/models/{{model}}:streamGenerateContent
Authorization: Bearer {{accessToken}}
Content-Type: application/json

{
  "contents": {
    "role": "USER",
    "parts": [
      {
        "text": "Answer the following questions using the video only. What is the profession of the main person? What are the main features of the phone highlighted?Which city was this recorded in?Provide the answer JSON."
      },
      {
        "file_data": {
          "mime_type": "video/mp4",
          "file_uri": "gs://github-repo/img/gemini/multimodality_usecases_overview/pixel8.mp4"
        }
      }
    ]
  }
}

Limited to Visual Studio?

Absolutely not!

I successfully used the same set of .http files in the following text editors and environments with the REST Client extension by Huachao Mao.

• Visual Studio Code - locally and online https://vscode.dev/
• Google Cloud Shell Editor (Code OSS for the Web)
• Project IDX - https://idx.dev/

Source code: Gemini Playground

I created a repository on GitHub gemini-playground that contains all samples described above with the exception of the .env file and the credentials to access the Vertex AI Gemini API. Feel free to give it a star and fork it for your own purpose.

Migrate from Gemini on Google AI to Vertex AI

As mentioned initially there are multiple "Gemini AI" offerings available. If you are new to Gemini, using the quickstarts and plans for Google AI Studio is the fastest way to get started.

However, as your generative AI solutions mature, you may need a platform for building and deploying generative AI applications and solutions end to end. Google Cloud provides a comprehensive ecosystem of tools to enable developers to harness the power of generative AI, from the initial stages of app deployment to managing complex data at scale. Google Cloud's Vertex AI platform offers a suite of MLOps tools that streamline the usage, deployment, and monitoring of AI models for efficiency and reliability.

Learn more about Gemini API and the Google AI versus Vertex AI differences.

Lastly, why is the sky blue?

Here's the response I was provided by Vertex AI Gemini API.

The sky is blue due to a phenomenon called Rayleigh scattering. This scattering occurs because the shorter wavelengths of sunlight (blue and violet) are scattered more effectively by molecules in the atmosphere than longer wavelengths (red and orange). The scattered blue light is what we see when we look up at the sky, while the longer wavelengths of light pass through the atmosphere and reach our eyes as sunlight.

With the release of Visual Studio 2022 Version 17.5 there is a new feature available that allows for better, faster API development using .http/.rest files with an integrated HTTP client. Those files enable you to "run" your API endpoints and manipulate various REST calls to iterate within parameters and see the outputs in a structured way.

Access to Gemini is currently offered through SDKs for various programming languages like Python, Go, Node.js, and so forth, including the barebone REST API. You can get an overview here: https://ai.google.dev/tutorials

The tutorial on Quickstart: Get started with Gemini using the REST API is limited to the use of the curl command only.

If you want to quickly try out the Gemini API, you can use curl commands to call the methods in the REST API. The examples in this tutorial show calls for each API method.

As a Windows developer using Visual Studio this might not be the optimum starting point, hence this article which calls the same REST API using .http/.rest files in Visual Studio.

These .http/.rest files aren’t meant to replace integration and unit testing. Instead, they provide a new way to rapidly iterate on API development, as well as a common place to monitor the APIs your app may be using and investigate required inputs/outputs during development.

Learn more about Visual Studio 2022 - 17.5 release announcement.

Set up your API key

To use the Gemini API, you'll need an API key. If you don't already have one, create a key in Google AI Studio.

In order to keep private, sensitive information and secrets out of your source code repositories, it is recommended to use either Environment Variables, User Secrets, or Azure Key Vault to retrieve data like an API key. Here, I'm going to create an .env file and place it into the project folder with the following content.

API_KEY=<The generated Gemini API key>

To access the value of a variable that is defined in a .env file, use $dotenv. More details are described under Environment Variables  in the official documentation.

All examples read the API key as environment variable from the .env file and stores it as a (local) variable. Additionally, there are variables for the API version and the model to be used. More information on API versions explained in the official documentation.

Model info

When starting with the Gemini API there is often the question of What's available? Apart from the documentation you can query the Gemini API to retrieve a list of available models, and you can get the details of an individual model.

List models

If you GET the models directory, it uses the list method to list all of the models available through the API, including both the Gemini and PaLM family models.

@apiKey={{$dotenv API_KEY}}
@version=v1beta

# Get a list of available models and description
GET https://generativelanguage.googleapis.com/{{version}}/models?key={{apiKey}}

Get model

If you GET a model's URL, the API uses the get method to return information about that model such as version, display name, input token limit, etc.

@apiKey={{$dotenv API_KEY}}
@version=v1beta
@model=gemini-pro

# Get information about the model, including default values
GET https://generativelanguage.googleapis.com/{{version}}/models/{{model}}?key={{apiKey}}

The response might look like this.

Gemini and Content based APIs

Text-only input (Gemini Pro)

For text-only input use the gemini-pro model and call the generateContent method to generate a response from the model. Using the variable values a POST request is send to the Gemini API endpoint with the prompt specified in JSON format.

@apiKey={{$dotenv API_KEY}}
@version=v1beta
@model=gemini-pro

# Send a text-only request
POST https://generativelanguage.googleapis.com/{{version}}/models/{{model}}:generateContent?key={{apiKey}}
Content-Type: application/json

{
  "contents": [{
    "parts": [{
      "text": "Write a story about a magic backpack."
    }]
  }]
}

Text-and-image input (Gemini Pro Vision)

If the input contains both text and image, use the gemini-pro-vision model. The following snippets help you build a request and send it to the REST API.

@apiKey={{$dotenv API_KEY}}
@version=v1beta
@model=gemini-pro-vision

# Send a text and image as input request. 
# Command Prompt base64 conversion used: certutil -encodehex -f "scones.jpg" "output.txt" 0x40000001 1>nul
POST https://generativelanguage.googleapis.com/{{version}}/models/{{model}}:generateContent?key={{apiKey}}
Content-Type: application/json

{
  "contents":[
    {
      "parts":[
        {
          "text": "What is this picture?"
        },
        {
          "inline_data": {
            "mime_type":"image/jpeg",
            "data": "/9j/4AAQSkZ...GTWup/9k="
          }
        }
      ]
    }
  ]
}

The various elements of your input are defined as parts in your prompt. Like previously, the text part contains your actual prompt and an additional file like an image is added as base64-encoded inline data including its mime type. The data key has a base64 encoded representation of the image to inspect using the prompt.

The picture shows a table with a white tablecloth. On the table are two cups of coffee, two small bowls, one filled with blueberries and the other with a silver spoon. There are also three scones with blueberries on the table. Next to the scones are some peony flowers.

Here are the steps to get the sample image and encode it in base64. The image is available here. It has been resized to a width of 512px prior to base64 encoding.

https://storage.googleapis.com/generativeai-downloads/images/scones.jpg

On Windows use a Command Prompt with the certutil command.

> certutil -encodehex -f "scones.jpg" "output.txt" 0x40000001 1>nul

Whereas on Linux or macOS use the base64 command to encode the image.

$ base64 -w0 scones.jpg > output.txt

Note: At the time of writing .http/.rest files in Visual Studio 2022 do not provide a functionality to read external files directly.

Count tokens

When using long prompts, it might be useful to count tokens before sending any content to the model.

@apiKey={{$dotenv API_KEY}}
@version=v1beta
@model=gemini-pro

# Count tokens for a long prompt
POST https://generativelanguage.googleapis.com/{{version}}/models/{{model}}:countTokens?key={{apiKey}}
Content-Type: application/json

{
  "contents": [{
    "parts": [{
      "text": "Write an extended story about a magic backpack."
    }]
  }]
}

Multi-turn conversations (chat)

Using Gemini, you can build freeform conversations across multiple turns.

@apiKey={{$dotenv API_KEY}}
@version=v1beta
@model=gemini-pro

# Using multi-turn conversations (chat)
POST https://generativelanguage.googleapis.com/{{version}}/models/{{model}}:generateContent?key={{apiKey}}
Content-Type: application/json

{
  "contents": [
    {"role": "user",
      "parts": [{
        "text": "Write the first line of a story about a magic backpack."}]},
    {"role": "model",
      "parts": [{
        "text": "In the bustling city of Meadow brook, lived a young girl named Sophie. She was a bright and curious soul with an imaginative mind."}]},
    {"role": "user",
      "parts": [{
        "text": "Can you set it in a quiet village in 1600s France?"}]},
  ]
}

Working with configuration parameters

Every prompt you send to the model includes parameter values that control how the model generates a response. The model can generate different results for different parameter values. Learn more about model parameters.

Also, you can use safety settings to adjust the likelihood of getting responses that may be considered harmful. By default, safety settings block content with medium and/or high probability of being unsafe content across all dimensions. Learn more about safety settings.

The following example specifies values for all the parameters of the generateContent method.

@apiKey={{$dotenv API_KEY}}
@version=v1beta
@model=gemini-pro

# Send a text-only request with model parameters and safety settings
# Ref: https://ai.google.dev/docs/concepts#model-parameters
POST https://generativelanguage.googleapis.com/{{version}}/models/{{model}}:generateContent?key={{apiKey}}
Content-Type: application/json

{
  "contents": [{
    "parts": [{
      "text": "Write a story about a magic backpack."
    }]
  }],
  "safetySettings": [
    {
        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
        "threshold": "BLOCK_ONLY_HIGH"
    }
  ],
  "generationConfig": {
    "stopSequences": [
        "Title"
    ],
    "temperature": 1.0,
    "maxOutputTokens": 800,
    "topP": 0.8,
    "topK": 10
  }
}

Limited to Visual Studio?

Absolutely not!

I successfully used the same set of .http files in the following text editors and environments with the REST Client extension by Huachao Mao.

• Visual Studio Code - locally and online https://vscode.dev/
• Google Cloud Shell Editor (Code OSS for the Web)
• Project IDX - https://idx.dev/

Source code: Gemini Playground

I created a repository on GitHub gemini-playground that contains all samples described above with the exception of the .env file and the API key to access the Gemini REST API. Feel free to give it a star and fork it for your own purpose.

Georestricted access to API of Gemini AI

Unfortunately, if you are residing in a country that has no access to the API  endpoints of Gemini AI you will get an HTTP 400 response like the following one.

Lastly, a story about a magic backpack

Here's the response I was provided by Gemini API.

Once upon a time, in a bustling town by the forest's edge, lived a young boy named Alex. Alex was an inquisitive and adventurous child who loved exploring the woods and playing with his friends. However, he had a secret desire that no one knew about—he craved magic and adventure.

One morning, as Alex wandered through the forest on his way to school, he stumbled upon a hidden glade. Fascinated by the serene atmosphere, he ventured deeper, following a trail of glowing fireflies. In the heart of the glade, beneath an ancient oak tree, lay a worn-out backpack. Curiosity compelling him, Alex reached out and touched it.

As soon as his fingers brushed against the bag, it sprung to life. The backpack shimmered with brilliant colors, its straps adjusting perfectly to Alex's shoulders as if it was made just for him. With a growing sense of excitement, Alex opened the bag's main compartment and discovered a swirling vortex of colors.

The vortex seemed to call to Alex, inviting him to step inside. Hesitating for a moment, he realized this was the magic and adventure he had always yearned for. With newfound courage, he took a deep breath and stepped through the portal, disappearing into the vibrant void.

The world inside the backpack was nothing like Alex had ever imagined. It was an expansive realm filled with floating islands, luminous waterfalls, and ethereal creatures. Every corner held a new discovery, from talking animals to enchanted artifacts.

Alex spent countless hours exploring this magical realm, making friends with the creatures and unraveling its mysteries. He learned the art of flying, telekinesis, and even conjuring illusions. Along his journey, he met a wise old wizard who became his mentor, teaching him valuable lessons about magic and responsibility.

As Alex grew wiser and more skilled, he realized that the backpack's magic was not without its consequences. With every spell he cast, a faint shimmer of darkness would appear on the bag's surface. He soon understood that the backpack had a life of its own, and its power could be both a blessing and a curse.

Determined to make the most of his time in the magical realm, Alex embarked on a quest to find the legendary "Heart of Magic," an artifact said to hold the power to restore balance and harmony to the backpack's magic. Along the way, he faced challenges, encountered dangerous creatures, and forged alliances with unlikely companions.

When Alex finally found the Heart of Magic, he was given the choice to either return home to his old life or remain in the magical realm forever. With a heavy heart, he made the difficult decision to say goodbye to his friends and the world he had come to love.

Stepping back through the vortex in the backpack, Alex found himself back in the forest glade, the backpack now nothing more than an ordinary worn-out bag. He carried it with him, cherishing the memories of his magical journey, knowing that he had grown and learned valuable lessons about friendship, magic, and the choices that shape one's destiny.

New year, new activities. It's still January and I'm already on tour. I was heading to the Developer Creators and Online Communities Summit - #GoogleDCOC - in Singapore. It's a global hybrid event - meaning in-person and online. The purpose is to bring together content creators and online community managers in the developer space from all around the world.

Why attending in-person?

I'm excited about this summit for various reasons. First and foremost, apart from blogging since over a decade I'm diving more and more into other ways of content creation. Already back in 2020, we recorded the whole Virtual Developers Conference in Mauritius - 4 tracks over 3 days, more than 100 hours of technical presentations - then post-processed everything and re-published every single session on its own. Everything available on YouTube. That conference alone has over 90 videos in its playlist.

Additionally, I started recording talks happening during our monthly MSCC meetings. Most of them still need processing but are coming to the YouTube channel soon. Pinky promise!

And not to forget: Podcasts!‌‌

Although the concept and "launch" of the Talks on Software Craftsmanship has been around since 2020 as announced at the end of the Virtual Developers Conference it didn't take off yet. Unfortunately, for various reasons which are mainly down to the procrastination of the host(s). Which is another pinky promise: Reviving, eh really launching, this podcast.

And what's a good motivator for that? Yes, you're right, podcasting. So, recently my friend and long-time community supporter Loic Forget took the lead in realising the podcast "Mau Pas Konpran!?" (published on Open Spotify). Together with Ish Sookun we are sitting together for a semi-technical, monthly recording session. The fun part here is that each episode is held in typical Mauritian style. We are conversing about local topics in at least three languages - Kreol Morisien, English, and a little bit of French or German. For me, that's a great learning experience on multiple levels.

Attending the summit I was highly interested in networking with other creators and to learn from their experiences. Which equipment to consider and which software applications are recommended for processing. Tips & tricks publishing on YouTube and how to improve the experience for viewers.

Second reason is the destination, Singapore. It's going to be my second trip to Asia after speaking at the C# Corner Conference 2017 in India. I have watched a number of documentaries about the city country during the past years, and the broadcast of the Formula 1 race is one of the highlights in my "sports calendar". Combining my attendance at the DCOC summit with the ability to explore the city of Singapore during two spare days, Wednesday and Saturday, sounded like an opportunity not to miss.

But hang on... JoKi, I thought you'd be a software crafter. How does this relate to your in-person attendance?‌‌In my case this might be the answer: "Online community managers: manage online tech communities on Discord, Telegram, Slack or other platforms (1000+ members/subscribers/followers)." - I founded and I'm still co-managing the two largest communities in Mauritius, namely Mauritius Software Craftsmanship Community (MSCC) and GDG Mauritius with a combined total count of over 4,000 members. With social media presence on X/Twitter, Facebook, and LinkedIn reaching almost 9,000 people. Even our YouTube channel has close to 400 subscribers.

So, why attending in-person? The direct interaction with other peers is priceless. Getting into a conversation with other attendees is so much easier than in online sessions (with chats). The learning factor from others' experience is magnitudes higher, more relatable and up close personal. Similar to our regular user group meetings.

Travelling to and fro, and how

Similar to previous trips I decided to travel light again, despite being out of the country for the six days. A small carry-on trolley for a bare minimum of clothes topped up with my daily backpack containing all kind of equipment.

The focus was on everything using a single connector, USB-C. Hence I assembled the following equipment to bring along.

• Lenovo Chromebook (USB-C charging)
• Google Pixel 6a (USB-C charging)
• Google Buds Pro (ANC and USB-C charging)
• Valco VMK20 (ANC and USB-C charging)
• 10,000 mAh battery power pack (USB-C charging)
• Hama 60W multi-plug USB-C charger (4 outlets)
• Cables. Lots of cables. USB cables, an HDMI cable, and a network cable. Let's see whether I get to hack that SmartTV at the hotel. 🤣

Regular readers might have had a good idea already.

At a certain stage I was even considering to leave any laptop at home. But then, why would you go to a Google Summit without a laptop, especially without a Chromebook? For one of the workshops it was communicated upfront that you have to have a laptop with you. So there we go. Unfortunately, I didn't pack my lavalier microphone which would have been very handy for some ad hoc on the spot recordings / live broadcast from the summit or from Singapore.

The choice of airline was easier for this trip. Although there are direct flights from Mauritius to Singapore, operated by Air Mauritius, there are a limited number of flights per week only. Such a flight would take roughly eight hours but the available options didn't fit well with the agenda scheduled. In consequence, I looked at the multiple flights per day on Emirates. and booked the round-trip taking into account that it took twice the time including a short stop-over in Dubai. Surprisingly, the price difference between those two choices is marginal. The flexibility advantage is impressive and actually I'm fewer days out of office than otherwise. Who'd expected that?

Speaking of expectations, Singapore requires all foreign travellers to submit the SG Arrival Card (SGAC) before arriving. There are two options to complete that requirement. Either you use their SGAC e-Service online or you install their MyICA Mobile application. I went for the later and it was done after a few clicks here and there, and uploading a scan of my passport. The SGAC is equivalent to the All-in-One Health Form when someone travels to Mauritius.

Touchdown Singapore

After the welcoming stop-over at the Emirates Business Lounge at the Dubai airport I arrived a little bit ahead of time in Singapore. And wow, what a difference the airport is.

Changi Airport and public transport

I've been to a few airports around the world so far and Changi is by far the most impressive one. Think of an airport inside a huge shopping mall and entertainment facility and you might get an idea about it. This thing is huge! Did I mention that free WiFi is offered everywhere?

Next task was to purchase one of those NFC cards for public transport. To my understanding there are at least two possibilities - ezLink and SimpleGo. I spent like $S 10 for the ezLink card which came pre-loaded with a balance of $S 5 to ride the MRT lines and busses.

As for mobile data it was even easier. Ahead of my trip I purchased a SingTel Tourist eSIM for their 5G network online. Then you install their hi!App and you can register/activate the eSIM card in your mobile after you have connection with their network. A few identification steps and confirmation emails later I was able to use their 5G data network instantly. Checkout the speed rates.

Another positive surprise was the automated immigration and passport stations. Armored with your passport, the SGAC code received and yourself you have everything to get through. For me, it was as smooth as the automated passport stations at German airports. Maybe even smoother...

Next, I went straight to the MRT station at Changi airport to catch a ride into the city. To get around I installed the MyTransport.SG mobile application which provides the network layout of the different MRT lines and the bus lines with all stations. Alternatively, Google Maps works just fine, too. Actually, I downloaded the map of Singapore for offline use. You know, just in case I might get lost without data network, etc.

Chinatown and staying at a capsule hotel

I boarded the MRT green line shortly after 22.00 hrs, and had to change to the Downtown (blue) line at Expo station before arriving at the DT 19 - Chinatown - station. Despite the late hour businesses and restaurants are still buzzing over there. Glad I chose this suburb to stay the first night. At least, I knew there would be various options to have a tasty dinner, and opportunities to shop anything I might have forgotten to bring along.

The capsule hotel I booked was within 5 minutes walking distance from the station exit Pagoda Street, and following the directions on Google Maps got me there easily. A quick scan of my passport at their automated check-in kiosk checked me in, and I received the key card in exchange. Again, really smooth and user-friendly processing. Here are a few impressions.

With the key card you get access to the different levels and amenities of the hotel. I reached my sleeping capsule, dropped of the luggage in the designated, key card secured locker storage, and then went on tour in Chinatown for dinner. I wasn't sure how long restaurants would be open but thought that probably midnight might be a closing time anywhere. In short distance across the hotel I found a place with yummy-looking dishes and I decided to give it shot. I mean, what could possible go wrong? BTW, the ratings on Google Maps for that joint are positive and their range of dishes offered is wide.

Around 1:30 hrs in the morning I finally went to sleep in my capsule. Well fed, cleaned up after having had a shower in the common washroom area of the hotel, and tired from the long trip.

Day 1

Exploration time!

First day in Singapore had no fixed agenda and it gave me the opportunity to explore the city freely. After a few hours of rest and the generous offer by the capsule hotel to store my luggage beyond the checkout I asked them for a few must-visit places in town.

Exploring Chinatown

As I spent the night in Chinatown what's more obvious than to discover the suburban during the morning hours? A quick check on Google Maps that the famous Buddha Tooth Relic Temple is literally just around the corner. By the time I got there prayers were still in full swing and it has an enlightening experience to stay for a while

Down that same road I went to visit the Sri Mariamman Temple and there also had been prayers. Taking into consideration that Thaipoosam Cavadee was on Thursday I assumed devotees would be at the temple for prayers. Although I went back through Pagoda Street towards the colonial street shops I only saw the Jamae (Chulia) Mosque from a short distance but didn't go there. I was reminded of Mauritius with those three places in close, peaceful coexistence.

The Bay area

Closing the loop through Chinatown I went back to the TE 18 - Maxwell - station of the MRT and headed to the line's final destination in the south east: TE 22 - Gardens by the Bay. The weather was holding and so I first went to the Marina Barrage to get a view of the barrage bridge and dam, and the many ships out on the sea. The barrage building itself is super interesting as there are several slopes that allow you to walk on the top of it.

Despite the light rain, yeah I brought a lightweight rain jacket with me, I then ventured to the Gardens by the Bay. Coming from the south I first visited the Kingfisher Lake with its small waterfalls and statues. Passing the Water Lily Pond and Sun Pavilion I headed straight to the Floral Clock. From there I got tickets for the Cloud Forest and the Flower Dome.

The Cloud Forest with its indoor waterfall and six levels of nature exploration is impressive and amazing to visit.

There are different sections of floral diversity which the Flower Dome has to offer. I enjoyed the smells, the tranquility in certain areas, and the massive educational factor across the dome. One could easily spend the whole day there.

As lunch time started to close in, I went along the Dragonfly Lake towards the Bayfront Ave and ended up in The Shoppes at Marina Sands Bay. That's like shopping heaven on Earth :)

To wrap up the tour I took the Downtown line from DT 16 - Bayfront - back to Chinatown. Stopped by at the capsule hotel to charge my mobile a bit, chatted with the family back home in Mauritius, and then grabbed my luggage to move to the booked hotel by Google. This time I caught a bus and got off the station right in front of IKEA Alexandra. Our hotel - Momentus Hotel Alexandra - is next to it.

After all the walking and discoveries during the morning and midday hours I was a bit exhausted and therefore relieved to stretch out on the bed to rest. The little time left until the official Welcome Reception next to the pool I used to review the tons of pictures I had taken, chatted a bit more with my wife and the kids, and had a refreshing shower.

Welcome reception

Our organising team from Google invited us to an informal welcome/reception dinner at the Momentus Hotel to gently kick off the summit. After a brief exchange with Dirk Primbs - asking him about getting accustomed in Canada - I took an empty chair at one of the tables and joined a group of developer creators from Hanoi, Vietnam: Huy Dang, Dang Dong, and Nguyen Hai-Truong. It was interesting to learn more about their activities and how they organise events. Thanks for the pin and stickers!

Shortly after I spotted Yesaya Athuman who I missed talking to at DevFest Dar es Salaam. I went over to him joining others standing and chatting about all kind of community stuff. There I got introduced to Dariusz Kalbarczyk, organiser of ngPolandConf, and we exchanged a bit about our common friend Dhananjay Kumar, organiser of ngIndia. By chance we were also joined by Mazlum Tosun whose YouTube videos fascinate me as he creates Google Cloud content in French and English language, and promotes them equally. We instantly spoke about common friends in the community like Ezekias Bokove, Louis Japheth Kouassi, and Guillaume Blaquiere. While having dinner fellow creator and book author Muhammed Ahsan Ayaz spent some time and interesting stories with us.

With the evening progressing and having had dinner from the buffet you could observe the forming of multiple groups based on either geographical vicinity or established connections on Discord. It always amazes me how easy it is to connect with other during such in-person gatherings. Together with Yesaya, I then sat down with Daisy Auma and Ezinne Osuamadi to learn more about their professional whereabouts and community involvements. It was actually fascinating to learn that Daisy moved from Kenya to the UK, whereas Ezinne is from Nigeria and working in Germany since a few years.

The world is such a small village after all.

During the evening I got to meet other participants from Turkmenistan, Kazakhstan, Uzbekistan, Mongolia, France, Italy, India, Bangladesh, Indonesia, and many more countries. Each single one with fascinating stories of content creation and community engagements. Very inspiring actually!

Day 2

Finally the day has arrived! The summit is happening officially. A shuttle bus took us the short distance from the hotel to the Mapletree Business City where Google Singapore has its office.

DCOC Summit

An empty stomach isn't capable to study. Hence breakfast buffet had been offered by Google. A number of conversations from last night were reignited and new conversations came to life. Big Hello's and cheers everywhere around; this summit was so inclusive and welcoming.

Our two Masters of Ceremony Alicja Heisig-Chiarello and Dirk Primbs launched the Summit officially and also welcomed everyone on the live stream. Meanwhile our two radio / live streaming moderators Nathalie Pereira and Alfredo Morresi had started already. Oh yes, amazingly the whole summit was a hybrid event with in-person and online participation.

BTW, here's the agenda: https://rsvp.withgoogle.com/events/developer-creators-and-online-communities-summit/agenda

Next up Janise Tan welcomed us to Singapore and the SEA developer community landscape giving us some details about the region, its numbers regarding to communities and activities. Fun fact, while introducing Singapore to the audience she highlighted some of the key factors of the city's success which miraculously match the secret ingredients being a successful content creator online or running thriving communities.

True to the nature of a hybrid summit, we then watched the Creator keynote as a remote session with Stephanie Wong. After the Google Cloud Tech X/Twitter Space in April last year about How to make the most of Innovators Plus subscription I was eager to meet Stephanie IRL. Hmm, didn't happen this time...

Her talk gave some good insights based on her long-year experience as a successful content creator. Building and telling a concise story is one of those golden aspects to take into consideration.

Got an idea how Home Assistant started? Well, I didn't know until watching the Online communities keynote by Paulus Schoutsen who started one of the largest open-source projects on GitHub based on the basic need to / problem of improving home automation. The main takeaway for me was to create and nourish a culture of inclusive, friendly, and safe online community with gender-neutral terms.

The following panel shared more tips on being successful creating content as well as entertaining a healthy community. Very helpful information has been shared by Stephanie and Paulus.

After the well-deserved morning break that allowed us to reflect and network we got an Intro to Gemini, presented by Dirk Primbs.

During the past decade there had been major breakthroughs in the field of Artificial Intelligence (AI). And although these days most people might talk about AI in the context of conversational bots or generative content creation there have been more highlights, i.e. in research & development sector, in the medical sector, and others. One should also understand that Machine Learning (ML) and Artificial Intelligence go way further back into the past than a decade but it's the magnitude of advancements that has happened recently only thanks to broader access to information and more capable computing power thanks to hyper-scaling data centres.

Breakout sessions I attended

Choosing a session was tough because all breakouts covered interesting topics. Here are the ones I found most attractive:

• Tips on creating a winning content strategy for your YouTube channel
  Ever wondered how YouTube handles recommendations? Tra Nguyen gave us a few insights and tips:
  ✅ Know your audience's needs and adapt accordingly
  ✅ Focus on your audience and the algorithm will follow
  ✅ Keep experimenting!
• The Simple Superpowers of Mozilla Hubs Part 1: Unleashing Innovation Through Community
  I was intrigued about a Mozilla session at a Google event, and had never heard about Hubs before. It's a private, virtual 3D world with endless possibilities of collaboration, according to Michael Morran. I'm wondering whether this could be a feature for the Developers Conference 2024 in Mauritius.
• Mastering Personalized Bot Build: A Discord App-building Workshop
  With just a few lines of code you can create your own bot(s) for Discord. Dirk Primbs explained to us that bots are literally treated as a Discord user account with permissions granted to react to certain events. The actual functionality of such a bot is down to your imagination.
• Podcasting on YouTube
  Following the sunsetting of Google Podcasts I wanted to know what's next. Thankfully Russell Yap had the right content for my curiousity. However with their move to YouTube Podcasts and YouTube Music I'm not thrilled at all, given that both services are not available in Mauritius. Plus, it requires Premium subscription to enable background play.

Whew, people, I was exhausted after that whole day of high-value information. Lots of new impulses and aspects to reflect on. The complete (raw) recording is accessible here: Radio studio pre-show. Most likely post-processing might is going to chop the stream into individual sessions (soon).

Lastly, our wonderful masters of ceremony Alicja and Dirk wrapped up the day with their closing remarks, informing us about the obligatory group photo, and how we are going to spent the evening together having dinner.

Networking dinner

Remaining in the same office building we went upstairs to the 30th floor. There you have an amazing over Singapore. Can't remember how many panorama shots I took but I must have been in each single corner of the building.

Over dinner more networking and conversations happened. This time I buddied with fellow creators Alex Patterson who runs CodingCat.dev and Jai Campbell who's a Cloud Architect from the UK. Most interestingly we talked mainly about Singapore, discontinued food products and healthy nutrition, and about a variety of documentaries broadcasted on Netflix.

IKEA

Back at the hotel I "had to go" to IKEA, of course. Not because of me but rather due to the shopping list of my beloved wife. Given the dimensions of my carry-on luggage I could purchase a few smaller, lighter items only. The most important, pressing ones so to speak.

More Networking

Back at the hotel I didn't even bother to go upstairs to the room but stayed right away down in the lobby joining Karen Hsieh, Liang-Bin Hsueh, and a local friend of his. We kind of picked up the conversation(s) from earlier today. It was interesting to learn more about Taiwan, Mandarin language, and Chinese/Asian culture. Likewise they were open to learn more about Mauritius.

Meanwhile Muhammed Ahsan Ayaz reached out to me asking where I would be around. I suggested to him to join us down in the hotel lobby. Already last week Ahsan posted in our DCOC summit channel on Discord and kindly offered physical copies of his updated, second edition book Angular Cookbook. I'm really happy about this addition to our community's book library.

Funnily, he was a bit surprised when I asked him to have the book signed by him. "That's the first time someone is asking for a signature!" - I'm grateful for this. How often do you have a chance to meet a book author in person?

Another summit fellow, Robert Theo from Indonesia, also got a signed copy and he then joined our little group for more networking fun. From there on we spoke a lot about Indonesia, Taiwan, Mauritius, food and cultural aspects, and so forth. Time was flying.

Day 3

That night I managed to catch a few more Zzzz's, and like the previous morning we took the provided shuttle to get to Google Singapore. Rinse and repeat, one might think. Absolutely not, today was community day!

DCOC Summit

Following yesterday's sessions mainly provided by Googlers and partners, the content for today was sourced from the community itself. A total of nine creators offered their knowledge and expertise. Plus, the various time slots in the podcast studio. Our fantastic masters of ceremony - Alicja and Nathalie - launched the day with a brief overview of what to expect and introduced the speakers. Each presenter had an opportunity to pitch their content in front of the audience. Another tough decision process to choose three out of nine.

Breakout sessions I attended

• Making a Mark on YouTube and Google: My Story
  First-hand shared experience always attracts my interest, and so I went to Abu Anwar MD Abdullah talk on the origins of The Flutter Way. It's kind of amazing how he started and is now entertaining the second most followed YouTube channel in the Flutter space globally.
• Podcast 101 - Dos and Don'ts
  Starting a podcast is easy and success follows instantly? Nope, think again. Being a co-host on the Mau Pas Konpran!? podcast and having a dangling Talks on Software Craftsmanship show I needed to know more. Thankfully Stefano Le Pera shared all the up's and down's of the ChatGDG podcast. A lot of what he mentioned resonated with my own experience. Time to get recording again...
• Generative AI for Visual Content Creation
  Are you concerned that AI might render your job position redundant? How about leveraging Generative AI to improve your skills and be more successful? Margaret Maynard-Reid, a ML Engineer / 3D Fashion Designer, gave us an overview of available types of Generative AI, and how she's benefiting from them in her daily work. Very useful content for my own needs.

During lunch break I seized the opportunity to hang out with numerous participants. Among those are Sathish VJ, Madona Wambua, Neïl Rahmouni, Cyrus Wong Chun Yin and Kuan Hoong Poo whom I follow on social media since a while already. Another fellow creator from the Sub-Saharan Africa region, Amani Bisimwa, had arrived at the summit. It was a great time to network again.

And like the previous day, the recording is available here: Welcome to Day 3 and introduction to community-driven sessions

Gardens by the Bay and Spectra - At night!

I knew about the light show at the Gardens by the Bay and I had planned to go there tonight. So, it was a delight for me that Arianna Capizzi of ChatGDG announced that there would be a group of people heading to the same destination. Awesome let's do it!

If I recall correctly, we were roughly twelve to thirteen people - the Dirty Dozen figuratively speaking - that met down at the lobby of the hotel and hauled a few Grab drivers to get to the Gardens. It was definitely quicker and more comfortable than using public transport and while sharing the cost also not so expensive after all.

With a selection of songs from various world-known musicals we enjoyed the light spectacle right in front of the Supertree Observatory and under the Skywalk. It was enchanting to say at least, highly recommended. Meanwhile I animated Lisa Carpenter to re-activate her account on Ingress and join me playing. We gladly explained to Monika Janota the purpose and the mechanics of the game. There is a crazy amount of portals all over Singapore.

As the hunger kicked in slowly but surely we decided to head over to the hawker centre in the Marina Sands Bay. Taking the Marina Bay Overpass we crossed the Dragonfly Lake and went straight into The Shoppes at Marina Sands Bay. Down the escalators and then the long straight to the food court.

Finding enough seats for such a big group at this time seems very challenging. And so unfortunately we had to split into smaller units, chope'd our places and went off exploring the different stalls sourcing for food. There is an incredible variety of dishes available.

After we concluded our culinary adventures we headed to the Waterfront Promenade and attended the Spectra - A Light & Water Show. What a joy for eyes and ears.

Later on we strolled down the Waterfront Promenade fully indulged in conversations of all kind of sorts, and marvelled together at the night skyline of Singapore. With all the talking we needed some drinks and therefore stopped by one the pubs in the surrounding. Before returning back to the hotel, we managed to visit Lau Pa Sat, the "old market" and first hawker centre in Singapore.

What a remarkable day full of sharing community experience, learning, exchanging, networking, conversing, dining, and fun it was.

Day 4

Exploration time, again!

As my flight back home was scheduled for the evening, I decided to spend my last day in Singapore (for now) in Chinatown, again. Like previously, I checked out of the hotel first thing in the morning but also asked the concierge desk to store my luggage until the afternoon.

Shop until you drop: Chinese New Year (CNY)

Starting at the People's Park Complex mall I explored the street market in Chinatown, went to the Chinatown Complex, then back to Pagoda Street where I found a nice place to have lunch. As I was looking for something specific I went across the overpass back into the People's Park Centre discovering all kind of items at the Night Bazaar. And after checking out all levels inside Chinatown Point mall I was finally done.

Unsurprisingly I had to buy another backpack (50l volume) to fit in all the items purchased. Given this half-day shopping spree I am not so sure about organising a (one week) vacation with the family here in Singapore is such a good idea. Especially around the time of Chinese New Year. Just kidding!

See you soon!

Reflecting over those past few days in Singapore while writing this blog recalled numerous conversations I had with other participants. I was excited meeting my community friends from the SSA region, finally being able to associate a face and person to the countless peers from the Google Developer Community Discord server, and massively enjoying the amount of new contacts made. Hooray to LinkedIn's QR Code feature which smoothlessly allowed all us to foster that new acquaintance on social media.

I don't know about others, but looking at my photos collection I have close to 600 pictures taken. Singapore by day, Singapore by night, during the presentations at the Summit, and a couple of selfies with like-minded community folks. For the next few weeks I'm going to sieve through everything recorded and noted down, going to deepen those newly established connections, and looking forward to apply other creator's experience to my content creation process. Whether it will be more blog articles or fresh podcast episodes.

To each and every one I met during the DCOC Summit:
You're incredible and thank you for spending some time with me. I appreciate you. 🫶

For now it's Goodbye community, goodbye Singapore, see you soon.

Shout out to the organising team

My heartfelt thanks go to Dirk Primbs, Alicja Heisig-Chiarello, Alessandro Palmieri, Monika Janota, Alfredo Morresi, Nathalie Pereira and the rest of the team at Google for organising such an amazing summit and bringing Developer Creators and organisers of Online Communities world-wide together in one place.

Thank You!

What a remarkable, first Developer Creators and Online Communities Summit it was. Well done!

Uganda - a new destination to explore. My first time travelling to Uganda and it is for speaking at DevFest Jinja. Following the conversations with Francis Akol we arranged and got it approved that I would be able to travel as Google Developer Expert (GDE). A first for GDG Jinja.

During several past occasions I met Francis, Fiona Nangobi (WTM ambassador in Jinja), and other community members from Uganda. Meaning, taking the trip to Jinja wouldn't be an adventure into the complete unknown but a welcoming experience with friends.

In preparation I had the East Africa(n) Tourist Visa (EATV) in my passport which would fast-track me at the immigration officer, or at least that's what I thought would be the case; more on that below, I found valuable resources online which described where the ATMs would be located in the airport, and where to purchase a Ugandan SIM card. I chose Airtel due to recommendations regarding network coverage and quality.

Like for my trip to Dar es Salaam two weeks ago, I decided to fly one or two earlier so that there be a chance for a bit of sightseeing. However this meant to be at the airport in the middle of the night, around 2:00 hrs in the morning catching the flight at 4:00 hrs then. As usual, the trip involved a stopover of approximately seven hours in Nairobi. While waiting in the Pride of Africa lounge I also seized the opportunity to clear a few issues I was facing with Asante Rewards, the frequent flyer loyalty program by Kenya Airways.

To enter, or Not to enter

that is the question:
Whether 'tis nobler in the mind to suffer
The slings and arrows of outrageous fortune,
Or to take Arms against a Sea of troubles,
...

It was not as dramatic as the opening speech of Prince Hamlet, however it was challenging nevertheless. Already back in Mauritius I was questioned about whether I had a VISA to enter Uganda, and again in Nairobi prior to boarding, I was quite surprised when I was told by the immigration officer that the EATV has expired. Hmm, hang on, I applied for it beginning of October and it's valid for 90 days, given multiple entry in either Rwanda, Kenya, or Uganda - so I thought.

Well, there is an important detail which can be overseen quite easily or misunderstood as in my case.

The visa is valid for 90 days and is not renewable upon expiry or upon exit from the block (Kenya, Uganda, Rwanda).

The East Africa Tourist Visa (EATV) is an agreement between those three mentioned countries to ease transits between them for the given period. However the visa itself is single entry coming from any other country and (!) it expires as soon as you exit the defined realm.

Ouch!
I totally didn't see that back in October and it wasn't mentioned by the immigration officer in Kigali, Rwanda. Either way it was my fault or at least responsibility. With all the forth and back between immigration officer at the counter, direct supervisor, moving to the immigration offices at the back, and then speaking to the head supervisor about the situation, it crossed my mind that this could be a potential episode of Border Security.

This is Africa, and there is always a way. Given my passport of European origin I was offered to apply for a new visa on arrival. Which I gratefully accepted. I mean paying USD $50 for my misunderstanding, read: the visa to enter Uganda, is a fair deal after all. Definitely better than sitting on the next plane back home.

Let the real adventure begin

After withdrawing some cash from one of the ATM and purchasing the Airtel SIM card I was ready for my first experience in Uganda. And what better to receive a hearty welcome by GDG fellow Asa Lugada and his friend Arnold. My connection to Asa even goes back to my first participation in the Andela-led ALC program, later GADS program. And of course the SSA Community Summit 2018.

Some days earlier we discussed details about the airport transfer to the guest house I'm staying in Jinja. Of course, I could have a booked a taxi or an arrangement with the guest house but this premium community service was by far the better option.

From Entebbe to Jinja is roughly 130km to drive. So we stopped at the Victoria Mall in Entebbe, got ourselves some snacks and refreshments, and off we went...

Giving or taking it took us approximately five hours to the guesthouse in Jinja. Thanks to Google Maps we managed to find the place straight away. After check-in and inspection of the room we headed to a nearby Indian-Asian restaurant and we treated ourselves with some tasty delights. Later on I could finally enjoy a well-deserved shower and rest in bed. It was an exciting but also tiring day of travelling.

Source of the Nile

Arriving at least a day in advance has some advantages than just being there for the DevFest. I've seen this already with GDEs that came to speak at DevFest Mauritius, and I've done it travelling to DevFest Dar es Salaam previously.

Francis suggested to meet first at my place, so that Marvin and Cynthia could deposit their stuff in my room, then a quick check of the venue and then seeing what we could do for the rest of the day. Weeks ago I mentioned that I would like to explore the source of the Nile which isn't too far from my local guesthouse anyways.

It was an amazing excursion and learning that ashes of the late Mahatma Gandhi have been spread out here at source was an interesting note.

I had a great day, good company and delicious food. Highly recommended!

DevFest Jinja

After getting some hours of sleep the big day had finally arrived. I enjoyed a nice local breakfast - called Rolex - and then called for a boda to get to The Innovation Village for DevFest Jinja.

It was clearly way too early when I arrived at the venue. But well, better too early than too late, and therefore I took some time to talk to other GDG organisers, spoke to Fiona Nangobi, and was chit-chatting with Marvin and Cynthia about yesterday's excursion and other highlights.

More and more people arrived and so Francis kicked off DevFest Jinja with a respectable crowd. A few minutes in the reception and registration area was swarmed with WTM ladies, already in their gowns for the dinner arrangement later that day. It was an amazing display of vibrant colours, great happiness and big smiles on the faces of all attendees.

I was scheduled with two sessions. During the first half of the day, I spoke about the benefits of .NET and how implementations in C# as well as ASP.NET can be developed swiftly and deployed easily to various services offered by Google Cloud Platform. There were numerous questions about use cases of C# and how the available Google APIs can be accessed via NuGet packages.

In the afternoon session I talked about the importance and advantages of professional certifications, in particular given the survey results that Google Cloud certifications are ranked among the highest paid ones. Build up your expertise and prove to yourself and others that you know your subject and that you are a knowledgable Google Cloud engineer. Those certification can open doors to higher payment on the job, better job offers and potentially a chance to work remotely with companies abroad.

It was informative listening to the talks by other speakers. Feel free to check out the full agenda of DevFest Jinja to see what you eventually missed.

With all those lovely people around, all the ongoing conversations and networking chats I somehow didn't realize that I had an exchange Zirabamuzale Rawaha aka RumzTech, organiser of GDG Luwero, with whom I did several remote sessions as part of the Road to Google Developers Certification earlier this year. Mea culpa, Rawaha!

Ever tasted Nsenene?

Purely by chance Asa and I were standing outside on the pavement trying to get a bit of fresh air and having an interesting conversation when this guy with an orange bucket walked pass us. As I wasn't sure whether I saw correctly I asked Asa about the content of the bucket. "Ohh, you gotta taste this. Would you like to try?"

Yes, of course! Let's snack a handful roasted crickets - called nsenene in Luganda - with small chopped white onions. This species is a delicacy in central and south-western Uganda. That's what I'm looking for while travelling other countries. Experiencing new flavours, new delicacies and new smells. And actually, those crickets are yummy. If you have a chance to taste... do it. You might be surprised.

On my way back home

Unfortunately, trips to speak at DevFest events are quite short, and so it was already time to say good bye. Thankfully Asa and Arnold offered to provide transfer to the airport, and we had to start quite early in the morning already. Shortly before driving through the Mabira Central Forest Reserve we were greeted by a massive weather spectacle with mesmerizing lightnings and roaring thunders. Whew, the streets turned into small streams and here and there we were joking about paddling in a kayak rather than driving in the car. We made it well ahead of departure time, and even managed to stop at the Victoria Mall again to have some breakfast with tea.

Another surprise was caused by Kenya Airways after we had landed in Nairobi. The scheduled flight to Mauritius had been delayed by another one and half hour so. Other travellers I met in the lounge were less lucky and were stranded for over twelve hours already. Eagerly hoping to continue their journeys.

Shout out to GDG Jinja and WTM Jinja

Congratulations to such a wonderful DevFest. Thank you so much for the warm welcome, the overwhelming care-taking and the joy I have experienced during those few days in Uganda. I'm really happy about the new impressions and experiences made.

Personal thanks to Francis Akol, Asa Lugada and Fiona Nangobi! Keep shining all of you!

Photo credits: Shared album on Google Photos by GDG Jinja.

I don't understand!? - In our latest episode we - Loic, Ish and I - sat together and talked about the situation, possible reasons, and considerations regarding the emigration of Mauritians towards other countries and the potential impact on the society here on the island.

The so-called "brain drain" is happening since years and it kind of amazes me to see that people are looking for their chances and luck abroad when there are opportunities available in the country.

"The Grass is always greener on the other side."

This proverb has the general understanding that life at other places is better than the current situation you are in. However this might be a superficial observation and there are other constraints playing into that, too.

Personally, I did the reverse. Meaning, I immigrated to Mauritius almost 17 years ago; initially as an expat on an Occupation Permit. And I have to admit that reaching certain goals and achievements would not have been possible back in Germany. Maybe possible but might have required much more effort, more time and more personal involvement. Who knows...

Please, check out episode #2 of the Mau Pas Konpran podcast and let us know your thoughts on this particular topic. Maybe share your own experience in case you have moved away from your home country, and how you see it nowadays.

Thanks for reading and hopefully listening.

Joyeuses fêtes et BananE!

PS: We are considering to publish the podcast on Apple platform.

After speaking at DevFest Nairobi in 2022 (including a spontaneous keynote on Google Cloud) I got inspired to be more active and hopefully present in other potential locations across the Sub-Saharan Africa region. And if I'm not completely wrong I also had an exchange with Georgia Rwechungura during the SSA Community Summit 2022 regarding the idea of coming to Tanzania, or more precisely to come to GDG Dar es Salaam and speaking at their DevFest.

With an improving health and running a few workshops - in-house and remote - earlier this year I was getting more and more eager as well as excited about the idea to speak at other DevFest events than Mauritius. All went well at DevFest Kigali a few weeks earlier and so nothing could possibly stop me from going to Tanzania.

Getting there and back?

Unfortunately, there are not many connections between Mauritius and African countries, or at least there could and should be many more than there are at the moment. Without a direct flight I had a look at the available options for airlines, airports and the associated stopover times. Here are a few routes I checked out:

• Johannesburg, South Africa
• Nairobi, Kenya
• Antananarivo, Madagascar
• Dubai, UAE
• Mahe, Seychelles
• St. Denis, La Reunion

It's really weird to travel in a yo-yo pattern like this. Meaning, you have to fly further than the actual destination and then "come back". A direct flight from Mauritius to Dar es Salaam would probably take less than three hours. Given the current possibilities it takes way more than twice the time.

Anyway, I chose to go with Kenya Airways and having a night stopover in Nairobi. With access to their Pride of Africa lounge it wasn't too bad after all.

Choice of accommodation

Usually I try to find a hotel or guesthouse that's close to the DevFest venue and doesn't have the flair of a typical business trip. Thanks to Naamini Yonazi I knew that DevFest would most likely be somewhere on the campus of the University of Dar es Salaam which lies North of the airport and the city centre. Traffic might be dense during morning hours and the suggestions provided on the GDE trip planning platform were too far away and most of them not to my liking.

Based on the positive experience I had with stays booked through the booking.com app in Europe I gave it a try for Tanzania. For those few days, I searched for an appropriate place to stay that is less than 30 minutes away from DevFest. Thanks to the ratings, great pictures, and other attributes like cost I actually found a hotel right on the beach.

Surprisingly, it was also offered on the GDE trip planner but outside the suggested radius. With minor adjustments I got it as an option and was able to book without any issues. Winning!

Travel companion

Now, after seeing some pictures of the beach side, the pool, the rooms and the restaurants of the hotel my lovely BWE got very much interested in Tanzania. You might guess where this is heading to, don't you?

Following our wedding anniversary celebrations in September my BWE and I talked about the possibility to spend a long weekend together in Tanzania, and we decided that would be a pleasant experience.

Plus, Mary Jane already told me since a while that she would love to go there to check out tanzanite gemstones for a piece of jewelry she'd like to create.

Getting around in Dar

Planning to go to a new location, whether it's a new city, a new country, or both, involves checking out the options to get around. First problem to solve, how to get from the airport to the guesthouse and back, then how to go to and from the DevFest venue, and lastly how to explore other sights of importance while being there.

Organising a ride from the airport to the guesthouse was the easiest. Thanks to the wonderful assistance of Naamini I had nothing to do. She arranged everything by asking her trusted driver to come to the airport to fetch us, and then drop us off at the guesthouse. She literally needed my flight details and destination only. Massive help and easy-peasy.

During conversations at the reception desk it became pretty clear that either Uber or Bolt might be the best option to book rides. The recommendation was to use Bolt as it seems to be less expensive and more flexible than Uber. So we gave it a try the next day in order to get from the guesthouse to the venue of DevFest. BTW, we booked a car rather than a tuk-tuk (auto rickshaw).

Later on, we felt more comfortable and went all in, either using Bolt rides or bargaining with the tuk-tuk drivers at their stand to agree on a fair. It was really good fun to discover places like this.

Maasai Warriors

Already back at the guesthouse where we stayed but also throughout other places we noticed that there were Maasai warriors around. Some were there to do hotel services like bell boy, some did gardening, and others seemed to be security for single, female travellers. Maybe a reader from Tanzania could help me out here.

I found it really impressive!
Stupidly, I forgot to ask to take a picture with at least one of them. Oh well, probably next time then. However I got myself a Maasai Shuka. Only need to learn and practice how to wear it though.

The Venue: 孔子学院

Yup, that's the right place. Yes, I'm sure.

Honestly, I had no idea of what to expect when I saw the DevFest location first time. But hey,why not? It kind of makes sense that there is a Confucius Institute in Dar es Salaam, Tanzania. Given the importance of the port and international trade with China I seems quite helpful for students to have easy access to courses on Chinese language and culture. And while writing this blog I discovered there is a 孔子学院 in Mauritius, too. Who'd have known?

What's on the agenda of DevFest?

Lots of amazing topics and sessions have been assembled by the GDG chapter in Dar es Salaam. Check out the full agenda on Sessionize to get an overview. Also, there had been multiple tracks in parallel allowing more speakers to present and give attendees a choice following their interest.

Networking everywhere

We managed to arrive a bit earlier than the times suggested on the agenda. This gave us time to get to know the team of GDG Dar a little bit, and to mingle with other attendees to get to know a bit more about their passions and activities. BTW, in one the rooms was even breakfast served. How cool is that?

GDEs and a Googler

Oh yes, you read this right. GDG Dar es Salaam managed to invite Khadija Juma from Google. As she is based in Mombasa, Kenya it seemed an obvious opportunity and I was really happy to introduce Mary Jane to her.

As for GDEs, let me quickly list them in no particular order.

• Ezekias Bokove, GDE for Google Cloud
• Maye Edwin, GDE for Web Technologies
• Jochen Kirstätter, GDE for Google Cloud

The highlights of DevFest Dar were the ice-breaker game that was done at the beginning as well as the group photo outdoors.

The Confucius Institute is quite impressive and it was really good fun to spend the day with DevFest attendees.

Thanks to GDG Dar es Salaam

My heart-felt thanks go out to Naamini Yonazi, Georgia Rwechungura, the crew at GDG Dar es Salaam, and all WTM ambassadors involved in the preparation and organisation of DevFest Dar es Salaam. You are the real reason we had a wonderful time in Tanzania. Your early assistance and guidance helped us to feel welcome and at ease in Dar es Salaam.

Asante sana!

PS: We, Mary Jane and I, kind of already decided to visit Zanzibar during 2024, and we'd love to combine it with a future engagement with GDG Dar es Salaam, and who knows, maybe GDG Pwani in Kenya...

Photo credits: Shared album on Pixieset by Sam Gidori, GDG Dar es Salaam.