Salut, de retour pour un nouveau tutoriel dev. Aujourd’hui, on va parler d’un sujet qui devient de plus en plus important : créer son propre ChatGPT local, capable de fonctionner sur ton ordinateur, de répondre à tes questions, et surtout de travailler avec tes propres documents sans devoir tout envoyer dans le cloud.

L’objectif de ce projet est simple : construire LocalGPT Studio, une application locale qui permet de discuter avec une intelligence artificielle installée sur ta machine. Tu peux lui poser des questions, lui demander de résumer un texte, d’analyser des fichiers, de retrouver une information dans un PDF ou encore de t’aider à comprendre une documentation technique.

L’intérêt principal, c’est que l’application reste orientée local, privé et contrôlable. Des outils comme LM Studio mettent déjà en avant l’idée d’exécuter des modèles IA localement et de manière privée sur son propre matériel. GPT4All présente aussi le même type de promesse : un chatbot privé, local, sans cloud obligatoire, avec prise en charge des documents locaux.

Mais ici, l’idée n’est pas seulement d’utiliser un outil existant. L’objectif est de comprendre comment fonctionne ce type d’application et comment on peut construire une base solide pour son propre assistant IA.

Télécharger le code source du projet sur GitHub

Pourquoi créer un ChatGPT local ?

Utiliser ChatGPT, Claude, Gemini ou d’autres assistants IA en ligne est pratique. Mais dès qu’on travaille avec des documents personnels, des fichiers clients, des contrats, des factures, des rapports internes ou du code source privé, la question de la confidentialité devient importante.

Un ChatGPT local permet de garder beaucoup plus de contrôle sur l’environnement d’exécution. Le modèle tourne sur ton ordinateur ou ton serveur, les fichiers sont stockés localement, et tu peux décider comment les données sont indexées, sauvegardées ou supprimées.

Attention tout de même : “local” ne veut pas dire automatiquement “sécurisé”. Si l’application garde l’historique des conversations en clair, si elle expose une API sur le réseau, ou si elle utilise des services externes sans prévenir, il faut le savoir. C’est justement pour cela qu’un projet comme LocalGPT Studio est intéressant : on peut construire une application transparente, compréhensible et maîtrisable.

Ollama est une bonne base technique pour ce type de projet, car il permet d’interagir avec des modèles via une API locale. Après installation, son API est disponible par défaut sur http://localhost:11434/api, ce qui permet à une application desktop ou web locale de communiquer avec le modèle.

C’est quoi LocalGPT Studio ?

LocalGPT Studio est une application web locale que j’ai développée pour discuter avec une intelligence artificielle directement depuis son ordinateur.

L’objectif est simple : créer une alternative légère à ChatGPT, mais avec plus de contrôle. Ici, l’utilisateur peut choisir son fournisseur IA, utiliser Ollama en local, connecter Groq API si besoin, garder un historique des conversations, envoyer des fichiers à l’assistant et exporter les discussions.

Le projet repose sur une stack simple et efficace :

Python
Flask
SQLite
Ollama
Groq API
HTML / CSS / JavaScript

LocalGPT Studio tourne en local sur http://127.0.0.1:5000. L’idée n’est pas de créer une usine à gaz. Le but est d’avoir une application propre, compréhensible, facile à installer et intéressante à améliorer.

Aperçu du projet

LocalGPT Studio fonctionne comme un petit studio IA personnel.

Depuis l’interface, on peut :

discuter avec un modèle Ollama installé sur son PC ;
utiliser Groq API pour obtenir des réponses rapides ;
activer ou désactiver le streaming ;
choisir le modèle IA ;
régler la température, le top-p, le nombre de tokens et le contexte ;
envoyer des fichiers texte, PDF, DOCX ou images ;
conserver l’historique des conversations ;
exporter une discussion en Markdown ou en TXT ;
utiliser la recherche web avec les modèles Groq compatibles.

C’est donc un très bon projet pour apprendre à connecter une interface web à une IA locale.

Télécharger le code source du projet sur GitHub

Pourquoi créer une IA locale ?

Aujourd’hui, beaucoup d’outils IA fonctionnent dans le cloud. C’est pratique, mais ce n’est pas toujours idéal.

Quand on veut tester des modèles, apprendre comment fonctionne une IA, travailler sur des fichiers personnels ou construire une application personnalisée, il est intéressant d’avoir une solution locale.

Avec LocalGPT Studio, on peut utiliser Ollama pour exécuter des modèles directement sur son ordinateur. Les conversations sont stockées dans une base SQLite locale, et l’application peut fonctionner sans dépendre uniquement d’un service externe.

Groq reste disponible en option pour les cas où l’on veut une réponse très rapide ou utiliser la recherche web.

Installation de LocalGPT Studio

Avant de commencer, il faut installer deux choses :

Python 3.10+
Ollama

Ensuite, on récupère le projet depuis GitHub.

git clone https://github.com/LM-Code-Be/localgpt-studio.git
cd localgpt-studio

On crée un environnement virtuel Python :

python -m venv .venv

Sur Windows, on active l’environnement avec :

.\.venv\Scripts\Activate.ps1

Puis on installe les dépendances :

pip install -r requirements.txt

Enfin, on lance l’application :

python app.py

Il suffit ensuite d’ouvrir le navigateur à cette adresse :

http://127.0.0.1:5000

Préparer Ollama

Pour utiliser LocalGPT Studio en mode local, il faut qu’Ollama soit installé et lancé.

Si Ollama n’est pas déjà installé, vous pouvez le télécharger via ce lien puis l’installer.

On peut vérifier ensuite les modèles disponibles avec :

ollama list

Pour télécharger un modèle, par exemple Llama 3 :

ollama pull llama3

Puis pour le tester directement :

ollama run llama3

Par défaut, LocalGPT Studio utilise l’adresse locale d’Ollama :

http://localhost:11434

Si l’application n’arrive pas à contacter Ollama, il faut vérifier que le service est bien lancé.

ollama serve

Utiliser Groq API en option

LocalGPT Studio peut aussi utiliser Groq API.

Ce n’est pas obligatoire, mais c’est pratique pour obtenir des réponses rapides ou utiliser la recherche web intégrée.

Dans l’application, il suffit d’aller dans les paramètres, de choisir Groq API comme fournisseur IA, puis de renseigner :

URL Groq : https://api.groq.com/openai/v1
Clé API Groq : gsk_...

Il est aussi possible de passer par des variables d’environnement :

$env:GROQ_API_KEY="gsk_votre_cle"
$env:GROQ_BASE_URL="https://api.groq.com/openai/v1"
python app.py

Important : il ne faut jamais publier une clé API dans le code source

Télécharger le code source du projet sur GitHub

Comment fonctionne l’application ?

LocalGPT Studio est organisé autour de trois grandes parties :

Chat
Conversations
Paramètres

Au démarrage, Flask charge la configuration, initialise la base SQLite, puis enregistre les routes de l’application.

La base SQLite contient les conversations, les messages et les paramètres. Cela permet de garder un historique local sans avoir besoin d’un serveur externe.

L’application utilise ensuite un service dédié pour communiquer avec Ollama. Quand l’utilisateur envoie un message, LocalGPT Studio prépare la conversation, ajoute le prompt système, applique les paramètres du modèle, puis envoie la requête à Ollama ou à Groq selon le fournisseur choisi.

Les paramètres IA disponibles

Depuis l’interface, l’utilisateur peut ajuster plusieurs paramètres importants :

temperature
top_p
max_tokens
top_k
repeat_penalty
context_size
seed
streaming_enabled
system_prompt
default_model

Ces options permettent de personnaliser le comportement de l’assistant.

Par exemple :

une température basse donne des réponses plus stables ;
une température plus haute donne des réponses plus créatives ;
max_tokens limite la longueur de la réponse ;
context_size définit la taille du contexte disponible ;
system_prompt permet de modifier le comportement global de l’assistant.

Le prompt système par défaut est orienté vers un assistant francophone, clair, pédagogique et précis.

Upload de fichiers

Une fonctionnalité intéressante de LocalGPT Studio est l’envoi de fichiers.

L’application accepte plusieurs formats :

.txt
.md
.csv
.json
.log
.py
.js
.html
.css
.pdf
.docx
.png
.jpg
.jpeg
.webp
.bmp

Pour les fichiers texte, le contenu est extrait directement.

Pour les fichiers PDF, l’application utilise PyPDF2.

Pour les fichiers DOCX, elle utilise python-docx.

Pour les images, le fichier est encodé en base64 afin de pouvoir être envoyé à un modèle compatible vision.

La limite d’upload est fixée à 12 MB, et le texte extrait est limité à 12 000 caractères afin de garder une application rapide et stable.

Exporter une conversation

LocalGPT Studio permet aussi d’exporter une conversation.

Deux formats sont disponibles :

Markdown
TXT

L’export Markdown est pratique pour transformer une discussion en note, en documentation ou en base d’article.

L’export TXT permet de sauvegarder rapidement une conversation dans un format simple et universel.

C’est une fonctionnalité utile quand on utilise l’IA pour travailler sur un projet, rédiger une idée, générer une documentation ou garder une trace d’une réponse importante.

Recherche web avec Groq

LocalGPT Studio intègre aussi un bouton Web pour lancer des réponses avec recherche web via Groq.

Cette fonctionnalité utilise les modèles compatibles :

groq/compound
groq/compound-mini

Si un autre modèle Groq est sélectionné, l’application peut basculer automatiquement vers groq/compound-mini pour effectuer la requête web.

C’est pratique pour poser des questions qui nécessitent des informations récentes.

Architecture simplifiée du projet

Voici une vue simplifiée du fonctionnement :

Navigateur
   ↓
Application Flask
   ↓
Routes API
   ↓
Services IA
   ↓
Ollama local ou Groq API
   ↓
Réponse affichée dans l’interface

Et pour les conversations :

Message utilisateur
   ↓
ConversationService
   ↓
SQLite
   ↓
Historique local

Cette architecture est volontairement simple. Elle permet de comprendre facilement comment une application IA est construite, sans partir directement sur une structure trop complexe.

Routes principales

LocalGPT Studio expose plusieurs routes utiles :

GET    /
GET    /api/models
POST   /api/chat
POST   /api/chat/stream
GET    /api/conversations
POST   /api/conversations
GET    /api/conversations/&lt;id>
PUT    /api/conversations/&lt;id>
DELETE /api/conversations/&lt;id>
GET    /api/export/&lt;id>/markdown
GET    /api/export/&lt;id>/txt
GET    /settings
POST   /settings

Ces routes couvrent les fonctions principales : affichage de l’interface, récupération des modèles, chat, streaming, gestion des conversations, export et paramètres.

Améliorations possibles

Le projet est déjà fonctionnel, mais il peut encore évoluer.

Voici quelques idées intéressantes :

ajouter une vraie indexation RAG des documents ;
ajouter une recherche dans l’historique ;
créer un mode projet avec plusieurs espaces de travail ;
ajouter une authentification locale ;
améliorer le support des modèles vision ;
ajouter un export PDF ;
ajouter un thème clair/sombre plus complet ;
créer une version desktop avec Electron ou Tauri ;
ajouter Docker pour simplifier l’installation ;
ajouter une page de statistiques des conversations.

C’est ce qui rend ce projet intéressant : il peut servir de base pour apprendre, mais aussi de point de départ pour construire un assistant IA beaucoup plus complet.

Télécharger le code source du projet sur GitHub

Conclusion

LocalGPT Studio est un projet parfait pour comprendre comment créer une application IA locale avec Python.

On y retrouve les bases essentielles d’un assistant moderne :

interface web
backend Flask
base SQLite
connexion Ollama
support Groq API
streaming
historique
upload de fichiers
export Markdown/TXT
paramètres IA personnalisables

Le projet reste simple à installer, mais il touche à beaucoup de notions importantes pour progresser en développement IA.

Si tu veux apprendre à construire ton propre assistant local, tester Ollama, comprendre le streaming ou créer une interface IA complète avec Flask, LocalGPT Studio est une très bonne base de départ.

Je te laisse le soin d’améliorer LocalGPT Studio et à nous le faire partager en commentaire.