Points clés
- Ollama expose une API REST sur `http://localhost:11434/v1` qui reproduit exactement l'API OpenAI.
- Bibliothèque Python OpenAI : remplacez `api_key="openai"` par `api_key="ollama"` et définissez `base_url="http://localhost:11434/v1"`.
- Même approche en Node.js : SDK OpenAI pointé vers localhost:11434.
- L'API compatible OpenAI est identique sur Ollama, vLLM et LM Studio -- aucun changement de code pour changer de fournisseur.
- Depuis avril 2026, le streaming (token par token) et les appels de fonctions fonctionnent avec les modèles locaux via cette API.
- Aider, Cline et Roo Code se connectent tous aux modèles locaux via ce même réglage base_url -- aucune intégration séparée nécessaire.
Que signifie « compatible OpenAI » ?
Compatible OpenAI signifie que l'endpoint API retourne des réponses dans le même format que l'API OpenAI. Tout outil ou bibliothèque conçu pour OpenAI fonctionne avec des modèles locaux en changeant simplement l'URL. Découvrez comment Ollama vs LM Studio implémentent ce standard.
Exemple : la bibliothèque Python OpenAI envoie des requêtes ainsi :
``` POST /chat/completions { "model": "gpt-4o", "messages": [...], "temperature": 0.7 } ```
L'API Ollama accepte exactement la même requête sur `localhost:11434/v1/chat/completions` et retourne la réponse au format OpenAI :
``` { "choices": [{"message": {"content": "..."}}], "usage": {"prompt_tokens": 10, "completion_tokens": 20} } ```
Le format étant identique, vous n'avez pas besoin d'apprendre une nouvelle API ni de réécrire votre code.
Quel est l'endpoint API d'Ollama ?
**En exécutant `ollama serve`, Ollama démarre une API REST sur `http://localhost:11434`.** Les endpoints compatibles OpenAI sont :
| Point de terminaison | URL | Description |
|---|---|---|
| Chat Completions | POST http://localhost:11434/v1/chat/completions | Correspond à `/chat/completions` d'OpenAI |
| Text Completions | POST http://localhost:11434/v1/completions | Correspond à `/completions` d'OpenAI |
| Embeddings | POST http://localhost:11434/v1/embeddings | Convertit du texte en vecteurs |
| List Models | GET http://localhost:11434/v1/models | Liste les modèles disponibles |
Comment utiliser l'API Ollama avec Python (bibliothèque OpenAI) ?
Installez la bibliothèque OpenAI et pointez-la sur localhost.
# 1. Install the OpenAI library
pip install openai
# 2. Connect to Ollama
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:11434/v1",
api_key="ollama" # dummy key; Ollama ignores it
)
# 3. Make a request
response = client.chat.completions.create(
model="llama3.2:3b",
messages=[
{"role": "user", "content": "What is 2+2?"}
]
)
print(response.choices[0].message.content)Comment utiliser l'API Ollama avec Node.js ?
Installez le SDK OpenAI et connectez-le à votre instance Ollama locale.
// 1. Install
npm install openai
// 2. Connect to Ollama
const OpenAI = require("openai").default;
const client = new OpenAI({
baseURL: "http://localhost:11434/v1",
apiKey: "ollama"
});
// 3. Make a request
const response = await client.chat.completions.create({
model: "llama3.2:3b",
messages: [{
role: "user",
content: "What is 2+2?"
}]
});
console.log(response.choices[0].message.content);Comment utiliser le serveur compatible OpenAI de LM Studio (localhost:1234) ?
**LM Studio expose une API compatible OpenAI sur `http://localhost:1234/v1`.** Activez-la sous l'onglet Local Server -- chargez un modèle, puis cliquez sur Start Server. Le même code Python et Node.js fonctionne avec LM Studio -- changez uniquement le port de 11434 à 1234.
LM Studio convient aux utilisateurs GUI qui souhaitent parcourir les modèles visuellement. Ollama est préférable pour les scripts, l'automatisation et les pipelines CI.
| Plateforme | Port | Idéal pour | GPU requis |
|---|---|---|---|
| LM Studio | localhost:1234 | Utilisateurs GUI, gestion visuelle des modèles | Non (CPU fonctionne) |
| Ollama | localhost:11434 | Scripts, automatisation, production | Non (CPU fonctionne) |
| vLLM | localhost:8000 | Multi-GPU, serveurs haute performance | Recommandé |
# Python: Connect to LM Studio (localhost:1234)
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:1234/v1",
api_key="lm-studio" # any string; LM Studio ignores it
)
response = client.chat.completions.create(
model="llama-3.2-3b-instruct", # exact model name shown in LM Studio
messages=[
{"role": "user", "content": "What is 2+2?"}
]
)
print(response.choices[0].message.content)Comment utiliser l'API Ollama depuis JavaScript dans le navigateur ?
L'appel d'Ollama depuis JavaScript côté navigateur nécessite que le navigateur et le serveur soient sur la même machine (ou que CORS soit autorisé). Pour des raisons de sécurité, les requêtes vers localhost ne fonctionnent que si le JavaScript est servi depuis localhost. Consultez les Meilleures interfaces LLM locaux pour des UI prêtes pour le navigateur.
Pour appeler Ollama depuis un navigateur sur une IP différente, configurez un proxy CORS ou utilisez un middleware côté serveur.
// Browser-side JavaScript (if server is localhost:3000, Ollama is localhost:11434)
fetch("http://localhost:11434/v1/chat/completions", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
model: "llama3.2:3b",
messages: [{ role: "user", content: "What is 2+2?" }]
})
})
.then(res => res.json())
.then(data => console.log(data.choices[0].message.content))Comment diffuser les réponses token par token ?
Le streaming permet d'afficher les réponses au fur et à mesure de leur génération, token par token, sans attendre la réponse complète. Depuis avril 2026, le streaming fonctionne avec tous les modèles locaux via l'API compatible OpenAI.
# Python: streaming example
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:11434/v1",
api_key="ollama"
)
stream = client.chat.completions.create(
model="llama3.2:3b",
messages=[{"role": "user", "content": "Count to 10"}],
stream=True
)
for chunk in stream:
if chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
Votre modèle local peut-il appeler des fonctions ?
Oui, depuis avril 2026, les appels de fonctions fonctionnent avec les modèles locaux via l'API OpenAI. Vous définissez un schéma de fonction et le modèle peut répondre avec des arguments. Cela permet aux Meilleurs LLM locaux pour le code de s'intégrer à votre écosystème d'outils.
La prise en charge des appels de fonctions dépend du modèle. Llama 3.3 8B, Qwen3 7B et la plupart des modèles récents la supportent. Les modèles plus petits (3B) peuvent ne pas l'utiliser de manière fiable.
Lors de l'utilisation d'API compatibles OpenAI localement, les sorties structurées et le mode JSON fonctionnent de la même manière qu'avec les API cloud. Pour contrôler la conformité des schémas et le format sur les modèles locaux et cloud, consultez sorties structurées et mode JSON.
Les APIs compatibles avec OpenAI acceptent les mêmes formats de prompt que les versions cloud — messages système, messages utilisateur et sortie structurée. La bibliothèque complète des techniques de prompt engineering s'applique directement aux appels d'API locaux.
# Example: local model calls a weather function
tools = [{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get current weather",
"parameters": {
"type": "object",
"properties": {
"location": {"type": "string"}
}
}
}
}]
response = client.chat.completions.create(
model="llama3.2:8b",
messages=[{"role": "user", "content": "What is the weather in SF?"}],
tools=tools
)
# Check if model returned a function call
if response.choices[0].message.tool_calls:
call = response.choices[0].message.tool_calls[0]
print(f"Call function: {call.function.name} with {call.function.arguments}")
Comment connecter Aider, Cline ou Roo Code à un modèle local ?
**Pointez Aider, Cline ou Roo Code vers la même base_url compatible OpenAI utilisée ailleurs dans ce guide -- `http://localhost:11434/v1` pour Ollama ou `http://localhost:1234/v1` pour LM Studio -- et utilisez n'importe quelle chaîne comme clé API.** Les trois outils proposent un mode de fournisseur générique « OpenAI Compatible » conçu exactement pour ce cas.
Cline et Roo Code (un fork de Cline) partagent le même schéma de configuration : ouvrez les paramètres de l'extension dans VS Code, sélectionnez le fournisseur API OpenAI Compatible, saisissez la Base URL et une clé API quelconque, puis indiquez le nom exact du modèle affiché par `ollama list` ou le navigateur de modèles de LM Studio.
Aider se connecte via la même couche compatible OpenAI grâce aux variables d'environnement `OPENAI_API_BASE` et `OPENAI_API_KEY` (ou aux options en ligne de commande équivalentes), pointées vers votre serveur local. Aider dispose aussi d'une prise en charge native d'Ollama via son propre préfixe de fournisseur -- consultez la documentation actuelle d'Aider pour la méthode recommandée, les noms exacts des options changeant d'une version à l'autre.
Utilisez Aider, Cline ou Roo Code avec des modèles locaux si : vous voulez zéro coût d'API pendant le développement, votre code ne doit pas quitter votre machine, ou vous testez des prompts avant de basculer vers un modèle cloud en production. Évitez les modèles locaux dans ces outils si vous avez besoin d'un raisonnement sur un contexte plus long que ce qu'un modèle avec 8 à 24 Go de VRAM peut gérer fiablement -- passez alors à un modèle cloud ou à un modèle local plus grand (Llama 4 Scout).
| Outil | Emplacement de configuration | Base URL locale |
|---|---|---|
| Cline | Paramètres de l'extension VS Code → API Provider → OpenAI Compatible | http://localhost:11434/v1 (Ollama) ou :1234/v1 (LM Studio) |
| Roo Code | Paramètres de l'extension VS Code → API Provider (même schéma que Cline) | http://localhost:11434/v1 (Ollama) ou :1234/v1 (LM Studio) |
| Aider | Variables d'environnement OPENAI_API_BASE / OPENAI_API_KEY ou options CLI | http://localhost:11434/v1 (Ollama) ou :1234/v1 (LM Studio) |
API LLM locaux par région
UE / RGPD : Pour les développeurs européens, exécuter Ollama en local garantit la conformité à l'article 5 du RGPD (minimisation des données) -- toute inférence reste sur l'appareil sans transfert de données vers des API cloud. La CNIL recommande l'inférence locale pour les applications professionnelles traitant des données sensibles (financières, médicales, juridiques), ce qui fait d'Ollama et LM Studio des choix privilégiés pour les entreprises soumises au droit français. Pour les entreprises, cela élimine la dépendance fournisseur -- les données d'entrée ne quittent pas votre propre réseau (aucun risque de transfert transfrontalier art. 44 RGPD pour les données d'inférence).
Japon / APPI : En vertu de la loi japonaise sur la protection des informations personnelles (APPI), l'inférence sur site contourne les exigences de transfert de données cloud. Ollama + Qwen3 7B fonctionne sur des ordinateurs portables d'entreprise standard (8 Go de RAM) avec une latence de 30 à 50 tok/sec.
Chine / CAC : Pour un déploiement sous la loi sur la cybersécurité (article 37 du CAC), l'inférence locale satisfait les mandats de localisation des données. Ollama + Qwen3 fonctionne sur n'importe quel appareil Linux sans appels API externes.
Quelles sont les erreurs courantes avec les API OpenAI de LLM locaux ?
- Oublier que la clé API est ignorée. Ollama requiert `api_key="ollama"` (n'importe quelle chaîne fonctionne) car il n'authentifie pas. La vraie sécurité vient du fait que la requête provient de localhost.
- Ne pas réaliser que le nom du modèle est important. Si vous appelez `/chat/completions` avec `model="gpt-4"` mais n'avez téléchargé que `llama3.2:3b` dans Ollama, la requête échouera. Utilisez les noms exacts de `ollama list`.
- Supposer qu'Ollama nécessite internet. Ce n'est pas le cas. Mais si votre code Python tente d'abord d'atteindre les serveurs OpenAI, il échouera. Définissez toujours `base_url` explicitement.
- Erreurs CORS depuis le navigateur. Si vous appelez Ollama depuis un script côté navigateur et obtenez une erreur CORS, le navigateur a bloqué la requête. Voir LLM locaux avec VS Code et Cursor pour des solutions.
- Ne pas définir stream=True pour le streaming. Si vous souhaitez des réponses token par token, vous devez explicitement définir `stream=True`.
Questions fréquentes sur les API LLM locaux
Dois-je modifier mon code OpenAI pour utiliser Ollama ?
Non. Définissez `base_url="http://localhost:11434/v1"` et `api_key="ollama"`. Tout le reste reste identique. Si vous avez du code utilisant la bibliothèque OpenAI, échangez ces deux lignes et il fonctionne avec votre modèle local.
Puis-je utiliser l'API depuis un autre ordinateur sur mon réseau ?
Oui. Par défaut, Ollama écoute uniquement sur localhost. Pour autoriser l'accès réseau, définissez la variable d'environnement `OLLAMA_HOST=0.0.0.0:11434` avant de lancer Ollama. Pointez ensuite votre code sur `http://<ip-machine>:11434/v1`. Utilisez un pare-feu en production.
LM Studio dispose-t-il d'une API compatible OpenAI ?
Oui. LM Studio expose une API compatible OpenAI sur `http://localhost:1234/v1`. Activez-la sous l'onglet Local Server, chargez un modèle, puis cliquez sur Start Server. Utilisez le même code Python ou Node.js qu'Ollama -- seul le port change (1234 au lieu de 11434).
Puis-je appeler plusieurs modèles simultanément ?
Si vous les avez chargés dans Ollama, oui. Exécuter deux modèles simultanément double l'utilisation de VRAM. Vous devez disposer de suffisamment de mémoire GPU.
L'API est-elle authentifiée ?
Non. Par défaut, l'API d'Ollama n'a pas d'authentification. Toute personne ayant accès à localhost:11434 peut l'utiliser. Pour la production avec accès réseau, ajoutez une authentification via un reverse proxy (nginx avec Basic Auth, etc.).
Comment utiliser le streaming avec l'API OpenAI d'Ollama ?
Définissez stream=True dans votre appel à la bibliothèque OpenAI. Ollama retourne des server-sent events (SSE) pour chaque token. En Python : for chunk in client.chat.completions.create(stream=True, ...): print(chunk.choices[0].delta.content).
Ollama prend-il en charge les appels de fonctions via l'API ?
Oui, pour les modèles qui le supportent (Llama 3.3 8B, Qwen3 7B, Mistral). Passez tools=[] dans l'appel API comme vous le feriez avec OpenAI. Ollama analyse les appels d'outils et retourne du JSON structuré.
Quelle est la différence entre Ollama /api/generate et /v1/chat/completions ?
/api/generate est l'endpoint natif à un tour d'Ollama. /v1/chat/completions est l'endpoint compatible OpenAI multi-tours. Utilisez /v1/chat/completions pour tous les nouveaux projets -- il supporte l'historique de conversation et est compatible avec les bibliothèques OpenAI.
Puis-je utiliser vLLM comme API compatible OpenAI ?
Oui. vLLM exécute un serveur compatible OpenAI sur http://localhost:8000/v1 par défaut. Lancez-le avec : python -m vllm.entrypoints.openai.api_server --model mistralai/Mistral-7B-v0.1. Utilisez le même code client qu'Ollama.
Comment utiliser l'API Ollama avec le package Node.js openai ?
Importez OpenAI depuis openai. Définissez baseURL: "http://localhost:11434/v1" et apiKey: "ollama" dans le constructeur. Appelez ensuite client.chat.completions.create() exactement comme avec la vraie API OpenAI.
Comment basculer entre Ollama et OpenAI dans le même code ?
Utilisez une variable d'environnement : définissez USE_LOCAL=true pour Ollama (base_url http://localhost:11434/v1, api_key "ollama") et USE_LOCAL=false pour OpenAI. La bibliothèque Python OpenAI accepte base_url comme argument de constructeur.
Puis-je utiliser l'API compatible OpenAI avec LangChain ?
Oui. Utilisez ChatOpenAI avec base_url="http://localhost:11434/v1" et api_key="ollama". Cela fait d'Ollama un remplacement direct d'OpenAI dans tout pipeline LangChain -- les chaînes RAG, agents et outils fonctionnent sans modification.
Comment utiliser Aider avec un modèle local via Ollama ou LM Studio ?
Pointez Aider vers votre serveur local compatible OpenAI en définissant les variables d'environnement OPENAI_API_BASE et OPENAI_API_KEY (ou les options CLI équivalentes) sur http://localhost:11434/v1 (Ollama) ou http://localhost:1234/v1 (LM Studio), avec n'importe quelle chaîne comme clé. Aider dispose aussi d'une prise en charge native d'Ollama via son propre préfixe de fournisseur -- consultez la documentation d'Aider pour la méthode actuellement recommandée.
Cline ou Roo Code peuvent-ils utiliser des modèles locaux via LM Studio ou Ollama ?
Oui. Les deux extensions VS Code proposent une option de fournisseur OpenAI Compatible dans leurs paramètres. Saisissez http://localhost:11434/v1 (Ollama) ou http://localhost:1234/v1 (LM Studio) comme Base URL, n'importe quelle chaîne comme clé API, et le nom exact du modèle. Roo Code est un fork de Cline et utilise le même schéma de configuration.
Sources
- Ollama. (2026). "Ollama OpenAI Compatibility." https://github.com/ollama/ollama/blob/main/docs/openai.md -- Documentation officielle pour les endpoints REST compatibles OpenAI d'Ollama.
- LM Studio. (2026). "LM Studio Local Server." https://lmstudio.ai/docs/local-server -- Documentation du serveur local compatible OpenAI de LM Studio sur localhost:1234.
- OpenAI. (2024). "OpenAI Python Library." https://github.com/openai/openai-python -- SDK Python officiel utilisé pour se connecter à OpenAI et aux LLM locaux via base_url.
- vLLM Team. (2024). "vLLM OpenAI-Compatible Server." https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html -- Documentation du serveur API compatible OpenAI de vLLM.