In the first part of this tutorial, we connected our mobile prototype to a Firebase database. This is a great practice, especially relevant if you plan to transition to coding with frameworks like React Native later on. However, this approach keeps us dependent on a pre-filled database.

Today, we are shifting into high gear. After 20 years in the IT industry, I am still fascinated by how easily we can now integrate artificial intelligence into an app with just a few clicks. We are going to replace our static database with the Google Gemini API to generate 100% custom quotes on the fly!

Foreword: This article, enhanced with improvements generated by AI (Google Gemini), is made available under the CC BY-ND 4.0

Step 1: Get the brain’s keys (Google AI Studio)

To talk to Gemini from our app, we need a pass: an API key.

• Go to Google AI Studio.
• Sign in with your Google account.
• In the left menu, click on Get API key and then on the Create API key button.

• Once the API key is created, click on it to display it.
• Copy this long string of characters and keep it safe (never share it publicly).
  

Step 2: Adapt MotivApp’s Design

Let’s pick up our Thunkable project where we left off. We are going to add some interactivity.

• On Screen1 (Home): Add a Text Input component right above the “Inspire me!” button. Change its Hint property to display: “Enter a theme (e.g., Sports, Coding…)”. Rename this component Input_Theme.
  

Step 3: Prompt Engineering with RISEN

This is the core of the reactor. To prevent the AI from rambling, we will structure our request (prompt) with the professional RISEN framework. Here is how we will constrain the gemini-2.5-flash model:

• R (Role): Act as an expert motivational life coach.
• I (Instruction): Write an original motivational quote based on the following theme: [Theme typed by the user].
• S (Steps): 1. Analyze the theme. 2. Find an inspiring angle. 3. Formulate the quote. 4. Attribute it to a fictional or real author.
• E (End Goal): The reader must feel an immediate urge to take action.
• N (Narrowing): The response MUST follow this strict format: ‘Quote - Author’. Do not exceed 20 words. Do not include any greetings.

Here is exactly the final text our app will assemble, replacing the end app variable with the theme chosen by the user:

Act as an expert motivational life coach. 
Write an original motivational quote based on the following theme: [USER'S THEME]. 
1. Analyze the theme. 2. Find an inspiring angle. 3. Formulate the quote. 4. Attribute it to a fictional or real author. 
The reader must feel an immediate urge to take action. 
The response MUST follow this strict format: 'Quote - Author'. Do not exceed 20 words. Do not include any greetings.

Step 4: Logic and Blocks

On Screen1

Blocks overview

Blocks sequence

Initialisation

• When Screen1 opens, empty the Input_Theme.
• When clicking on Btn_Inspire, we must check that the Text in the Input_Theme component is not empty before executing the next steps.

Building the API Request:

• Create a Web API component : on the left list, uncollapse “Advanced”, then click on [+] at the right side of “Web APIs”. This will replace Firebase to communicate with Google’s servers.

  • Rename it to Gemini.
  • Configure the API URL: set the field “URL” to https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent.
  • Configure your API key:
    • Set the field “Property” to key
    • Paste your API key in the field “Value”.
    • Click on [Add].
  • Setup the header:
    • Set the field “Property” to Content-Type
    • Set the field “Value” to application/json.
    • Click on [Add].
  • Click on [Done].

The Gemini API is very strict about the data format it receives. It expects a JSON object containing a contents list, which itself contains a parts list, which finally contains the text attribute with our prompt. In Thunkable, the easiest way to build this request body is to use a text block.

1. First, create an app variable named full_prompt and use a join block to stick the large RISEN text block (seen in step 3) with the Text in the Input_Theme component.
2. Grab another advanced join block (which allows pasting several pieces of text together).
3. In the first box, paste exactly this beginning of JSON code: {"contents": [{"parts": [{"text": "
4. In the second box, drag your full_prompt app variable.
5. In the third box, close the JSON code with: "}]}]}
6. Assign the whole thing to the set Web_API's Body to block.

Extracting the JSON response:

• Trigger the call with the call Gemini's Post block.
• The API replies with a large block of complex textual data (response).
• In the then do section, we will isolate the text we want by nesting several blocks, much like Russian dolls. We will assign this entire path to a new citation app variable.
• To fully understand this large red and blue block, read it from right to left (from the inside out):
  1. We turn the raw text into a manageable object: get object from JSON [response].
  2. We extract the candidates property.
  3. This is a list, so we grab the first item: in list [...] get # 1.
  4. We extract the content property.
  5. We extract the parts property.
  6. This is also a list, so we grab the first item: in list [...] get # 1.
  7. We finally extract the text property.
• Separating the quote from the author:
  1. Create an app liste_reponse app variable.
  2. Assign to it the make list from text block (in Lists), using our citation app variable, and type " - " in the delimiter box.
  3. Now that our data is clean and split, finish by dragging the Maps to Screen2 block.

On Screen2

1. Update Label_Quote by getting the first item of this list (in list get # 1 block).
2. Update Label_Author by getting the second item (in list get # 2 block).

Step 5: Try it out!

The moment of truth has arrived.

• Launch the app via Thunkable Live on your phone (or via the web preview).
• On the first screen, type a theme you care about in the text input (for example: “Stress management”, “Pushing your limits”, or “Learning to play guitar”).
• Tap Inspire me!.
• After a brief second (the time it takes for Google’s model to generate its response), you will automatically switch to the second screen.
• And there you have it! A unique, perfectly formatted quote tailored to your theme appears right before your eyes. You can just click “Go Back” to try with a new idea!

Conclusion

Congratulations! You have just created a mobile app capable of generating endless content using artificial intelligence. The limits of no-code are being pushed every day, and now is the perfect time to experiment.

Feel free to modify the RISEN prompt to create a recipe generator, a poem creator, or even an interactive quiz. The floor is yours!

Dans la première partie de ce tutoriel, nous avons connecté notre prototype mobile à une base de données Firebase. C’est une excellente pratique, particulièrement pertinente si vous envisagez de basculer plus tard sur du développement avec des frameworks comme React Native. Cependant, cette approche nous rend dépendants d’une base de données pré-remplie.

Aujourd’hui, on passe à la vitesse supérieure. Après 20 ans dans l’industrie des TI, je suis toujours fasciné par la façon dont on peut désormais intégrer de l’intelligence artificielle dans une application en quelques clics. Nous allons remplacer notre base statique par l’API de Google Gemini pour générer des citations 100% sur mesure, à la volée !

Avant-propos: Cet article, augmenté d’améliorations générées avec des IA (Google Gemini), est mis à disposition au travers de la license CC BY-ND 4.0

Étape 1 : Obtenir les clés du cerveau (Google AI Studio)

Pour parler à Gemini depuis notre application, il nous faut un laissez-passer : une clé d’API.

• Rendez-vous sur Google AI Studio.
• Connectez-vous avec votre compte Google.
• Dans le menu de gauche, cliquez sur Get API key puis sur le bouton Create API key.

• Une fois la clé d’API créée, cliquez dessus pour l’afficher.
• Copiez cette longue suite de caractères et gardez-la précieusement (ne la partagez jamais publiquement).
  

Étape 2 : Adapter le Design de MotivApp

Reprenons notre projet Thunkable là où nous l’avons laissé. Nous allons ajouter un peu d’interactivité.

• Sur le Screen1 (Accueil) : Ajoutez un composant Text Input juste au-dessus du bouton “Inspire-moi !”. Modifiez son paramètre Hint (indice) pour afficher : “Entrez un thème (ex: Le sport, Le code…)”. Renommez ce composant Input_Theme.
  

Étape 3 : Le Prompt Engineering avec RISEN

C’est le cœur du réacteur. Pour éviter que l’IA ne divague, nous allons structurer notre requête (prompt) avec le framework professionnel RISEN. Voici comment nous allons contraindre le modèle gemini-2.5-flash :

• R (Role) : Agis comme un coach de vie expert en motivation.
• I (Instruction) : Écris une citation motivante inédite basée sur le thème suivant : [Thème tapé par l’utilisateur].
• S (Steps) : 1. Analyse le thème. 2. Trouve un angle inspirant. 3. Formule la citation. 4. Attribue-la à un auteur fictif ou réel.
• E (End Goal) : Le lecteur doit ressentir une envie immédiate de passer à l’action.
• N (Narrowing) : La réponse DOIT suivre ce format strict : ‘Citation - Auteur’. Ne dépasse pas 20 mots. N’inclus aucune salutation.

Voici exactement le texte final que notre application va assembler, en remplaçant la app variable de fin par le thème choisi par l’utilisateur :

Agis comme un coach de vie expert en motivation. 
Écris une citation motivante inédite basée sur le thème suivant : [THÈME DE L'UTILISATEUR]. 
1. Analyse le thème. 2. Trouve un angle inspirant. 3. Formule la citation. 4. Attribue-la à un auteur fictif ou réel. 
Le lecteur doit ressentir une envie immédiate de passer à l'action. 
La réponse DOIT suivre ce format strict : 'Citation - Auteur'. Ne dépasse pas 20 mots. N'inclus aucune salutation.

Étape 4 : La Logique et les Blocs

Sur le Screen1

Aperçu des blocs

Séquence des blocs

Initialisation

• À l’ouverture du Screen1, videz le champ Input_Theme.
• Lors du clic sur Btn_Inspire, nous devons vérifier que le texte Text du composant Input_Theme n’est pas vide avant d’exécuter les étapes suivantes.

Construire la requête API :

• Créez un composant Web API : dans la liste de gauche, déroulez “Advanced”, puis cliquez sur le [+] à droite de “Web APIs”. C’est lui qui remplacera Firebase pour dialoguer avec les serveurs de Google.

  • Renommez-le en Gemini.
  • Configurez l’URL de l’API : définissez le champ “URL” à https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent.
  • Configurez votre clé d’API :
    • Définissez le champ “Property” à key.
    • Collez votre clé d’API dans le champ “Value”.
    • Cliquez sur [Add].
  • Configurez l’en-tête (header) :
    • Définissez le champ “Property” à Content-Type.
    • Tapez application/json dans le champ “Value”.
    • Cliquez sur [Add].
  • Cliquez sur [Done].

L’API de Gemini est très stricte sur le format des données qu’elle reçoit. Elle attend un objet JSON contenant une liste contents, qui contient elle-même une liste parts, qui contient enfin l’attribut text avec notre prompt. Dans Thunkable, la façon la plus simple de construire ce corps de requête (le Body) est d’utiliser un bloc de texte.

1. D’abord, créez une app variable full_prompt et utilisez un bloc join pour y coller le gros bloc de texte RISEN (vu à l’étape 3) avec le texte Text du composant Input_Theme.
2. Prenez un autre bloc de texte avancé join (qui permet de coller plusieurs morceaux de texte ensemble).
3. Dans la première case, collez exactement ce début de code JSON : {"contents": [{"parts": [{"text": "
4. Dans la deuxième case, glissez votre app variable full_prompt.
5. Dans la troisième case, fermez le code JSON avec : "}]}]}
6. Assignez le tout au bloc set Web_API's Body to.

Extraire la réponse JSON :

• Lancez l’appel avec le bloc call Gemini's Post.
• L’API nous répond avec un gros bloc de données textuelles complexes (response).
• Dans la section then do, nous allons isoler le texte qui nous intéresse en imbriquant plusieurs blocs, un peu comme des poupées russes. Nous allons assigner tout ce cheminement à une nouvelle app variable citation.
• Pour bien comprendre ce grand bloc rouge et bleu, lisez-le de droite à gauche (de l’intérieur vers l’extérieur) :
  1. On transforme le texte brut en objet manipulable : get object from JSON [response].
  2. On extrait la propriété candidates.
  3. C’est une liste, on prend le premier élément : in list [...] get # 1.
  4. On extrait la propriété content.
  5. On extrait la propriété parts.
  6. C’est aussi une liste, on prend le premier élément : in list [...] get # 1.
  7. On extrait enfin la propriété text.
• Séparer la citation de l’auteur : 1. Créez une app variable liste_reponse.
  1. Assignez-lui le bloc make list from text (dans Lists), en utilisant notre app variable citation, et tapez " - " dans la case delimiter.
  2. Maintenant que nos données sont propres et découpées, terminez en glissant le bloc Navigate to Screen2.

Sur le Screen2

1. Mettez à jour le Label_Quote en allant chercher le premier élément de cette liste (bloc in list get # 1).
2. Mettez à jour le Label_Author en allant chercher le deuxième élément (bloc in list get # 2).

Étape 5 : Essayez !

Le moment de vérité est arrivé.

• Lancez l’application via Thunkable Live sur votre téléphone (ou via l’aperçu Web de la plateforme).
• Sur le premier écran, tapez un thème qui vous inspire dans le champ de texte (par exemple : “La gestion du stress”, “Le dépassement de soi” ou “L’apprentissage de la guitare”).
• Appuyez sur Inspire-moi !.
• Après une brève seconde (le temps que le modèle de Google génère sa réponse), vous basculez automatiquement sur le deuxième écran.
• Et voilà ! Une citation unique, parfaitement formatée et taillée sur mesure pour votre thème s’affiche sous vos yeux. Vous n’avez plus qu’à cliquer sur “Retour” pour tester avec une nouvelle idée !

Conclusion

Félicitations ! Vous venez de créer une application mobile capable de générer du contenu à l’infini grâce à l’intelligence artificielle. Les limites du no-code sont repoussées tous les jours, et c’est le moment idéal pour expérimenter.

N’hésitez pas à modifier le prompt RISEN pour créer un générateur de recettes de cuisine, un créateur de poèmes ou même un quiz interactif. À vous de jouer !

Starting this year, I have the opportunity to act as a mentor for the Technovation Montreal program. Seeing teams go from a simple idea to a functional mobile prototype in just a few weeks reminded me of one key thing: no-code is an absolutely fantastic driver of innovation.

Even when you aim to develop mobile apps from scratch using advanced frameworks like React Native, leveraging these visual platforms allows you to validate a backend architecture and an interface logic in a flash 🙂

To put my money where my mouth is, I’m proposing a new two-part tutorial series to build a dynamic, Cloud-connected iOS/Android mobile app, without writing a single line of traditional code.

Foreword: This article, enhanced with improvements generated by AI (Google Gemini), is made available under the CC BY-ND 4.0

What’s the game plan?

The goal of this mini-series is to build a mobile app by progressively integrating professional concepts. Here is our roadmap:

1. Today: Create the interface for a “Motivational Quotes” app (MotivApp) using Thunkable, and connect it to a real, real-time Cloud database with Firebase.
2. Part 2: Make the app smart by replacing our database with calls to the Google Gemini API to generate unique quotes on the fly 🚀

15 minutes flat to prototype our app!

Our application will feature two screens: a home screen with an “Inspire me!” button, and a display screen that will randomly pull a quote stored in the Cloud.

Step 1: Prepare the backend with Firebase

Firebase is Google’s platform that provides ready-to-use backend services. We are going to use its Realtime Database.

1. Log into the Firebase Console with a Google account and click on Create a project (name it MotivApp).
2. In the left menu, go to Databases & Storage > Realtime Database and click on Create database. Choose the test mode to start easily.
3. In the Data tab, we will structure our database with unique identifiers to make it robust. Click on the three little dots to the right of your database URL, choose Import JSON, and import a file containing this:

{
  "quotes": {
    "quote_001": {
      "text": "Success is falling nine times and getting up ten.",
      "author": "Japanese Proverb"
    },
    "quote_002": {
      "text": "Make your life a dream, and a dream a reality.",
      "author": "Antoine de Saint-Exupéry"
    },
    "quote_003": {
      "text": "Innovation distinguishes between a leader and a follower.",
      "author": "Steve Jobs"
    }
  }
}

Keep your database URL and your Web API key (available in the Firebase project settings) handy, we’ll need them in Thunkable!

The easiest way to find your API key is to:

1. Go to the Project overview page in the Firebase console.
2. Click on the button [+ Add app]
3. Click on the button </> to add a Web app.
4. Put MotivApp as app nickname, then click on [Register app].
5. You’ll get a pop up with the values you need.

Step 2: The Design (Visual Interface)

Create a free account on Thunkable and start a new project :

• On the main screen, you’ll have a prompt box.
• At the bottom of that prompt box, find the line “Prefer to start from scratch?” then click on Create Blank Project”.

• Put MotivApp as Project name, select Health & Fitness, make sure that Use the Drag and Drop Builder is selected.
• Click on [Create].

On Screen1 (Home):

1. Drag a Label component to the center of the screen with the text “Welcome to MotivApp!”. Center text and change font zsize using the options in the left tree view.
2. Drag a Button component below it. Change its text to “Inspire me!”. Rename this component to Btn_Inspire in the left tree view.

On Screen2 (Quote):

1. Add a second screen (Screen2).
2. Drag two Labels one below the other. The first one (main text) will be renamed Label_Quote, the second one (smaller, for the author) will be Label_Author.
3. Drag a Button below with the text “Go Back” (Btn_GoBack).
4. Connect your Realtime Database
   • In your Thunkable tab, click the Settings gear icon in the sidebar.
   • Scroll to the Firebase section and paste the “apiKey” into the “Firebase API Key” field.
   • Still in the Firebase section, paste the “databaseURL” into the “Database URL” field.

Step 3: The Logic (Blocks)

Switch from the Design tab to the Blocks tab. This is where the magic happens!

Screen1 Logic:

• Grab the when Btn_Inspire Clicks do block and drag the Navigate to Screen2 block inside it.

Screen2 Logic (Extracting JSON data): Here, we need to retrieve our dictionary of quotes, pick one at random, and then isolate its text and author.

1. Go to Variables and grab the initialize cloud variable name block. Name it "quotes" (this must exactly match the root node name of our JSON in Firebase so Thunkable syncs it automatically).
2. Grab the when Screen2 Opens do block.
3. Inside, we’ll first list our keys. Create a temporary variable random_key. Assign to it the random item of list block. The list to provide will be generated by the get object properties of block (in the Objects category) applied to our quotes cloud variable.
4. Now that we have a random key (e.g., quote_002), let’s create a chosen_quote variable. Assign to it the property (get property of object block) corresponding to random_key extracted from our cloud quotes object.
5. Finally, update your labels! Assign the "text" property of the chosen_quote object to Label_Quote, and its "author" property to Label_Author.
6. Grab the when Btn_Inspire Clicks do block and drag the Navigate to Screen1 block inside it.

Step 4: Test the beast!

No need to compile!

• Download the Thunkable Live app on your smartphone (iOS or Android).
• Log in with your account. Tap your project and test: you should see a new quote pulled directly from your Cloud database with every try 😉

Conclusion

And there you have it! You’ve created a real mobile app connected to a professional backend. The huge advantage of this architecture is that you can now add, edit, or delete quotes directly from the Firebase console, and your users’ app will update instantly, without them having to re-download it.

But why stop there? In part 2 of this tutorial, we will replace our Firebase database with the Gemini artificial intelligence API. Our app will no longer just read quotes, it will invent them on demand! Stay tuned.

Depuis cette année, j’ai l’occasion d’agir comme mentor pour le programme Technovation Montréal. Voir des équipes passer d’une simple idée à un prototype mobile fonctionnel en quelques semaines m’a rappelé une chose essentielle : le no-code est un levier d’innovation absolument fantastique.

Même lorsque l’on ambitionne de développer soi-même des applications mobiles de A à Z avec des frameworks avancés comme React Native, passer par ces plateformes visuelles permet de valider une architecture backend et une logique d’interface en un éclair 🙂

Pour joindre le geste à la parole, je vous propose une nouvelle série de deux tutoriels pour créer une application mobile iOS/Android dynamique et connectée au Cloud, sans écrire une seule ligne de code classique.

Avant-propos: Cet article, augmenté d’améliorations générées avec des IA (Google Gemini), est mis à disposition au travers de la license CC BY-ND 4.0

C’est quoi le plan de match ?

L’objectif de cette mini-série est de construire une application mobile en y intégrant progressivement des concepts professionnels. Voici notre feuille de route :

1. Aujourd’hui : Créer l’interface d’une application de “Citations Motivantes” (MotivApp) avec Thunkable, et la connecter à une vraie base de données Cloud en temps réel avec Firebase.
2. Partie 2 : Rendre l’application intelligente en remplaçant notre base de données par des requêtes à l’API de Google Gemini pour générer des citations uniques à la volée 🚀

15 minutes chrono pour prototyper notre application !

Notre application comportera deux écrans : un écran d’accueil avec un bouton “Inspire-moi !”, et un écran d’affichage qui ira piocher aléatoirement une citation stockée dans le Cloud.

Étape 1 : Préparer le backend avec Firebase

Firebase est la plateforme de Google qui fournit des services backend prêts à l’emploi. Nous allons utiliser sa Realtime Database.

1. Connectez-vous à la Console Firebase avec un compte Google et cliquez sur Créer un projet (nommez-le MotivApp).
2. Dans le menu de gauche, allez dans Bases de données et stockage d’objets > Realtime Database et cliquez sur Créer une base de données. Sélectionner la région la plus proche de vous, puis choisissez le mode test pour commencer facilement.
3. Dans l’onglet Données, nous allons structurer notre base avec des identifiants uniques pour que ce soit robuste. Cliquez sur les trois petits points à droite de l’URL de votre base, choisissez Importer un fichier JSON, et importez un fichier contenant ceci :

{
  "citations": {
    "quote_001": {
      "texte": "Le succès, c'est tomber sept fois, se relever huit.",
      "auteur": "Proverbe japonais"
    },
    "quote_002": {
      "texte": "Faites que le rêve dévore votre vie...",
      "auteur": "Antoine de Saint-Exupéry"
    },
    "quote_003": {
      "texte": "L'innovation distingue le leader du suiveur.",
      "auteur": "Steve Jobs"
    }
  }
}

Gardez l’URL de votre base de données et votre clé d’API web sous la main, nous en aurons besoin dans Thunkable !

La manière la plus simple de trouver votre clé API et l’URL de votre base est de :

1. Se rendre sur la page Vue d’ensemble du projet dans la console Firebase.
2. Cliquer sur le bouton [+ Ajouter une application]
3. Cliquer sur le bouton </> pour ajouter une application web.
4. Mettez MotivApp en pseudo d’application, puis cliquer sur [Enregistrer l’application].
5. Une fenêtre contextuelle s’affichera avec toutes les valeurs dont vous avez besoin.
   

Étape 2 : Le Design (Interface Visuelle)

Créez un compte gratuit sur Thunkable et démarrez un nouveau projet:

• Sur l’écran principal, vous trouverez une zone de saisie (prompt box).
• Au bas de cette zone, repérez la mention « Prefer to start from scratch? » puis cliquez sur Create Blank Project.

• Saisissez MotivApp comme nom de projet (Project name), sélectionnez Health & Fitness, et assurez-vous que l’option Use the Drag and Drop Builder est bien cochée.
• Cliquez sur [Create].

Sur le Screen1 (Accueil) :

1. Glissez un composant Label au centre de l’écran avec le texte “Bienvenue sur MotivApp !”. Centrez le texte et changer la taille de police dans l’arborescence à gauche.
2. Glissez un composant Button en dessous. Changez son texte pour “Inspire-moi !”. Renommez ce composant Btn_Inspire dans l’arborescence à gauche.

Sur le Screen2 (Citation) :

1. Ajoutez un deuxième écran (Screen2).
2. Glissez deux Labels l’un sous l’autre. Le premier (texte principal) sera renommé Label_Quote, le second (plus petit, pour l’auteur) sera Label_Author.
3. Glissez un Button en dessous avec le texte “Retour” (Btn_Retour).
4. Connectez votre Realtime Database
   • Dans votre onglet Thunkable, cliquez sur l’icône d’engrenage (Settings) dans la barre latérale.
   • Faites défiler jusqu’à la section Firebase et collez la valeur « apiKey » dans le champ « Firebase API Key ».
   • Toujours dans la section Firebase, collez l’URL « databaseURL » dans le champ « Database URL ».

Étape 3 : La Logique (Les Blocs)

Passez de l’onglet Design à l’onglet Blocks. C’est ici que la magie opère !

Logique du Screen1 :

• Prenez le bloc when Btn_Inspire Clicks do et glissez à l’intérieur le bloc Navigate to Screen2.

Logique du Screen2 (Extraction des données JSON) : Ici, nous devons récupérer notre dictionnaire de citations, en choisir une au hasard, puis isoler son texte et son auteur.

1. Allez dans Variables et prenez le bloc initialize cloud variable name. Nommez-la "citations" (cela doit correspondre exactement au nom racine de notre JSON dans Firebase pour que Thunkable fasse la synchronisation automatiquement).
2. Prenez le bloc when Screen2 Opens do.
3. À l’intérieur, nous allons d’abord lister nos clés. Créez une variable temporaire cle_aleatoire. Assignez-lui le bloc random item of list. La liste à fournir sera générée par le bloc get object properties of (dans la catégorie Objects) appliqué à notre variable cloud citations.
4. Maintenant que nous avons une clé au hasard (ex: quote_002), créons une variable citation_choisie. Assignez-lui la propriété (bloc get property of object) correspondant à cle_aleatoire extraite de notre variable cloud citations.
5. Enfin, mettez à jour vos labels ! Attribuez au Label_Quote la propriété "texte" de l’objet citation_choisie, et au Label_Author sa propriété "auteur".
6. Prenez le bloc when Btn_Retour Clicks do et glissez à l’intérieur le bloc Navigate to Screen1.

Étape 4 : Tester la bête !

Pas besoin de compiler !

• Téléchargez l’application Thunkable Live sur votre smartphone (iOS ou Android).
• Connectez-vous avec votre compte. Touchez votre projet et testez : vous devriez voir une nouvelle citation tirée directement de votre base de données Cloud à chaque essai 😉

Conclusion

Et voilà ! Vous avez créé une véritable application mobile connectée à un backend professionnel. L’avantage énorme de cette architecture, c’est que vous pouvez maintenant ajouter, modifier ou supprimer des citations directement depuis la console Firebase, et l’application de vos utilisateurs se mettra à jour instantanément, sans qu’ils n’aient à la retélécharger.

Mais pourquoi s’arrêter en si bon chemin ? Dans la partie 2 de ce tutoriel, nous allons remplacer notre base Firebase par l’API de l’intelligence artificielle Gemini. Notre application ne se contentera plus de lire des citations, elle les inventera sur mesure ! Restez à l’écoute.

In the previous post, I suggested some approaches to help as many people as possible understand the latest innovations in AI. Now, it only makes sense to set a good example from a tech popularization perspective 🙂

As the post title suggests, here’s a quick, simple, and effective tutorial to install your own large language model instance, or LLM, locally on a Windows PC using Ollama.

Foreword: This article, enhanced with improvements generated by AI (Napkin , Google AI, Perplexity), is made available under the CC BY-ND 4.0

What is an LLM?

Great question, thanks for asking 😀 An LLM (Large Language Model) is an artificial intelligence model trained on massive amounts of text data to understand and generate human language, learning to predict the next words in a sequence.

Among the best-known models for the general public:

• Available through ChatGPT, OpenAI’s GPT models (GPT-4o, o3 and o4-mini).
• Grok, by xAI, fully integrated into X.
• Google Gemini, featured in Google tools like Gmail, Google Drive, Google Docs, etc.
• LLama models from Meta, fully integrated into Facebook, Instagram, and WhatsApp, and open-sourced since LLama 2 in July 2023 (GitHub repo).

From this core capability, the applications of these AI models are numerous:

• Advanced chatbots
  • Automated customer support,
  • Interactive FAQ.
• Large-scale data processing
  • Summarization,
  • Extraction, refinement, and classification.
• Automatic translation
  • For my previous article, I was glad to have access to LLMs to translate Chinese academic papers!
• Code generation
  • Widely used for coding assistance, I use GitHub Copilot to harmonize this blog’s Markdown code!
• Reasoning simulation
  • The latest achievements in this area are really interesting. Besides the DeepSeek-R1 model, I experiment a lot with Gemini Pro 2.5’s Deep Search.

10 minutes flat to install an LLM on a Windows PC—is it possible?

Really?

OK, you won’t be running inferences with hundreds of billions of parameters on your laptop, let alone commercial models, but you can easily run smaller, yet powerful enough LLMs for fun!

What’s the point of a local LLM?

Personally, I see only benefits:

• Access to a wide range of recent open-source LLMs, including reasoning models like DeepSeek-R1 or Qwen 3.
• Guaranteed privacy: once the model is on your PC, no data leaves your computer, protecting all exchanges with the model (texts, images).
• No subscription for available features.
• Give a second life to older PCs. For example, I repurposed an old laptop with a Core i5 and 16 GB RAM as a personal server with Ubuntu, and I run a small model on it!

What are the components?

Ollama

Available on Linux, MacOS, Windows, and Docker, this open-source software platform allows you to manage and run language models locally.

• Website: https://ollama.com
• Discord: https://discord.com/invite/ollama
• List of available models: https://ollama.com/library
  • You can sign up here to publish and share your own models.
• GitHub repo: https://github.com/ollama/ollama

Hollama - Webchat Client for Ollama

Also available on Linux, MacOS, Windows, and Docker, this app is a webchat client compatible with Ollama and OpenAI.

• GitHub repo: https://github.com/fmaclen/hollama
• Live demo: https://hollama.fernando.is/

I chose Hollama for its ease of use, especially for loading new models directly through the graphical interface.

System Requirements

No need for a dedicated graphics card or a Copilot+ PC; the following config is enough to get started!

I validated this tutorial on virtual machines using this minimum configuration, so you can proceed with confidence 😉

Language model used in the tutorial - gemma3:1b-it-qat

gemma3:1b-it-qat refers to a lightweight and efficient version of Google’s open-source Gemma 3 model:

• 1 billion parameters (“1b”).
• Instruction-tuned ("it"): Optimized to follow instructions and respond conversationally, this model is ideal for text generation, summarization, and translation.
• Quantization-Aware Trained ("qat"): Trained to support quantization (e.g., 4-bit), which greatly reduces memory requirements while maintaining quality close to larger models.

How do you do it? (Step-by-step guide)

Open PowerShell as administrator

• Right-click the Start menu and select “Terminal (Admin)” or “Windows PowerShell (Admin)”.
  

• Click [Yes] to accept privilege elevation.

Install a local Ollama instance, install the GUI, and fetch the gemma3:1b-it-qat model in a single command

• Run this command:

winget install --id=Ollama.Ollama --accept-source-agreements -e; winget install --id=FernandoMaclen.Hollama -e; ollama pull gemma3:1b-it-qat; shutdown -r -t 0

• Once the package is downloaded and verified, the Ollama instance installation process begins, and the Ollama installer GUI appears.

• During the final steps of this first installation process, the Microsoft C++ 2015/2022 Redistributable may be installed automatically if not already present.

• At the end of the Ollama instance installation, a welcome window appears. Click [Finish] to close it.

• With the local Ollama instance installed, the Hollama GUI installation proceeds automatically.

• Once this installation process is complete, the gemma3:1b-it-qat model download to the local Ollama instance starts automatically.

• Once the model is downloaded, the system will automatically restart. After rebooting, you’ll see the Hollama app icon on the Desktop.

Finalize installation

• Double-click the Hollama icon on the desktop to launch the GUI. A Windows Firewall notification appears; click [Cancel] to block incoming connections.

• Once the app starts, it opens directly in the settings interface.

• In the Servers section, select “Ollama” in the “Connection type” dropdown, then click [Add connection].

• Click [Verify]. If all goes well, the message “Connection has been verified and is ready to use.” appears in a green box at the top, and the “Use models from this server” box is checked automatically.

Test your first prompt

• In the left menu, click [New session].

• Make sure the model is present in the dropdown, write your prompt, click [Run]. Wait a few seconds, and voilà—magic 😀

How to download other models with the GUI?

• Go back to the Hollama app settings.
• Under the “Ollama” connection settings, click the “Ollama’s Library” link. In the new window, browse the available model catalog, copy the identifier of the model you want to load (e.g., qwen3:0.6b), then close this window.

• Back in the “Ollama” connection settings, paste the model identifier into the “Pull model” textbox, then click the red button to start loading.

• An info message appears at the top to show progress. The new model will be loaded and ready to use when the message turns green.

• You can now select and use this new model in conversation sessions.

(If needed) Completely remove installed components

• Open PowerShell as administrator (see first step),
• Run the following command to remove all installed components (apps and models):

winget uninstall --id=Ollama.Ollama ; winget uninstall --id=FernandoMaclen.Hollama; winget source reset --force; rm $env:USERPROFILE\*ollama* -R; rm $env:USERPROFILE\AppData\Local\*ollama* -R; rm $env:USERPROFILE\AppData\Local\Temp -R; rm $env:USERPROFILE\AppData\Roaming\*ollama* -R; shutdown -r -t 0

• Once the components are uninstalled, the system will automatically

Conclusion

In just a few minutes, you can now experiment with the power of local LLMs on your Windows PC, without any subscription or cloud dependency. Whether for learning, coding assistance, or simply exploring the latest advances in artificial intelligence, Ollama and Hollama offer a simple and accessible solution.

Don’t hesitate to try out different models and share your feedback or discoveries!

Dans le post précédent, j’ai proposé des angles d’approche pour permettre au plus grand nombre d’appréhender les dernières innovations en termes d’IA. Maintenant, il est somme toute logique que je donne le bon exemple sous l’angle de la vulgarisation techno 🙂

Comme le suggère le titre du post, je vous propose un tutoriel rapide, simple et efficace pour installer votre propre instance de grand modèle de langage, ou LLM, localement sur un PC sous Windows en utilisant Ollama.

Avant-propos: Cet article, augmenté d’améliorations générées avec des IA (Napkin , Google AI, Perplexity), est mis à disposition au travers de la license CC BY-ND 4.0

C’est quoi un LLM ?

Très bonne question, merci de l’avoir posée 😀 Un LLM (Large Language Model) est un modèle d’intelligence artificielle entraîné sur d’énormes quantités de données textuelles pour comprendre et générer du langage humain, apprenant ainsi à prédire les mots suivants dans une séquence.

Parmi les modèles les plus connus du grand public :

• Disponibles au travers de ChatGPT, les modèles GPT de OpenAI (GPT-4o, o3 et o4-mini).
• Grok, par xAI, qui est pleinement intégré à X.
• Google Gemini, mis en avant au travers des outils Google tels que Gmail,Google Drive, Google Docs, etc…
• Les modèles LLama de Meta, qui sont pleinement intégrés à Facebook, Instagram et WhatsApp, sont rendus Open Source depuis la sortie de LLama 2 en juillet 2023 (Dépôt GitHub).

À partir de cette capacité fondamentale, les applications de ces modèles IA sont nombreuses :

• Chatbots avancés
  • support client automatisé,
  • FAQ interactive.
• Traitement de données à grand volume
  • Résumés,
  • Extraction, raffinage puis classification.
• Traduction automatique
  • Pour mon article précédent, j’étais bien content d’avoir accès à des LLM pour traduire des articles universitaires chinois !
• Génération de code informatique,
  • Beaucoup utilisé pour l’aide au codage, j’utilise GitHub Copilot pour harmoniser le code Markdown de ce blog !
• Simulation de raisonnement
  • Les dernières évolutions dans ce domaine sont vraiment intéressantes. Outre le modèle DeepSeek-R1, j’expérimente beaucoup avec l’option de Recherche Profonde de Gemini Pro 2.5.

10 minutes chrono pour installer un LLM sur un PC Windows, c’est possible !

Vraiment ?

OK, c’est sûr que vous n’allez pas faire tourner des inférences avec des centaines de milliards de paramètres sur votre laptop, et encore moins des modèles commerciaux, mais pas de souci pour faire tourner des LLM plus modestes mais suffisamment performants pour s’amuser !

C’est quoi l’intérêt d’un LLM local ?

Personnellement, je n’y vois que des avantages

• Accès à une multitude de LLM Open Source récents, y compris des modèles de raisonnement comme DeepSeek-R1 ou Qwen 3.
• Confidentialité garantie : une fois le modèle sur le PC, aucune donnée ne quitte l’ordinateur, protégeant ainsi les données échangées avec le modèle (textes, images).
• Pas d’abonnement pour les fonctionnalités disponibles.
• Possibilité de redonner un second souffle à des PC un peu moins récents. Pour exemple, j’ai reconditionné un vieux laptop avec un Core-I5 et 16 GB de RAM en serveur perso avec une distri Ubuntu, et je fais tourner un petit modèle dessus !

C’est quoi les composants ?

Ollama

Disponible sur Linux, MacOs, WIndows et Docker, cette plateforme logicielle Open Source permet la gestion et l’exécution locale de modèles de langage.

• Site web : https://ollama.com
• Discord : https://discord.com/invite/ollama
• Liste des modèles disponibles : https://ollama.com/library
  • Il est possible de s’inscrire ici pour publier et partager ses propres modèles.
• Dépot GitHub : https://github.com/ollama/ollama

Hollama - Client Webchat pour Ollama

Disponible également sur Linux, MacOs, WIndows et Docker, cette application est un client Webchat compatible Ollama et OpenAI.

• Dépot GitHub : https://github.com/fmaclen/hollama
• Live demo : https://hollama.fernando.is/

J’ai choisi Hollama pour sa simplicité d’utilisation, notamment pour charger de nouveaux modèles directement au travers de l’interface graphique.

Prérequis système

Pas besoin d’une carte graphique dédiée ou d’un PC Copilot +, la config suivante vous permet de faire vos premières armes !

J’ai validé ce tutoriel sur des machines virtuelles qui utilisent cette configuration minimale, vous pouvez y aller les yeux fermés 😉

Modèle de langage utilisé dans le tutoriel - gemma3:1b-it-qat

gemma3:1b-it-qat désigne un version légère et efficace du modèle Open Source Gemma 3 de Google:

• 1 milliard de paramètres (“1b”).
• Instruction-tuned ("it") : Optimisé pour suivre des instructions et répondre de manière conversationnelle, ce modèle est idéal pour la génération de texte, le résumé et la traduction.
• Quantization-Aware Trained ("qat") : Entraîné pour supporter la quantification (par exemple en 4 bits), ce qui réduit considérablement la mémoire nécessaire tout en maintenant une qualité proche des modèles plus lourds.

C’est comment qu’on fait ? (Guide étape par étape)

Ouvrez PowerShell en mode administrateur

• Clic-droit sur le menu Démarrer et sélectionnez « Terminal (Administrateur) » ou «Windows  PowerShell (Admin) ».

• Cliquez sur [Oui] pour accepter l’élévation de privilèges.

Installez un instance locale Ollama, installez l’interface graphique et récupérez le modèle gemma3:1b-it-qat en une seule ligne de commande

• Exécutez cette commande :

winget install --id=Ollama.Ollama --accept-source-agreements -e; winget install --id=FernandoMaclen.Hollama -e; ollama pull gemma3:1b-it-qat; shutdown -r -t 0

• Une fois le paquet téléchargé et vérifié, le processus d’installation de l’instance Ollama commence, et l’interface graphique d’installation Ollama s’affiche.

• Durant l’une dernières étapes de ce premier processus d’installation, l’installation du Redistribuable Microsoft C++ 2015/2022 peut s’effectuer de manière automatique s’il n’est pas présent sur le système.

• À la fin du processus d’installation de l’instance Ollama, une fenêtre de bienvenue s’affiche. Vous pouvez cliquer sur [Finish] pour la fermer.

• L’instance locale Ollama étant installée, l’installation de l’interface graphique Hollama s’effectue de manière automatique.

• Une fois ce processus d’installation terminé, le téléchargement du modèle gemma3:1b-it-qat sur l’instance locale Ollama se lance de manière automatique.

• Une fois le modèle téléchargé, le système redémarre automatiquement. Une fois redémarré, vous pouvez alors constater que l’icône de l’application Hollama est disponible sur le Bureau.

Finalisez l’installation

• Double-cliquez sur l’icône Hollama présent sur le bureau pour lancer l’interface graphique. Une notification du pare-feu Windows s’affiche, cliquez sur [Annuler] pour bloquer les flux entrants.

• Une fois l’application démarrée, celle-ci s’ouvre directement dans les paramètres de l’interface.

• Dans la section Serveurs, sélectionnez “Ollama” dans la liste déroulante “Type de connexion” puis cliquez sur [Ajouter une connexion].

• Cliquez sur [Vérifier]. Si tout va bien le message “La connexion a été vérifiée et est prête à être utilisée.” s’affiche dans un encart vert en haut de la fenêtre, et la case “Utiiser les modèles de ce serveur” se coche automatiquement.

Testez un premier prompt

• Dans le menu de gauche, cliquez sur [Nouvelle session].

• Validez que le modèle est présent dans la liste déroulante, écrivez votre prompt, cliquez sur [Exécuter]. Patientez quelques secondes, et voilà, magie 😀

Comment télécharger d’autres modèles avec l’interface graphique ?

• Retournez dans les paramètres de l’application Hollama.
• Sous les paramètres de la connexion “Ollama”, cliquez sur le lien “Bibliothèque d’Ollama”. Dans la nouvelle fenêtre qui s’affiche, parcourez le catalogue de modèles disponible, copiez l’identifiant du modèle que vous souhaitez télécharger (exemple : qwen3:0.6b), puis fermez cette fenêtre.

• De retour dans les paramètres de la connexion “Ollama”, collez l’identifiant du modèle dans la boite de texte “Tirer le modèle”, puis cliquez sur le bouton rouge pour lancer le téléchargement.

• Un message d’information s’affiche en haut de la fenètre pour montrer la progression. Le nouveau modèle est téléchargé et prêt à être utilisé quand le message passera au vert.

• Vous pouvez désormais choisir et utiliser ce nouveau modèle dans les sessions de conversation.

(Si besoin) Supprimer entièrement les composants installés

• Ouvrez PowerShell en mode administrateur (cf. 1ère étape),
• Exécutez la commande suivante pour supprimer tous les composants installés (applications et modèles) :

winget uninstall --id=Ollama.Ollama ; winget uninstall --id=FernandoMaclen.Hollama; winget source reset --force; rm $env:USERPROFILE\*ollama* -R; rm $env:USERPROFILE\AppData\Local\*ollama* -R; rm $env:USERPROFILE\AppData\Local\Temp -R; rm $env:USERPROFILE\AppData\Roaming\*ollama* -R; shutdown -r -t 0

• Une fois les composants désinstallés, le poste va redémarrer automatiquement.

Conclusion

En quelques minutes, vous pouvez désormais expérimenter la puissance des LLM locaux sur votre PC Windows, sans abonnement ni dépendance au cloud. Que ce soit pour apprendre, obtenir de l’aide à la rédaction ou au codage, ou simplement explorer les dernières avancées de l’intelligence artificielle, Ollama et Hollama offrent une solution simple et accessible.

N’hésitez pas à tester différents modèles, à partager vos retours ou vos découvertes, et à contribuer à la communauté open source !