Jouons avec Ollama - Créer un analyseur d'articles de blog avec un LLM local

Tagger ses articles à la main, ça ne passe pas à l'échelle — et repérer, parmi quelques centaines d'articles, ceux qui vont réellement ensemble non plus. Je voulais voir si un modèle local, avec pour seule entrée le Markdown brut, pouvait générer des tags corrects puis utiliser ces tags pour suggérer lui-même des liens internes.

Le résultat​

Une fois les deux scripts exécutés, output/all_articles_with_tags.json contient les tags générés pour chaque article :

Le deuxième script compare ensuite ces tags entre les articles. suggested_interlinks.json est la première sortie intéressante :

[?
  {
    "source_article": "001-intro-to-docker.md",?
    "suggested_links": []?
  },
  {
    "source_article": "004-local-llms-future.md",
    "suggested_links": ["002-getting-started-with-ollama.md"]?
  },
  {
    "source_article": "003-advanced-python.md",
    "suggested_links": []
  },
  {
    "source_article": "002-getting-started-with-ollama.md",
    "suggested_links": ["004-local-llms-future.md"]?
  }
]

Les articles 002 et 004 sont correctement identifiés comme liés — ils parlent tous les deux de LLM locaux. Les articles 001 et 003 sont laissés de côté, puisqu'ils traitent de sujets sans rapport. Plutôt pas mal !

Le second fichier de sortie, tag_analysis.json, montre les tags et leur nombre d'occurrences dans les articles. Sur ce petit échantillon, « local LLMs » apparaît dans deux articles (002 et 004) alors que tous les autres tags n'apparaissent qu'une seule fois :

{
  "total_unique_tags": 23,?
  "top_tags": [?
    {
      "tag": "local",
      "count": 2
    },
    {
      "tag": "LLMs",
      "count": 2
    },
    {
      "tag": "docker",
      "count": 1
    },
    {
      "tag": "containers",
      "count": 1
    },
    {
      "tag": "images",
      "count": 1
    },
    {
      "tag": "compose",
      "count": 1
    },
    {
      "tag": "future",
      "count": 1
    },
    {
      "tag": "AI",
      "count": 1
    },
    {
      "tag": "development",
      "count": 1
    },
    {
      "tag": "advanced",
      "count": 1
    },
    {
      "tag": "python",
      "count": 1
    },
    {
      "tag": "scripting",
      "count": 1
    },
    {
      "tag": "decorators",
      "count": 1
    },
    {
      "tag": "generators",
      "count": 1
    },
    {
      "tag": "context",
      "count": 1
    },
    {
      "tag": "managers",
      "count": 1
    },
    {
      "tag": "rest",
      "count": 1
    },
    {
      "tag": "api",
      "count": 1
    },
    {
      "tag": "language models",
      "count": 1
    },
    {
      "tag": "Ollama",
      "count": 1
    }
  ]
}

Pourquoi ça fonctionne​

• Un script par responsabilité : le premier script ne parle qu'au LLM et produit des tags ; le second se contente de lire ces tags et de calculer les relations — aucun script ne fait les deux.
• Les tags sont le seul signal utilisé pour les liens. Deux articles partageant un tag sont considérés comme liés ; plus ils partagent de tags, plus la suggestion est forte.
• Rien ici n'est spécifique à Docusaurus — remplacez data/posts par n'importe quel dossier de fichiers Markdown et les deux mêmes scripts produisent le même type d'analyse.

Installation​

Copier la structure de répertoires et les fichiers​

Lancez la commande suivante dans votre terminal pour copier la structure de répertoires et les fichiers de ce tutoriel :

Une fois terminé, lancez code . pour ouvrir le répertoire courant dans Visual Studio Code puis appuyez sur Ctrl+Shift+P et choisissez Devcontainers: Reopen in Container pour ouvrir le projet dans un container de développement.

Le build du container et l'installation des dépendances prendront quelques minutes. Une fois le devcontainer démarré, vous verrez dans Docker Desktop que les deux containers tournent :

Télécharger le modèle LLM​

Revenez ensuite à votre terminal (sur votre host) et lancez la commande suivante pour télécharger le modèle LLM :

$ docker exec -it tags-ollama-1 ollama pull llama3:8b

Tester le service Ollama​

Nous venons de télécharger le modèle LLM, vérifions maintenant que le service Ollama fonctionne correctement. Lancez la commande suivante dans votre terminal (sur votre host) :

$ curl --silent http://localhost:11444/api/tags | jq

curl --silent http://localhost:11444/api/generate \
  -d '{\
    "model": "llama3:8b", \
    "prompt": "Explain in one sentence why Docker is so amazing.", \
    "stream": false \
  }' | jq .response

Le service fonctionne, et on voit que l'endpoint tags est disponible. C'est cet endpoint que nos scripts Python utiliseront pour envoyer le contenu des articles et récupérer les tags générés.

Autres démos​

Lancer le script de génération de tags​

Retournez dans Visual Studio Code, ouvrez le terminal (dans VSCode) et exécutez le fichier scripts/01_generate_tags.py. Ce script lit tous les fichiers Markdown du répertoire data/posts, envoie leur contenu au modèle LLM qui tourne dans le container, et enregistre les tags générés dans un fichier JSON.

Et effectivement, vous constatez que le fichier output/all_articles_with_tags.json a été créé — les tags montrés plus haut dans « Le résultat » sont exactement ce que cette exécution a produit.

Lancer le script d'analyse et de liens​

Le second script, scripts/02_analyze_and_link.py, lit les tags générés depuis ce fichier JSON et produit les fichiers suggested_interlinks.json et tag_analysis.json montrés plus haut.

Sous le capot (à sauter si vous voulez juste l'utiliser)​

Choisir le bon modèle​

Dans cet article, j'ai pris llama3:8b comme point de départ. Mais la vraie force d'Ollama, c'est la possibilité de changer de « cerveau » selon la tâche. Le registre Ollama propose une immense bibliothèque de modèles, mais le bon choix dépend de votre matériel — en particulier de votre RAM et de votre GPU.

Comparaison des modèles en un coup d'œil​

Lequel choisir ?​

• Prenez llama3:8b si vous débutez ou si votre RAM est limitée. Il est parfait pour du prototypage rapide et des tâches d'automatisation simples qui ne demandent pas de raisonnement logique poussé.
• Essayez mistral si vous trouvez les réponses de Llama 3 un peu trop rigides. Beaucoup de développeurs préfèrent Mistral pour son côté créatif et son efficacité. C'est un excellent modèle « du quotidien » pour l'aide au code en général.
• Passez à llama3:70b si vous faites des tâches qui exigent une grande précision — refactoring de bases de code complexes, débogage logique poussé, ou traitement de gros jeux de données où la justesse est critique. Ce modèle étant énorme, il réduit fortement les « hallucinations », ce qui en fait le choix le plus fiable pour un travail professionnel.

Télécharger vos modèles​

Vous pouvez ajouter n'importe lequel de ces modèles à votre environnement local immédiatement. Lancez simplement les commandes suivantes dans votre terminal :

Pour récupérer le modèle standard Llama 3 (8B) :

$ docker exec -it tags-ollama-1 ollama pull llama3:8b

Pour récupérer le très performant Llama 3 (70B) :

$ docker exec -it tags-ollama-1 ollama pull llama3:70b

Pour récupérer le modèle Mistral :

$ docker exec -it tags-ollama-1 ollama pull mistral

Note : le modèle 70b est bien plus gros (~40 Go). Assurez-vous d'avoir assez d'espace disque et, surtout, au moins 48 Go de RAM disponibles pour que le modèle tourne sans ralentir votre système.

Conclusion​

Deux petits scripts Python et un modèle local ont transformé un dossier d'articles Markdown en un index de tags et une série de suggestions de liens internes — aucune API cloud, aucun tag manuel, et rien dans ce pipeline n'est spécifique à Docusaurus. Faites pointer data/posts vers n'importe quel dossier de fichiers Markdown et les deux mêmes scripts feront le même travail.

Transformer une suggestion du type « les articles 002 et 004 sont liés » en un vrai <Link> dans le texte reste ici une étape manuelle — la suite logique, c'est que le second script propose la phrase exacte et le texte du lien, et pas seulement la paire de fichiers.