Déployer une IA Générative Puissante Localement sur un MacBook Pro

15 min readMay 25, 2024

POC pour obtenir votre IA privée et gratuite avec LM Studio, HuggingFace et PrivateGPT

En mai 2024, il est tout à fait possible de faire fonctionner une IA générative puissante, gratuitement et localement sur un matériel courant, comme un MacBook Pro. Cet article vous guide à travers la mise en place d’un Large Language Model (LLM) combiné à une technique de Retrieval-Augmented Generation (RAG), démontrant les capacités actuelles de ces technologies. Notez bien que l’objectif de mon guide est de vous permettre de monter une maquette pleinement fonctionnelle mais dont les limites de la licence accordée par l’équipe de LM Studio ne vous permettent pas d’utiliser en entreprise ou commercialement.

Qu’est-ce qu’un Large Language Model (LLM) ?

Un Large Language Model est un modèle de traitement du langage naturel (NLP pour Natural Language Processing) qui utilise des réseaux de neurones profonds pour comprendre et générer du texte humain. Entraînés sur de vastes ensembles de données textuelles, ces modèles accomplissent diverses tâches comme la traduction, la rédaction automatique, et la réponse à des questions. Vous connaissez déjà sûrement, j’en suis certain, des outils comme ChatGPT, Gemini, Claude ou Mistral. Ces modèles sont puissants mais dépendent souvent de services en ligne payants et ne sont pas sous votre contrôle direct.

Qu’est-ce que le Retrieval-Augmented Generation (RAG) ?

Le RAG combine la génération de texte par des modèles de langage avec la récupération d’informations pertinentes à partir d’une base de données ou d’un ensemble de documents. Cette approche améliore la précision des réponses en accédant à des informations externes pendant la génération. La clé de cette technique réside dans la vectorisation, transformant des textes en vecteurs numériques. Ces vecteurs capturent les caractéristiques sémantiques du texte, permettant aux algorithmes de machine learning de traiter et comprendre efficacement les textes.

Pourquoi déployer votre IA localement ?

Déployer un LLM localement signifie installer et exécuter le modèle de langage sur votre propre infrastructure, comme dans mon exemple ici sur un MacBook Pro, plutôt que de dépendre de services cloud. Les avantages incluent une meilleure confidentialité des données, un contrôle total sur le modèle et des performances optimisées en fonction des ressources locales disponibles.

Technologies et Connaissances Nécessaires pour ce POC

Pour ce Proof-of-Concept (POC), vous aurez besoin de :

- Un ordinateur Apple MacBook suffisamment puissant, pour ma part j’utilise un MacBook Pro M2 MAX avec 32 Go de RAM.
- Homebrew pour la gestion des paquets sur macOS.
- Le Terminal d’origine Apple ou bien iTerm2 que j’affectionne particulièrement pour sa richesse fonctionnelle.
- Python 3.11 avec Pyenv pour gérer plusieurs versions de Python sans risquer de rendre instable votre macOS.
- Poetry pour la gestion des dépendances Python.
- Make pour automatiser les tâches.
- LM Studio pour exécuter et servir localement les LLM téléchargés depuis HuggingFace.
- La librairie HuggingFace_Hub pour télécharger les modèles de “text embeddings”.
- PrivateGPT pour fournir une interface graphique dédiée (UI basée sur Gradio) et gérer le RAG localement.

Au niveau des connaissances, pas de prérequis spécifiques, juste une familiarité avec la ligne de commande, savoir utiliser un éditeur de texte voire de code (comme Vim, Nano, ou VS Code), et quelques notions basiques de Git.

Installation des Composants

Quand vous lisez ‘bash’ dans un bloc de code, il vous faut ouvrir votre terminal et y taper ou y copier / coller le code présent.

Homebrew

Homebrew installe les paquets que macOS n’inclut pas par défaut. Pour l’installer, ouvrez votre terminal et exécutez :

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Site officiel : https://brew.sh/

iTerm2

iTerm2 offre plus de fonctionnalités que le terminal par défaut de macOS. Installez-le avec Homebrew :

brew install --cask iterm2

Site officiel : https://iterm2.com/

Python 3.11 et Pyenv

Vérifiez votre version de Python :

python3 --version

Dans mon cas je suis en 3.11.9

Faites la mise à jour si besoin.

Pour faire la mise à jour, si vous débutez avec python, il est fort probable que vous ayez Python3 d’installé dans /usr/bin/python3, pour le savoir utilisez la commande :

which python3

Si vous obtenez /usr/bin/python3, c’est l’installation par défaut.

Cet environnement est utilisé par votre système d’exploitation macOS, je vous conseille très fortement de ne pas le bricoler !

Donc si votre python n’est pas en 3.11, à minima, ou qu’il s’agit de celui déployé par Apple sur votre système, il faut déployer un nouvel environnement sans toucher celui d’origine. Pour cela nous utiliserons Pyenv qui reste très léger et permet de gérer plusieurs versions de Python en fonction de vos besoins.

Et c’est parti pour installer Pyenv sur votre macOS avec Homebrew :

brew install pyenv

Site officiel de Pyenv : https://github.com/pyenv

Vous devez ajouter Pyenv à votre profil de shell pour qu’il s’initialise correctement. Cela va dépendre de votre Shell, dans mon cas j’utilise Zsh avec iTerm2, dans toute la suite de cet article je ne parlerai que de cet environnement de Bash sauf ici où je vous présente en détail comment faire pour plusieurs environnements différents (gratitude pour l’équipe du projet Pyenv qui a très bien détaillé ces opérations !).

Configurer votre environnement shell pour Pyenv,

Pour Bash :

echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bashrc
echo 'command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(pyenv init -)"' >> ~/.bashrc

Ensuite, si vous avez ~/.profile, ~/.bash_profile ou ~/.bash_login, ajoutez-y également les commandes. Si vous n’avez aucun de ces fichiers, ajoutez-les à ~/.profile.

Pour ajouter à ~/.profile :

echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.profile
echo 'command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.profile
echo 'eval "$(pyenv init -)"' >> ~/.profile

Pour ajouter à ~/.bash_profile :

echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bash_profile
echo '[[ -d $PYENV_ROOT/bin ]] && export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bash_profile
echo 'eval "$(pyenv init -)"' >> ~/.bash_profile

Puis rechargez votre shell :

exec "$SHELL"

Pour Zsh :

echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.zshrc
echo '[[ -d $PYENV_ROOT/bin ]] && export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.zshrc
echo 'eval "$(pyenv init -)"' >> ~/.zshrc

Si vous souhaitez obtenir Pyenv dans des shells de connexion non interactifs, ajoutez également les commandes à ~/.zprofile ou ~/.zlogin.

Pour Fish shell :

Si vous avez Fish 3.2.0 ou plus récent, exécutez ceci de manière interactive :

set -Ux PYENV_ROOT $HOME/.pyenv
fish_add_path $PYENV_ROOT/bin

Sinon, exécutez le snippet ci-dessous :

set -Ux PYENV_ROOT $HOME/.pyenv
set -U fish_user_paths $PYENV_ROOT/bin $fish_user_paths

Maintenant, ajoutez ceci à ~/.config/fish/config.fish :

pyenv init - | source

Avertissement Bash : Il existe certains systèmes où la variable BASH_ENV est configurée pour pointer vers .bashrc. Sur ces systèmes, vous devriez certainement mettre la ligne `eval “$(pyenv init -)”` dans .bash_profile, et non dans .bashrc. Sinon, vous pourriez observer des comportements étranges, comme Pyenv entrant dans une boucle infinie.

Note sur les proxy : Si vous utilisez un proxy, exportez également http_proxy et https_proxy.

Sur macOS, vous voudrez peut-être aussi installer Q d’AWS (ex Fig) qui fournit des complétions alternatives pour de nombreux outils en ligne de commande avec une interface popup de type IDE dans la fenêtre du terminal. (Notez que leurs complétions sont indépendantes du codebase de Pyenv, elles peuvent donc être légèrement désynchronisées.)

Dans tous les cas, n’oubliez pas de redémarrez votre shell pour que les changements de PATH prennent effet !

exec "$SHELL"

Plus d’infos sur le paramétrage de Pyenv par ici : https://github.com/pyenv/pyenv?tab=readme-ov-file#getting-pyenv

Poetry

IMPORTANT !!!
Poetry doit toujours être installé dans un environnement virtuel dédié pour l’isoler du reste de votre système. Il ne doit en aucun cas être installé dans l’environnement du projet qui doit être géré par Poetry. Cela garantit que les dépendances de Poetry ne seront pas accidentellement mises à jour ou désinstallées. (Chacune des méthodes d’installation suivantes garantit que Poetry est installé dans un environnement isolé.) De plus, l’environnement virtuel isolé dans lequel Poetry est installé ne doit pas être activé pour exécuter des commandes Poetry.

Installez Poetry pour gérer les dépendances Python :

curl -sSL https://install.python-poetry.org | python3 -

Ajoutez Poetry à votre PATH. Dans mon cas c’est Zsh :

export PATH="~/.local/bin:~/.zshrc"

Ensuite, rechargez votre profil de shell avec source :

source ~/.zshrc  # ou le fichier de profil correspondant à votre bash, vous avez suivi ;)

Si besoin de désinstaller Poetry, alors refaire la même commande en lui ajoutant l’argument — uninstall.

curl -sSL https://install.python-poetry.org | python3 --uninstall

Testez le bon fonctionnement de Poetry :

poetry --version

Vous devez obtenir quelque chose comme :

Poetry (version 1.8.2)

Avec l’installateur officiel comme utilisé ici, vous pouvez gérer les mises à jour via cette commande :

poetry self update

Pour activer l’auto-complétion dans votre terminal, suivez les exemples fournis sur la documentation officielle : https://python-poetry.org/docs/main/#installing-with-the-official-installer

Si tout comme moi vous utilisez Zsh avec le terminal iTerm2, utilisez l’exemple pour “Oh My Zsh” :

poetry completions zsh > ~/.oh-my-zsh/plugins/poetry/_poetry

Puis ajoutez l’entrée poetry dans la zone des plugins de votre fichier ~/.zshrc que vous éditez avec Nano, Vi ou tout autre éditeur de texte de votre choix :

plugins=(poetry)

Si vous avez déjà d’autres plugins, comme git par exemple, alors ajoutez poetry derrière les précédents, séparé par un espace, ce qui donne avec l’exemple Git :

plugins=(git poetry)

Puis testez l’auto-complétion en tapant ‘poetry’ puis sur la touche Tabulation ⇥ de votre clavier. Vous devriez obtenir à l’écran la liste de toutes les commandes disponibles pour poetry :

Résultat de l’appui sur la touche tabulation après la commande poetry

Make

GNU Make est un outil qui contrôle la génération d’exécutables et d’autres fichiers non-sources d’un programme à partir des fichiers sources du programme.

Make acquiert sa connaissance de la manière de construire le programme à partir d’un fichier appelé makefile, qui liste chacun des fichiers non-sources et comment le calculer à partir d’autres fichiers. Un peu compliqué ? En gros, lorsque vous écrivez un programme, vous devez écrire un makefile pour celui-ci, afin qu’il soit possible d’utiliser Make pour construire et installer le programme. Dans notre POC, Make sert à lancer PrivateGPT, tout simplement.

Pour installer Make on se sert ici encore de Homebrew dans le terminal :

brew install make

Envie d’en savoir plus sur cet obscur utilitaire ? Le site officiel de la version GNU de Make est ici : https://www.gnu.org/software/make/

Installation de LM Studio

Ici c’est très simple, il suffit de suivre les indications du site officiel, on repasse en mode “clicodrome”, ça va être très facile :)

Site officiel de LM Studio : https://lmstudio.ai/

Au moment où j’ai réalisé cette documentation nous en étions à la version 0.2.23 intégrant depuis la mi-avril le modèle Llama 3 de chez Meta AI.

J’ajoute que cette version fournit aussi, depuis quelques semaines, la possibilité de générer du “text embeddings”, très utile donc pour les applications de RAG comme PrivateGPT, mais cette dernière ne sait pas encore l’utiliser et votre humble serviteur n’a pas pris le temps de coder ce qu’il fallait pour. Je ferai peut-être un futur article sur ce sujet. En attendant nous utiliserons la librairie python “huggingface_hub” pour assurer cette fonction.

Si tout est bien installé vous allez déjà pouvoir jouer avec une IA générative locale sur votre mac. Vérifiez que tout fonctionne et téléchargez au moins le modèle LLM “Llama 3” de chez META. Dans mon exemple j’ai pris celui-ci qui tourne très bien sur mon MacBook Pro M2 Max :

lmstudio-community/Meta-Llama-3–8B-Instruct-GGUF/Meta-Llama-3–8B-Instruct-Q8_0.gguf

Pour vérifier que le rôle de serveur local de votre LM Studio fonctionne, après l’avoir démarré, vous pouvez faire une requête de test pour connaître le modèle chargé, pour cela, depuis votre terminal iTerm2 ou équivalent, tapez cette commande :

curl http://localhost:1234/v1/models

Vous devriez obtenir une réponse identique à celle-ci (pour le modèle Llama 3) :

{
  "data": [
    {
      "id": "lmstudio-community/Meta-Llama-3-8B-Instruct-GGUF/Meta-Llama-3-8B-Instruct-Q8_0.gguf",
      "object": "model",
      "owned_by": "organization-owner",
      "permission": [
        {}
      ]
    }
  ],
  "object": "list"
}%

Et si vous regardez la fenêtre de logs de votre serveur LM Studio vous devriez y voir la même sortie.

Logs dans l’interface de LM Studio 0.2.23 après une requête Curl depuis le terminal macos

Notez que vous pouvez aussi piloter LM Studio depuis la ligne de commande depuis la version 0.2.22 de début mai.
Plus d’infos sur ce site officiel : https://lmstudio.ai/blog/lms

Installation de la librairie HuggingFace Hub

Il vous faudra, pour pouvoir vous connecter depuis le client python huggingface_hub vers les dépôts d’HuggingFace, avoir un compte gratuit chez eux et avoir créé au moins un jeton d’accès (token).

Interface HuggingFace — Menu Settings — Gestion des jetons d’accès

Pour cela commencez par aller sur le site de HuggingFace, créez votre compte puis dans “Settings” et “Access Tokens”, créez puis récupérez votre jeton. Ce jeton est tout aussi précieux qu’un mot de passe, n’en faites pas n’importe quoi !

Site officiel de HuggingFace : https://huggingface.co/welcome

Maintenant sur votre mac, dans votre terminal, installez la librairie python huggingface_hub à l’aide de pip :

pip install huggingface_hub
huggingface-cli login

Après lancement de la seconde ligne, la librairie vous demandera, en anglais, de renseigner votre jeton d’accès (token) créé précédemment. Vous pouvez le copier / coller.

Installation de PrivateGPT

Pour en savoir plus, avant d’installer ce programme par clonage depuis son dépôt chez Github, c’est par ici : https://docs.privategpt.dev/overview/welcome/introduction

Pour l’installer, toujours dans votre terminal, positionnez-vous dans votre dossier de développement. Dans mon cas, je range mes expériences dans un répertoire que j’ai nommé DEV à la racine de mon home, ce qui donne ~/DEV

Mais au fait, connaissez-vous le symbole tilde (~) ?

Petite parenthèse pour les newbies fraîchement débarqués ;-)

Le symbole tilde (~) dans une invite de commande Linux ou MacOS est utilisé pour représenter le répertoire personnel de l’utilisateur actuel. Voici quelques usages et significations du tilde dans ce contexte :

1. Répertoire personnel :

Lorsque vous voyez ~ dans une invite de commande, cela fait référence au répertoire personnel de l’utilisateur connecté. Par exemple, si votre nom d’utilisateur est john, ~ correspondra à /home/john sur Linux ou /Users/john sur MacOS.

2. Navigation rapide :

Vous pouvez utiliser ~ pour vous déplacer rapidement vers votre répertoire personnel. Par exemple, la commande cd ~ vous ramène directement à votre répertoire personnel, peu importe où vous vous trouvez dans le système de fichiers.

3. Combinaisons avec des chemins :

Vous pouvez utiliser ~ avec des chemins relatifs pour accéder à des sous-répertoires de votre répertoire personnel. Par exemple, ~/Documents accédera au dossier Documents dans votre répertoire personnel.

4. Répertoires d’autres utilisateurs :

En utilisant ~ suivi d’un nom d’utilisateur, vous pouvez accéder au répertoire personnel d’un autre utilisateur. Par exemple, ~john accédera au répertoire personnel de l’utilisateur john si vous avez les permissions nécessaires.

Voici quelques exemples pratiques de l’utilisation du tilde dans une invite de commande :

• cd ~ : Change le répertoire actuel pour le répertoire personnel de l’utilisateur.
• ls ~ : Liste les fichiers et répertoires dans le répertoire personnel de l’utilisateur.
• cp ~/file.txt . : Copie file.txt depuis le répertoire personnel vers le répertoire courant.
• cd ~/Documents/Projects : Change le répertoire actuel pour le sous-répertoire Projects dans le répertoire Documents de l’utilisateur.

En résumé ; whaou j’écris comme une IA générative c’est grave docteur ? Donc je reprends, le tilde est un raccourci pratique qui permet de simplifier et d’accélérer la navigation dans le système de fichiers en faisant référence au répertoire personnel de l’utilisateur actuel.

Donc pour installer PrivateGPT, positionnez-vous dans votre dossier de développement, pour moi c’est dans ~/DEV

Puis clonez le dépôt de PrivateGPT et entrez dans le nouveau répertoire créé :

cd ~/DEV # à adapter à votre répertoire de développement
git clone https://github.com/zylon-ai/private-gpt
cd private-gpt

Installation des dépendances Poetry nécessaires au fonctionnement de PrivateGPT

Nous allons maintenant installer les dépendances supplémentaires nécessaires au fonctionnement de ce projet, pour cela, toujours dans votre terminal au sein de votre projet private-gpt, utilisez la commande suivante :

poetry install --extras "ui llms-openai-like embeddings-huggingface vector-stores-qdrant"

Et vous devriez-voir dans votre terminal se dérouler l’installation de tous les packages nécessaires au projet.

Quelques explications utiles sur les arguments, situés entre les double-quotes (guillemets), de cette ligne de commande :

ui pour utiliser l’UI Gradio

llms-openai-like pour se connecter à LM Studio qui est, rappelons-le si besoin, un LLM local dont le serveur est compatible avec l’API d’OpenAI.

embeddings-huggingface pour pouvoir utiliser localement des modèles d’Embeddings au format Huggingface, grâce, rappelons-le, à la bibliothèque huggingface_hub. Ces modèles servent à convertir des mots, des phrases ou des documents entiers en vecteurs de nombres. Ces vecteurs captent des aspects sémantiques du texte, ce qui permet aux algorithmes de travailler avec du texte en utilisant des opérations mathématiques. J’essaierai de vous faire un article ultérieurement sur ce que sont les vecteurs.

vector-stores-qdrant pour le stockage des fameux vecteurs créés au format Qdrant.

Paramétrage de PrivateGPT

Nous allons maintenant modifier le fichier de configuration adapté à notre POC, à savoir le fichier settings-vllm.yaml que vous devez trouver à la racine de votre répertoire private-gpt

Pourquoi celui-ci et pas un autre ? Tout simplement parce qu’il s’agit du fichier le mieux adapté, à date, pour se connecter à LM Studio. Par contre il n’est pas pleinement compatible, comme je le disais plus haut, avec les dernières versions 0.2.19 et au delà, de LM Studio. Il manque encore les composants permettant d’exploiter le “text embeddings” pour la vectorisation directement depuis LM Studio. J’avoue ne pas avoir trop creusé le sujet pour le moment.

Pour éditer le fichier, dans votre terminal, je vous conseille l’utilisation de l’éditeur nano :

nano settings-vllm.yaml

Ou bien depuis VS Code si c’est votre outil de prédilection.

Et si vous n’êtes pas suffisamment à l’aise avec l’un de ces deux outils, il y a plus simple, en ouvrant le fichier directement depuis le Finder de macOS dans l’éditeur de texte de macOS, à savoir TextEdit.

Puis modifiez le fichier pour obtenir ceci :

server: 
  env_name: ${APP_ENV:vllm}

llm: 
  mode: openailike
  max_new_tokens: 512
  tokenizer: mistralai/Mistral-7B-Instruct-v0.2
  temperature: 0.1

embedding: 
  mode: huggingface
  ingest_mode: simple

huggingface: 
  embedding_hf_model_name: BAAI/bge-small-en-v1.5

openai: 
  api_base: http://localhost:1234/v1
  api_key: lm-studio
  model: lmstudio-community/Meta-Llama-3-8B-Instruct-GGUF
  request_timeout: 600.0

Ce sont mes réglages, qui fonctionnent bien pour ce POC, à savoir pour rappel, faire une démonstration de la puissance d’une IA générative associée à un RAG pour perfectionner le modèle de LLM utilisé sur vos datas (vos fichiers à faire digérer par le RAG), le tout en local sur une machine “abordable”.

Vous pouvez bien entendu changez de modèles de LLM et de text embeddings, tester d’autres valeurs pour la température ou encore le nombre de tokens max que le LLM doit utiliser.

Prérequis avant le premier démarrage de PrivateGPT pour télécharger le modèle de “text embeddings” pour votre RAG local

Cette étape est importante puisque sans elle la suite ne fonctionne pas !

Il faut en effet télécharger localement les modèles nécessaires pour le RAG. Rappelez-vous, privateGPT n’est pas à ce jour capable d’utiliser les nouvelles fonctionnalités du serveur LM Studio. Nous avons donc installé une librairie python de chez HuggingFace, connectée cette librairie à leurs dépôts via un token qui vous appartient, et maintenant il faut lui indiquer quoi télécharger.

La procédure est la suivante, en étant toujours dans votre terminal, dans le répertoire private-gpt, vous utilisez les commandes suivantes pour personnaliser PrivateGPT :

export PGPT_PROFILES=vllm

Cette commande indique à privateGPT d’utiliser le profile de réglages contenu dans votre fichier settings-vllm.yaml

Vous pouvez vérifier que la commande a bien fonctionné en utilisant celle-ci :

echo $PGPT_PROFILES

Ce qui doit vous retourner ceci dans votre terminal :

vllm

Puis vous lancez cette commande qui va télécharger les modèles, environ 5 Go de données, dans le sous-répertoire /private-gpt/models/

poetry run python scripts/setup

Et si tout se passe bien, vous obtiendrez en sortie ces quelques lignes :

19:26:55.385 [INFO    ] private_gpt.settings.settings_loader - Starting application with profiles=['default', 'vllm']
Downloading embedding BAAI/bge-small-en-v1.5
Fetching 14 files: 100%|██████████████████████████████████████████████████████████████████████████████████████████████| 14/14 [00:00<00:00, 37.95it/s]
Embedding model downloaded!
Downloading LLM mistral-7b-instruct-v0.2.Q4_K_M.gguf
LLM model downloaded!
Downloading tokenizer mistralai/Mistral-7B-Instruct-v0.2
Tokenizer downloaded!
Setup done

Démarrage de PrivateGPT

C’est le grand moment, si tout s’est bien passé jusqu’ici il n’y a pas de raison que ça ne puisse pas fonctionner, suspens…

Toujours dans votre répertoire private-gpt, en ligne de commande lancez PrivateGPT avec make, notez qu’il vous faudra maintenant toujours utiliser cette série de commande pour démarrer votre instance de PrivateGPT :

export PGPT_PROFILES=vllm
make run

Et si tout est OK, vous devriez obtenir une série de lignes indiquant le bon démarrage de PrivateGPT et de son interface graphique Gradio UI disponible en localhost sur le port TCP 8001 (sans certificat SSL) :

PrivateGTP fonctionne et vous invite à vous connecter en HTTP sur l’adresse localhost port 8001

Utilisation de l’interface de PrivateGPT et test du RAG

Connectez-vous à l’aide de votre navigateur web préféré à l’adresse http://localhost:8001

Vous devriez obtenir ceci :

UI Gradio de PrivateGPT, ici avec 3 documents PDF, mes notes de cours, déjà ingérés.

Pour mes tests, j’ai chargé dans le RAG des notes de mes cours dédiés au leadership et à l’amélioration de la santé mentale, 3 documents PDF pour un total d’environ 30 000 mots.

Sur le modèle Llama 3 de META, sans aucun tunning fin, les résultats sont bluffants. Certes ce n’est pas aussi rapide qu’un ChatGPT 4o ; sur ma machine j’obtiens une réponse finalisée en une minute environ, mais c’est gratuit, privé et la qualité de la réponse est tout à faire pertinente !

Amusez-vous à comparer des requêtes avec le contexte de vos documents (bouton Query Files activé) versus des requêtes sans le contexte (bouton LLM Chat activé).

Pour la suite

Je prévois de vous présenter prochainement une autre maquette qui n’utilisera que des composants 100 % libres (Open Source), donc pas de LM Studio mais peut-être un Ollama (licence MIT) ou bien Jan (licence AGPL v3) à la place, avec cette fois-ci une orientation professionnelle, pour un usage en entreprise, avec plusieurs dizaines de documents dédiés à une thématique. Abonnez-vous pour être prévenu !