Comment configurer un environnement de développement IA local avec Ollama en 7 étapes

L'IA générative a transformé le quotidien des développeurs. Autocomplétion intelligente, génération de tests, refactoring assisté, documentation automatique — les gains de productivité sont réels. Mais pour les équipes françaises qui travaillent sur du code sensible, l'envoi systématique de code source vers des API cloud américaines pose un problème de conformité RGPD, de coût récurrent, et de dépendance à un service tiers.

La solution : Ollama. Cet outil open source (licence MIT) permet de télécharger, gérer et exécuter des modèles de langage directement sur votre machine ou votre serveur, avec une API REST compatible avec les outils de développement existants. Que vous soyez un développeur freelance qui veut un assistant IA privé, ou un CTO qui cherche à déployer une solution IA pour son équipe, ce guide vous amène de zéro à un environnement de développement IA local complet en 7 étapes.

Etape 1 : Installer Ollama et vérifier la compatibilité GPU

Exemple : une startup IA à Paris qui veut éliminer ses coûts API OpenAI

L'installation d'Ollama prend moins de 2 minutes sur Linux, macOS ou Windows. Sur Linux (le choix le plus courant pour les serveurs de développement), une seule commande suffit :

# Installation Ollama sur Linux
curl -fsSL https://ollama.com/install.sh | sh

# Verifier l'installation
ollama --version

# Verifier la detection GPU (NVIDIA)
nvidia-smi

# Verifier la detection GPU (AMD ROCm)
rocminfo

Ollama détecte automatiquement les GPU NVIDIA (via CUDA) et AMD (via ROCm). Pour les GPU NVIDIA, assurez-vous d'avoir les drivers CUDA 12.x installés — nvidia-smi doit afficher votre GPU avec sa VRAM disponible. Pour les GPU AMD, ROCm 6.x est requis. Si aucun GPU n'est détecté, Ollama bascule automatiquement en mode CPU, qui fonctionne mais sera 5 à 10 fois plus lent.

Voici les exigences GPU minimales par taille de modèle :

Pour une startup à Paris qui débute, un simple RTX 4060 (350 EUR environ) suffit pour faire tourner un modèle 7-8B qui couvre 80% des besoins de coding assisté. L'investissement est amorti en 2-3 mois comparé aux coûts API récurrents.

Etape 2 : Télécharger et gérer les modèles

Exemple : une agence web à Lyon qui teste différents modèles pour le pair programming IA

Ollama utilise un système de registre de modèles similaire à Docker Hub. Chaque modèle est identifié par un nom et une variante (tag). Le téléchargement est automatique — Ollama récupère les poids quantifiés optimisés pour votre hardware.

# Telecharger les modeles essentiels pour le developpement
ollama pull llama3.1:8b          # Modele generaliste - bon pour le chat et le raisonnement
ollama pull mistral:7b           # Excellent pour le francais et le code
ollama pull codegemma:7b         # Specialise code (Google) - completion et generation
ollama pull muse-glimmer:30b-q4  # Le dernier Meta - coding + tool use (si GPU 24 Go+)

# Lister les modeles installes
ollama list

# Informations detaillees sur un modele
ollama show llama3.1:8b

# Supprimer un modele pour liberer de l'espace
ollama rm codegemma:7b

# Tester un modele interactivement
ollama run mistral:7b "Ecris une fonction TypeScript qui valide un email avec regex"

Pour une agence web à Lyon qui teste plusieurs modèles, voici la stratégie recommandée : commencez par Mistral 7B (excellent en français, très bon pour le code), puis testez CodeGemma 7B pour la complétion inline, et gardez Llama 3.1 8B comme modèle de repli généraliste. Chaque modèle occupe 4-5 Go de disque en quantification 4-bit, donc prévoyez 20-30 Go d'espace disque libre pour stocker 4-5 modèles.

Ollama gère automatiquement le chargement/déchargement des modèles en VRAM. Quand vous passez d'un modèle à l'autre, le modèle précédent est déchargé pour libérer la mémoire GPU. Par défaut, Ollama garde le dernier modèle utilisé en mémoire pendant 5 minutes (OLLAMA_KEEP_ALIVE=5m) pour accélérer les requêtes suivantes.

Etape 3 : Configurer l'API REST locale pour vos applications

Exemple : un développeur backend à Toulouse qui intègre l'IA dans son API Node.js

Ollama expose une API REST sur le port 11434 par défaut. Cette API est compatible avec le format OpenAI, ce qui signifie que la plupart des bibliothèques client existantes (openai-node, langchain, etc.) fonctionnent sans modification en changeant simplement l'URL de base.

# Lancer le serveur Ollama (demarre automatiquement sur Linux via systemd)
ollama serve

# Tester l'API avec curl
curl http://localhost:11434/api/generate -d '{
  "model": "mistral:7b",
  "prompt": "Explique le pattern Repository en TypeScript",
  "stream": false
}'

# Endpoint compatible OpenAI (chat completions)
curl http://localhost:11434/v1/chat/completions -d '{
  "model": "mistral:7b",
  "messages": [
    {"role": "system", "content": "Tu es un assistant de developpement expert en TypeScript et Node.js."},
    {"role": "user", "content": "Comment implementer un middleware Express pour la validation JWT ?"}
  ]
}'

# Lister les modeles disponibles
curl http://localhost:11434/api/tags

Pour un développeur à Toulouse qui travaille sur une API Node.js, l'intégration est directe. Voici un exemple avec le SDK officiel OpenAI Node.js, qui fonctionne avec Ollama grâce à la compatibilité API :

// integration-ollama.ts
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "http://localhost:11434/v1",
  apiKey: "ollama", // Ollama n'exige pas de cle, mais le SDK en demande une
});

async function analyserCode(code: string): Promise<string> {
  const completion = await client.chat.completions.create({
    model: "mistral:7b",
    messages: [
      { role: "system", content: "Analyse ce code et suggere des ameliorations." },
      { role: "user", content: code },
    ],
    temperature: 0.3,
    max_tokens: 2048,
  });

  return completion.choices[0].message.content ?? "";
}

// Utilisation dans un endpoint Express
app.post("/api/review", async (req, res) => {
  const suggestions = await analyserCode(req.body.code);
  res.json({ suggestions });
});

L'avantage clé : zéro coût API par requête. Votre application peut appeler le modèle des milliers de fois par jour sans facture surprise. Et puisque tout tourne en local, la latence est réduite à 50-200 ms contre 500-2000 ms pour un appel API cloud.

Etape 4 : Intégrer Ollama dans VS Code avec Continue.dev

Exemple : un développeur front-end à Bordeaux qui veut un Copilot privé et gratuit

Continue.dev est l'extension VS Code open source la plus populaire pour connecter un LLM local à votre IDE. Elle offre l'autocomplétion de code, le chat contextuel, la génération de tests, et la revue de code — le tout alimenté par votre instance Ollama locale.

// ~/.continue/config.json
{
  "models": [
    {
      "title": "Mistral 7B (local)",
      "provider": "ollama",
      "model": "mistral:7b",
      "apiBase": "http://localhost:11434"
    },
    {
      "title": "Muse Glimmer 30B (local)",
      "provider": "ollama",
      "model": "muse-glimmer:30b-q4",
      "apiBase": "http://localhost:11434"
    }
  ],
  "tabAutocompleteModel": {
    "title": "CodeGemma (autocomplete)",
    "provider": "ollama",
    "model": "codegemma:7b",
    "apiBase": "http://localhost:11434"
  },
  "allowAnonymousTelemetry": false
}

Pour un développeur à Bordeaux qui utilise React et TypeScript au quotidien, Continue.dev avec un modèle local est une alternative crédible à GitHub Copilot. Les fonctionnalités clés :

• Tab autocomplete : complétion inline en temps réel, alimentée par CodeGemma 7B (rapide, spécialisé code).
• Chat contextuel (Ctrl+L) : posez des questions sur le fichier ouvert, obtenez des explications, des suggestions de refactoring.
• Edit inline (Ctrl+I) : sélectionnez du code et demandez une modification (« ajoute la gestion d'erreur », « convertis en async/await »).
• Génération de tests : sélectionnez une fonction et demandez « génère les tests unitaires avec Jest ».
• Zéro télémétrie : avec allowAnonymousTelemetry: false, aucune donnée ne quitte votre machine.

Le paramètre tabAutocompleteModel est crucial : utilisez un modèle petit et rapide (7B) pour l'autocomplétion temps réel (qui doit répondre en moins de 300 ms), et un modèle plus gros (30B) pour le chat et les tâches complexes où la qualité prime sur la vitesse.

Etape 5 : Créer un pipeline RAG local avec LangChain

Exemple : une équipe à Nantes qui veut un chatbot interne alimenté par sa documentation technique

Le RAG (Retrieval-Augmented Generation) permet de connecter un modèle IA à vos propres données — documentation technique, base de connaissances, code source. Avec Ollama et LangChain, vous pouvez construire un pipeline RAG entièrement local, sans envoyer vos documents à un service cloud.

# Installation des dependances
pip install langchain langchain-community chromadb ollama

# pipeline_rag.py
from langchain_community.llms import Ollama
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain_community.document_loaders import DirectoryLoader, TextLoader

# 1. Charger vos documents (Markdown, texte, code)
loader = DirectoryLoader("./docs/", glob="**/*.md", loader_cls=TextLoader)
documents = loader.load()

# 2. Decouper en chunks
splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = splitter.split_documents(documents)

# 3. Creer les embeddings locaux (Ollama)
embeddings = OllamaEmbeddings(model="nomic-embed-text", base_url="http://localhost:11434")

# 4. Stocker dans ChromaDB (local)
vectorstore = Chroma.from_documents(chunks, embeddings, persist_directory="./chroma_db")

# 5. Creer la chaine de question-reponse
llm = Ollama(model="mistral:7b", base_url="http://localhost:11434")
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=vectorstore.as_retriever(search_kwargs={"k": 4}),
)

# 6. Poser une question sur votre documentation
result = qa_chain.invoke("Comment configurer l'authentification JWT dans notre API ?")
print(result["result"])

Pour une équipe à Nantes qui veut un assistant interne alimenté par sa documentation API et ses conventions de code, ce pipeline se met en place en une après-midi. Les composants clés sont tous locaux : Ollama pour le LLM, nomic-embed-text pour les embeddings (modèle d'embedding léger qui tourne aussi dans Ollama), et ChromaDB comme base de données vectorielle locale. Notre guide détaillé sur le déploiement d'un pipeline RAG open source couvre les aspects avancés : chunking adaptatif, re-ranking, et évaluation de la qualité des réponses.

Etape 6 : Optimiser les performances et la mémoire

Exemple : un développeur à Strasbourg avec un GPU 12 Go qui veut maximiser les performances

L'optimisation d'Ollama passe par trois leviers : la quantification, les variables d'environnement, et le profil de chargement GPU/CPU.

# Variables d'environnement Ollama (a ajouter dans ~/.bashrc ou /etc/environment)

# Nombre de couches chargees sur le GPU (ajuster selon VRAM)
export OLLAMA_NUM_GPU=35        # Defaut: auto. Reduire si OOM errors

# Temps de conservation du modele en memoire (defaut: 5m)
export OLLAMA_KEEP_ALIVE=30m    # Garder le modele 30 min apres derniere requete

# Nombre de threads CPU (pour le chargement et les couches CPU)
export OLLAMA_NUM_THREAD=8      # Ajuster au nombre de coeurs physiques

# Taille du batch (requetes simultanes)
export OLLAMA_NUM_PARALLEL=2    # Permet 2 requetes en parallele

# Adresse d'ecoute (par defaut localhost uniquement)
export OLLAMA_HOST=0.0.0.0:11434  # Ecouter sur toutes les interfaces (pour serveur partage)

# Repertoire de stockage des modeles (par defaut ~/.ollama)
export OLLAMA_MODELS=/data/ollama/models  # Pointer vers un SSD rapide

# Redemarrer le service apres modification
sudo systemctl restart ollama

Pour un développeur à Strasbourg avec un GPU de 12 Go (RTX 4070), la stratégie optimale est d'utiliser des modèles 8B en quantification Q4_K_M (le meilleur rapport qualité/taille). Si le modèle ne tient pas entièrement en VRAM, Ollama répartit automatiquement les couches entre GPU et CPU (offloading partiel). Réduisez OLLAMA_NUM_GPU pour contrôler manuellement combien de couches vont sur le GPU.

Autre optimisation clé : le flash attention. Si votre GPU le supporte (NVIDIA Ampere ou supérieur, soit RTX 3000+ ou A100+), Ollama l'active automatiquement. Flash attention réduit la consommation mémoire et accélère le traitement des longs contextes — un gain de 20-40% sur les prompts dépassant 4K tokens.

Etape 7 : Déployer en équipe avec Docker Compose

Exemple : une équipe de 8 développeurs à Lille qui centralise son instance IA

Pour une équipe de développement, la meilleure approche est de centraliser Ollama sur un serveur partagé avec un GPU dédié, accessible à tous les développeurs via le réseau local ou un VPN. Docker Compose simplifie ce déploiement.

# docker-compose.yml
version: "3.8"

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama-server
    restart: unless-stopped
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    environment:
      - OLLAMA_KEEP_ALIVE=60m
      - OLLAMA_NUM_PARALLEL=4
      - OLLAMA_HOST=0.0.0.0

  nginx:
    image: nginx:alpine
    container_name: ollama-proxy
    restart: unless-stopped
    ports:
      - "8080:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - ollama

volumes:
  ollama_data:

# nginx.conf — reverse proxy avec authentification basique
events { worker_connections 128; }

http {
  upstream ollama {
    server ollama:11434;
  }

  server {
    listen 80;

    # Authentification basique
    auth_basic "Ollama API";
    auth_basic_user_file /etc/nginx/.htpasswd;

    # Rate limiting
    limit_req_zone $binary_remote_addr zone=api:10m rate=30r/m;

    location / {
      limit_req zone=api burst=10;
      proxy_pass http://ollama;
      proxy_set_header Host $host;
      proxy_read_timeout 300s;  # Timeout long pour les requetes d'inference
    }
  }
}

# Demarrer la stack
docker compose up -d

# Telecharger les modeles dans le conteneur
docker exec -it ollama-server ollama pull mistral:7b
docker exec -it ollama-server ollama pull muse-glimmer:30b-q4

# Creer le fichier d'authentification
docker exec -it ollama-proxy sh -c "apk add apache2-utils && htpasswd -bc /etc/nginx/.htpasswd dev motdepasse123"

# Tester depuis un poste developpeur
curl -u dev:motdepasse123 http://serveur-ia.internal:8080/api/tags

Pour l'équipe de 8 développeurs à Lille, cette architecture fournit un serveur IA partagé avec authentification, rate limiting, et gestion centralisée des modèles. Chaque développeur configure Continue.dev pour pointer vers http://serveur-ia.internal:8080 avec les credentials d'authentification. Le reverse proxy Nginx permet également d'ajouter du TLS (Let's Encrypt) pour les accès distants, et des logs d'accès pour monitorer l'utilisation. Pour un guide complet sur cette architecture, consultez notre article déployer Ollama en production sécurisée avec Docker.

Ce que ça signifie pour vous : récapitulatif et prochaines étapes

Vous avez désormais un environnement de développement IA local complet : Ollama fait tourner les modèles, Continue.dev fournit l'interface IDE, LangChain connecte le tout à vos données, et Docker Compose permet le déploiement en équipe. Le tout sans envoyer un seul octet de code vers le cloud.

Les prochaines étapes pour aller plus loin :

• Fine-tuning : créez un modèle spécialisé sur votre base de code avec Ollama create et un Modelfile personnalisé. Voir notre guide de fine-tuning.
• Monitoring : ajoutez Prometheus + Grafana pour surveiller l'utilisation GPU, les temps de réponse, et le nombre de requêtes par développeur.
• Agents IA : utilisez Muse Glimmer 30B (Apache 2.0) pour construire des agents agentiques locaux capables d'orchestrer des workflows de développement complets.
• Sécurité : auditez régulièrement vos modèles et votre infrastructure avec notre checklist dans le guide de sécurisation des pipelines IA.

FAQ — Questions fréquentes