Le problème principal

La question centrale est : comment intégrer une IA puissante dans notre entreprise ou nos projets sans dépendre d’un fournisseur externe, afin de garder nos données privées ?

La solution : Ollama

Je pense qu’Ollama offre le meilleur des deux mondes. D’une part, Ollama est auto‑hébergeable, ce qui vous permet d’importer de nombreux modèles open‑source provenant de différents fournisseurs (Meta, Microsoft, Mistral AI, etc.). D’autre part, grâce à la quantisation des modèles, Ollama délivre d’excellentes performances même sur un petit serveur.

Ollama est disponible sur toutes les plateformes (Linux, macOS, Windows) et se télécharge en une seule commande. De plus, Ollama ne se limite pas à être un simple LLM local ; il ouvre la porte à des cas d’usage avancés (RAG, documentation, automatisation, …) et l’intégration se fait via un unique point d’accès API.

Ollama s’intègre à de nombreux outils : notebooks, recherches web, IDE, etc. Pour les développeurs et les professionnels, c’est un véritable changeur de jeu ; les possibilités sont impressionnantes.

Mise en route

Étape 1 : téléchargement

Tout d’abord, téléchargez Ollama sur votre ordinateur ou serveur :

curl -fsSL https://ollama.com/install.sh | sh

Cette commande télécharge Ollama, installe la boîte à outils associée et prépare votre environnement IA. Aucun modèle n’est fourni par défaut.

Étape 2 : vérification

Vérifiez que l’installation s’est bien déroulée :

ollama serve
# ou simplement
ollama

Étape 3 : téléchargement d’un modèle

Nous devons maintenant télécharger un modèle pour pouvoir discuter !

Le premier modèle que nous allons utiliser est Phi‑3 de Microsoft. Ce modèle représente un excellent compromis entre performances et taille ; il fonctionne parfaitement sur un ordinateur portable avec 8 Go de RAM et convient aux tests locaux ou à une petite production interne.

Nous utiliserons la version phi3:3.8b, d’une taille raisonnable (2,2 Go) et d’une fenêtre de contexte de 128 K.

ollama run phi3:3.8b

Étape 4 : vérification des modèles

Assurez‑vous que le modèle a bien été téléchargé et qu’il est prêt à l’emploi :

ollama list   # liste les modèles téléchargés
# ou
ollama ps     # montre les modèles en cours d’exécution

Vous devriez voir quelque chose de similaire :

Utilisation

Une fois le modèle prêt, plusieurs méthodes permettent d’interagir avec lui :

Via le terminal

ollama run phi3

Vous obtenez alors un prompt interactif pour discuter avec le modèle.

Via cURL

Vous pouvez envoyer des requêtes HTTP avec cURL :

curl -X POST http://localhost:11434/api/generate -d '{
  "model": "phi3:3.8b",
  "prompt": "Bonjour, comment ça va ?",
  "stream": false
}'

Cette approche est très pratique pour l’intégrer à des scripts bash ou créer votre propre interface de chat.

Le paramètre stream est crucial ; réglé à true, il permet d’obtenir des réponses en temps réel, à l’image de ChatGPT.

Nous pouvons imaginer de nombreux cas d’usage : génération de code, documentation, tests automatisés, etc.

Via Python

Ollama propose une bibliothèque Python officielle, très simple d’utilisation. Vous la trouverez sur GitHub.

from ollama import chat

response = chat(
    model='phi3',
    messages=[{'role': 'user', 'content': 'Bonjour !'}],
)
print(response.message.content)

Vous pouvez également appeler directement l’API HTTP :

import requests

ollama_url = "http://localhost:11434/api/generate"

res = requests.post(ollama_url, json={
    "model": "phi3",
    "prompt": "Bonjour, comment ça va ?",
    "stream": False
})

print(res.json())

Si Ollama tourne localement, la bibliothèque Python suffit. En cas d’exécution dans un conteneur distant, il suffit d’ajuster l’URL ou d’utiliser la méthode requests.

Utilisation d’Ollama avec Docker

À mon avis, Docker est la meilleure solution pour déployer Ollama en production. Cela permet d’obtenir d’excellentes performances même sur un serveur modeste, tout en restant simple à déployer.

Voici un exemple de fichier docker‑compose.yml :

services:
  ollama:
    image: ollama/ollama
    container_name: ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    restart: unless-stopped

volumes:
  ollama_data:

Cette image officielle, disponible sur Docker Hub, est optimisée pour la performance.

Exemple de structure de projet avec Ollama

.
├── __pycache__
│   ├── locustfile.cpython-311.pyc
│   └── main.cpython-314.pyc
├── docker-compose.yml
├── Dockerfile
├── get_reportings.py
├── jmeter
│   ├── __pycache__
│   ├── plan.jmx
│   └── results.jtl
├── locustfile.py
├── main.py
├── prometheus
│   └── prometheus.yml
├── pytest.ini
├── README.md
├── reports
├── requirements.txt
├── sonar-project.properties
└── tests
    ├── __pycache__
    └── test_api.py

Le fichier principal illustrant la puissance d’Ollama

import requests
import datetime

query = "http_requests_created[1m]"
ollama_url = "http://localhost:11434/api/generate"
url = f"http://localhost:9090/api/v1/query?query={query}"

response = requests.get(url).json()

try:
    with open("jmeter/results.jtl", "r", encoding="utf-8") as f:
        jmeter_content = f.read()
except FileNotFoundError:
    print("Fichier de résultats JMeter introuvable.\n")
    jmeter_content = "Aucun résultat JMeter disponible."

prompt = f"""
Analyse ces métriques provenant de Prometheus :

{response}

Fournis‑moi un rapport avec la structure suivante :

# titre

## Analyse des métriques provenant de Prometheus.

### Votre analyse (max 5‑6 lignes)

### Comment améliorer ou corriger (max 2 lignes)
"""

res = requests.post(ollama_url, json={
    "model": "phi3",
    "prompt": prompt,
    "stream": False
})

now = datetime.datetime.now().strftime("%Y-%m-%d_%H-%M")

with open(f"reports/report_{now}.md", "w", encoding="utf-8") as f:
    f.write("Rapport Prometheus\n\n")
    f.write(res.json()['response'])
    f.write("\n\n")

Nous utilisons l’URL locale d’Ollama car le projet tourne sous Docker ; le script s’exécute sur ma machine, pas dans le conteneur, d’où l’usage de localhost au lieu du nom du conteneur.

Ce script récupère des données depuis JMeter et Prometheus, envoie un prompt simple à Ollama (modèle phi3:3.8b) et génère un rapport au format Markdown, stocké dans le répertoire reports/ sous le nom report_YYYY‑MM‑DD_HH‑MM.md.

Il s’agit d’un exemple très basique, mais il montre bien ce que l’on peut faire avec Ollama.

Conclusion

Pour moi, Ollama est un outil exceptionnel pour les développeurs et les professionnels qui souhaitent exploiter des LLM localement, sans connexion Internet et avec une interface ultra‑simple.

Il est totalement gratuit et open‑source ; vous pouvez l’utiliser pour des projets sérieux ou simplement pour le plaisir. Les possibilités sont très impressionnantes.

Je n’ai pas encore exploré toutes les potentialités d’Ollama, mais je prévois de le faire à l’avenir : par exemple, l’associer à Open‑Claw, Claude, ou à tout autre fournisseur compatible.