LLM local en Python : Démarrage rapide avec Ollama et LiteLLM

# LLM local en Python : Démarrage rapide avec Ollama et LiteLLM pour les développeurs

De nombreux développeurs qui se lancent dans l'univers des grands modèles de langage (LLM) rencontrent des obstacles : l'obligation de s'inscrire à des services cloud, de gérer des clés API et de faire face à des coûts continus en tokens. Bien que fonctionnelle, cette approche n'est pas toujours idéale pour les premières expérimentations et le développement local. Cet article présente une alternative efficace : déployer et intégrer des LLM directement sur votre ordinateur. Nous vous guiderons pas à pas pour configurer un environnement local avec Ollama pour exécuter les modèles et LiteLLM pour les intégrer dans des applications Python, en vous montrant comment obtenir votre première réponse significative de votre propre LLM sans dépendre de services externes.

Avantages du développement local avec des LLM

Le déploiement local de LLM offre plusieurs avantages indéniables, particulièrement pour l'apprentissage et le prototypage. D'abord, il supprime totalement le besoin de clés API et les coûts financiers associés, permettant des expérimentations illimitées. Ensuite, il élimine la dépendance à une connexion internet pour chaque requête, ce qui est crucial pour le développement hors ligne ou dans des environnements à réseau instable. Enfin, cette approche rend le processus d'interaction avec le LLM hautement transparent : vous pouvez observer comment votre code Python communique avec LiteLLM, qui transmet la requête à Ollama, puis au modèle local. Ce n'est pas de la "magie IA", mais une logique logicielle clairement traçable, simplifiant grandement le débogage et la compréhension architecturale. Pour les développeurs souhaitant bien saisir les mécanismes d'intégration des LLM, une approche locale est le point de départ idéal.

Ollama et LiteLLM : Composants architecturaux clés

Avant de plonger dans l'installation, il est essentiel de distinguer les fonctions des deux outils principaux que nous utiliserons : Ollama et LiteLLM.

Ollama est un outil puissant pour exécuter des grands modèles de langage en local. Il agit comme un serveur qui gère le téléchargement, le stockage et l'exécution des LLM sur votre ordinateur, en fournissant une API unifiée pour y accéder. En substance, Ollama est un runtime pour les LLM locaux, facilitant le travail avec divers modèles comme Llama, Mistral, Qwen, et bien d'autres.
LiteLLM est une bibliothèque Python légère conçue pour unifier les requêtes API vers différents fournisseurs de LLM. Sa fonctionnalité clé est de fournir une interface unique pour interagir à la fois avec des services cloud (OpenAI, Anthropic, Google Gemini) et des solutions locales comme Ollama. Cela signifie qu'un code écrit pour un modèle local via LiteLLM peut être facilement adapté pour fonctionner avec des fournisseurs cloud avec des modifications minimes.

En résumé, Ollama "lance" le modèle local, LiteLLM fournit une façon standardisée d'interagir avec lui depuis Python, et votre code construit une application complète autour de cela.

Installation d'Ollama et téléchargement d'un modèle local

Pour commencer à travailler avec un LLM local, suivez ces étapes séquentielles.

Installation d'Ollama

D'abord, téléchargez et installez Ollama depuis le site officiel (ollama.com) pour votre système d'exploitation (Windows, macOS, Linux). Après l'installation, vérifiez son bon fonctionnement en exécutant cette commande dans votre terminal :

ollama --version

Une sortie affichant le numéro de version confirme qu'Ollama est prêt. Sur Windows, assurez-vous que l'icône Ollama (🦙) est présente dans la barre des tâches, indiquant un service en arrière-plan actif.

Téléchargement d'un LLM local

Ollama n'est pas un modèle en soi, mais une plateforme pour les exécuter. Maintenant, téléchargez un grand modèle de langage spécifique. Pour nos besoins, qwen2.5:3b est un excellent choix — c'est un modèle compact mais suffisamment puissant qui tourne bien sur la plupart des ordinateurs portables et supporte le français. Lancez le téléchargement via votre terminal :

ollama run qwen2.5:3b

La première fois, le modèle se téléchargera et sera sauvegardé localement. Une fois terminé, vous entrerez dans un chat interactif Ollama. Testez-le en posant une question en français, par exemple : Salut ! Explique en deux phrases ce qu'est Python. Si le modèle répond, vous avez franchi l'obstacle principal. Pour quitter le chat, tapez /bye.

Note : Si les performances de qwen2.5:3b sont insuffisantes pour votre matériel, essayez une version plus légère : ollama run qwen2.5:1.5b. La logique du code Python reste inchangée.

Préparation de votre environnement Python

Pour isoler les dépendances du projet, il est recommandé d'utiliser un environnement virtuel.

Créez un dossier de projet et entrez-y :

```bash

mkdir llm-chat

cd llm-chat

```

Initialisez un environnement virtuel :

```bash

python -m venv venv

```

Activez-le.

* Windows : venv\Scripts\activate

* macOS / Linux : source venv/bin/activate

Une activation réussie est indiquée par le préfixe (venv) dans votre ligne de commande.

Installez la bibliothèque LiteLLM :

```bash

pip install litellm

```

Tous les composants sont maintenant prêts pour coder.

Intégration d'un LLM en Python : Votre première requête

Créez un fichier nommé main.py à la racine de votre projet et ajoutez ce code :

from litellm import completion
 
MODEL = "ollama_chat/qwen2.5:3b"
API_BASE = "http://localhost:11434"
 

def ask(question: str) -> str:
    response = completion(
        model=MODEL,
        messages=[
            {"role": "user", "content": question}
        ],
        api_base=API_BASE,
        request_timeout=120,
    )
    return response.choices[0].message.content
 
answer = ask("Salut ! Écris une phrase courte sur Python.")
print(answer)

Exécutez le script depuis votre environnement virtuel activé :

python main.py

Si une réponse significative du modèle apparaît dans votre console, vous avez réussi à intégrer un LLM local dans votre code Python. C'est un moment pivotal, montrant comment un modèle abstrait devient un composant fonctionnel de votre application.

Analyse du code de `main.py`

Examinons les éléments principaux de ce script minimaliste mais fonctionnel :

from litellm import completion : Nous importons la fonction centrale completion de la bibliothèque LiteLLM, conçue pour envoyer des requêtes aux LLM.
MODEL = "ollama_chat/qwen2.5:3b" : Cette variable définit le modèle utilisé. Le préfixe ollama_chat/ indique à LiteLLM de diriger la requête vers le service Ollama local. Spécifiez ici le nom du modèle téléchargé (ex. : qwen2.5:1.5b).
API_BASE = "http://localhost:11434" : Spécifie l'adresse du serveur API Ollama local. Par défaut, Ollama tourne sur le port 11434.
messages=[{"role": "user", "content": question}] : C'est la structure fondamentale pour interagir avec la plupart des API LLM modernes. Les requêtes sont passées sous forme de liste de messages, chaque message ayant un role (ex. : "user", "assistant", "system") et un content (le texte du message). Même pour une simple question, cette structure est utilisée, posant les bases pour travailler avec l'historique des dialogues et le contexte.
request_timeout=120 : Définit le temps d'attente maximum pour une réponse du modèle en secondes. Les modèles locaux peuvent nécessiter plus de temps pour leur démarrage initial ou pour traiter des requêtes complexes.
response.choices[0].message.content : De l'objet de réponse complet renvoyé par le modèle, nous extrayons le texte généré directement. L'objet response contient de nombreuses autres informations utiles que nous pourrons explorer dans les parties suivantes.

Résolution des problèmes courants au démarrage

Lors de la configuration, vous pourriez rencontrer divers soucis. Voici les plus fréquents et leurs solutions :

Problème 1 : Connection refused ou Failed to connect

* Cause : Le service Ollama n'est pas lancé ou inaccessible.

* Solution : Vérifiez qu'Ollama est actif. Cherchez l'icône 🦙 dans la barre des tâches (Windows/macOS) ou exécutez ollama list dans le terminal. Si la commande répond, le service fonctionne.

Problème 2 : Model not found

* Cause : Le modèle spécifié dans le code n'a pas été téléchargé, ou son nom ne correspond pas.

* Solution : Exécutez ollama list pour voir les modèles locaux disponibles, puis corrigez le nom dans la variable MODEL de main.py.

Problème 3 : Réponse lente ou performances faibles

* Cause : Le premier lancement d'un modèle peut être lent à cause du chargement en mémoire, ou le modèle est trop exigeant pour votre matériel.

* Solution : Attendez plus longtemps. Fermez les applications gourmandes. Essayez une version plus légère, comme qwen2.5:1.5b.

Problème 4 : ModuleNotFoundError: No module named 'litellm'

* Cause : Le script a été exécuté hors de l'environnement virtuel activé où LiteLLM est installé.

* Solution : Assurez-vous d'avoir activé l'environnement virtuel (préfixe (venv) dans le terminal) avant de lancer le script.

Problème 5 : Problèmes d'encodage dans PowerShell (caractères corrompus)

* Cause : Incompatibilité d'encodage du terminal.

* Solution : Dans PowerShell, exécutez $OutputEncoding = [System.Text.Encoding]::UTF8 avant le script.

Points clés à retenir

Le déploiement local de LLM avec Ollama et LiteLLM évite les coûts API et la dépendance internet, offrant un contrôle total.
Ollama sert de runtime pour les modèles locaux, tandis que LiteLLM unifie l'API pour interagir avec eux depuis Python.
La première étape consiste à installer Ollama et télécharger un modèle adapté, comme qwen2.5:3b.
Le script Python utilise litellm.completion pour envoyer des requêtes, où MODEL pointe vers le modèle local via ollama_chat/, et API_BASE spécifie l'adresse Ollama.
Les requêtes au LLM sont passées comme une liste de messages avec rôles (role) et contenu (content), formant la base des systèmes conversationnels.

Conclusion et étapes suivantes

À ce stade, nous avons implémenté avec succès une intégration basique d'un LLM local dans une application Python. Le modèle est passé d'une technologie abstraite à un composant gérable capable de répondre aux requêtes directement depuis votre code. Cette étape importante ouvre la porte à davantage d'expérimentations et au développement d'applications IA plus complexes.

Dans la partie suivante, nous transformerons cet exemple minimal en un chat console complet, en ajoutant une boucle de conversation, la saisie utilisateur et une préparation basique pour gérer le contexte des dialogues. Cela vous permettra de passer des questions ponctuelles à une interaction interactive avec votre LLM local.

— Editorial Team