AI Agents · Leçon

Exécuter des modèles locaux avec Ollama et llama.cpp

Ollama transforme l’exécution des LLM en une commande « docker run » ; llama.cpp va plus loin avec la quantification et un contrôle direct en C++.

Exécuter des modèles locaux avec Ollama et llama.cpp est une leçon AI Agents gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Agents, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Agents comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Deux voies simples

Pour auto-héberger des modèles ouverts sur une station de travail ou un serveur :

Ollama : le plus simple, avec une expérience proche de Docker pour les modèles de langage
llama.cpp : plus proche du matériel, davantage de contrôle et une empreinte plus réduite

Ollama Quick Start

# Install (macOS):
brew install ollama

# Pull a model:
ollama pull llama3.1:8b

# Run interactively:
ollama run llama3.1:8b 'Hello'

# Serve via HTTP (OpenAI-compatible):
ollama serve

Calling Ollama Via SDK

from openai import OpenAI
client = OpenAI(base_url='http://localhost:11434/v1', api_key='ollama')

response = client.chat.completions.create(
    model='llama3.1:8b',
    messages=[{'role': 'user', 'content': 'Hello'}]
)
print(response.choices[0].message.content)

Appels d'outils avec Ollama

Ollama prend en charge les appels d'outils pour les modèles compatibles (Llama 3.1+, Mistral, Qwen 2.5) :

tools = [{'type': 'function', 'function': {...}}]
response = client.chat.completions.create(
    model='llama3.1:8b',
    messages=messages,
    tools=tools
)

Principes de base de llama.cpp

llama.cpp est une implémentation en C++ qui exécute n'importe quel modèle au format GGUF (ANY) sur CPU, GPU ou Metal (Apple Silicon) :

# Build (or install pre-built):
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp && make

# Run a quantized model:
./llama-cli -m models/llama-3.1-8b-instruct.Q4_K_M.gguf -p 'Hello'

Server Mode

./llama-server -m models/llama-3.1-8b-instruct.Q4_K_M.gguf --port 8080

# Now OpenAI-compatible endpoint at http://localhost:8080/v1

Quantification

La quantification sur 4 bits (Q4_K_M) vous permet d'exécuter un modèle de « 16GB » avec environ 5GB de RAM, au prix d'une perte de qualité marginale. Essayez d'abord Q4 ; choisissez une quantification supérieure (Q5, Q6, Q8) pour les tâches où la qualité est essentielle.

Configuration matérielle requise

Modèle	RAM Q4	VRAM Q4
7-8B	~6 GB	~6 GB
13B	~10 GB	~10 GB
70B	~40 GB	~40 GB

La mémoire unifiée d'Apple Silicon rend les grands modèles locaux étonnamment utilisables.

vLLM pour le débit

Pour servir des modèles en production avec une forte concurrence, utilisez vLLM (PagedAttention, traitement par lots continu) :

# pip install vllm
from vllm import LLM, SamplingParams
llm = LLM(model='meta-llama/Llama-3.1-8B-Instruct')

params = SamplingParams(temperature=0.2, max_tokens=512)
result = llm.generate(['Hello world'], params)

Inférence de génération de texte (TGI)

HuggingFace TGI est un autre serveur de production. Il offre une bonne prise en charge de l'utilisation des outils.

Comparer les serveurs

Ollama : meilleure expérience utilisateur, CLI/HTTP simple, adapté au développement
llama.cpp : le plus léger, s'exécute partout
vLLM : débit le plus élevé, réservé aux GPU
TGI : intégration HuggingFace, supervision

Quand s'auto-héberger

Confidentialité stricte
Très gros volume, avec un seuil de rentabilité d'environ 10M jetons par jour
Modèles réglés finement
Scénarios en périphérie ou hors ligne

Quand NOT s'auto-héberger

Petits projets annexes, pour lesquels l'hébergement est moins coûteux
Qualité de raisonnement de pointe requise
Tâches multimodales

Point de terminaison compatible avec OpenAI

Pourquoi la convention du point de terminaison compatible avec OpenAI est-elle pratique pour les modèles locaux ?

Récapitulatif

Ollama pour la simplicité en développement, llama.cpp pour la portabilité et vLLM pour le débit en production. Tous utilisent des API suivant le format d'OpenAI, ce qui permet de les remplacer sans modifier le code.

Questions Fréquemment Posées

La leçon « Exécuter des modèles locaux avec Ollama et llama.cpp » est-elle gratuite ?

Oui — le texte complet de « Exécuter des modèles locaux avec Ollama et llama.cpp » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Agents, passe à CoddyKit PRO. Le cours AI Agents comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Exécuter des modèles locaux avec Ollama et llama.cpp » ?

Ollama transforme l’exécution des LLM en une commande « docker run » ; llama.cpp va plus loin avec la quantification et un contrôle direct en C++. Tu pratiques AI Agents avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Agents ?

Aucune expérience préalable n'est requise. AI Agents sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Exécuter des modèles locaux avec Ollama et llama.cpp » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Agents ?

Oui. Chaque leçon AI Agents inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Présentation de Llama, Mistral et Qwen
Exécuter des modèles locaux avec Ollama et llama.cpp
Appels de fonctions avec des modèles ouverts (Hermes, Functionary)
Compromis : latence, coût et capacités

← Retour à AI Agents