Comment installer un LLM en Python : local ou API

Deux significations de l'installation d'un LLM

Lorsque les gens demandent comment installer llm en python, ils veulent généralement dire l'une des deux choses. La première consiste à exécuter un modèle localement : télécharger les poids et les charger avec une bibliothèque sur votre propre CPU ou GPU. La deuxième consiste à installer une bibliothèque cliente afin que votre code Python puisse communiquer avec un modèle qui s'exécute ailleurs. Les deux sont valides, et le choix dépend de votre matériel et de ce que vous souhaitez construire.

La voie API est beaucoup plus courte. Vous exécutez pip install openai, pointez le client vers une URL de base et appelez le modèle. Pas de poids, pas de pilotes GPU, pas de planification de mémoire. Le reste de cette page donne les étapes et le code pour cette voie, avec une courte section sur la version locale pour que vous puissiez comparer.

Installation locale ou API hébergée : comment choisir

Question	Installation locale	API hébergée
Ce que vous installez	Une bibliothèque d'inférence plus les poids du modèle	Le package openai
Matériel	De la mémoire et généralement un GPU adapté au modèle	Toute machine capable de faire des appels HTTPS
Coût	Votre matériel et l'électricité	Par token, à partir du crédit prépayé
Fonctionne hors ligne	Oui	Non
Temps jusqu'à la première réponse	Téléchargement, configuration, réglage	Quelques minutes

L'installation locale a du sens si vous devez tout garder sur une seule machine, avez besoin de travailler hors ligne, ou voulez expérimenter avec les poids eux-mêmes. Des bibliothèques comme les bindings llama.cpp ou Hugging Face transformers sont les points de départ habituels ; consultez leur propre documentation pour les exigences matérielles, car celles-ci dépendent de la taille du modèle que vous choisissez.

L'API a du sens si vous voulez un résultat fonctionnel rapidement, si votre ordinateur portable ne peut pas contenir un grand modèle, ou si votre application doit servir de nombreux utilisateurs. Vous payez par token au lieu d'acheter du matériel. Pour ce service, cela coûte 0,15 $ par 1M de tokens d'entrée et 0,50 $ par 1M de tokens de sortie, sans abonnement. La page tarification a les détails.

Étape 1 : créer un environnement virtuel et installer le package

Utilisez un environnement virtuel pour que l'installation reste propre. Toute version récente de Python 3 fonctionne avec le package openai.

Copypython3 -m venv .venv
source .venv/bin/activate
pip install openai

Ensuite, vous avez besoin d'une clé. Inscrivez-vous sur la page clé API avec Google ou avec email et mot de passe. Les nouveaux utilisateurs peuvent réclamer 0,50 $ de crédit d'essai gratuit là-bas en un clic, valable 7 jours et sans carte. Stockez la clé dans une variable d'environnement au lieu de votre fichier source :

Copyexport API_KEY="paste-your-key-here"

Étape 2 : faire votre premier appel

Le service est compatible OpenAI, donc les seuls changements par rapport à un script OpenAI standard sont la base URL et l'ID du modèle. L'ID du modèle est uncensored.

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.getaiapikey.com/v1",
    api_key=os.environ["API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain what a context window is in two sentences."},
    ],
    temperature=0.7,
    max_tokens=200,
)

print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

Si cela imprime une réponse et deux comptes de tokens, l'installation est terminée. Pour vérifier que votre clé fonctionne et voir l'ID du modèle, vous pouvez aussi appeler GET /v1/models :

Copyfor m in client.models.list():
    print(m.id)

La même demande depuis le shell, sans Python du tout, est un seul appel curl à https://api.getaiapikey.com/v1/chat/completions avec l'en-tête Authorization: Bearer suivi de votre clé. Le guide de démarrage rapide le montre en entier.

Étape 3 : streamer les tokens à leur arrivée

Attendre qu’une réponse longue se termine avant d’imprimer quoi que ce soit semble lent. Définissez stream=True et le serveur envoie des tokens via des événements envoyés par le serveur. Vous pouvez demander un résumé d’utilisation dans le dernier bloc avec stream_options.

Copystream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short scene set in a lighthouse."}],
    stream=True,
    stream_options={"include_usage": True},
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if chunk.usage:
        print("\n", chunk.usage.total_tokens, "tokens")

Un détail est important en production : une requête en streaming occupe sa place de concurrence jusqu'à la fin du flux. Une clé complète permet 8 requêtes simultanées, donc si votre application ouvre de nombreux flux longs, fermez-les lorsque l'utilisateur se déconnecte.

Étape 4 : mode JSON et appel de fonctions

Pour une sortie structurée, définissez response_format sur un objet JSON. Dites aussi au modèle dans le prompt de répondre en JSON, car le paramètre garantit une syntaxe JSON valide mais pas les noms de champs que vous voulez.

Copyimport json

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "Reply only with JSON: {\"title\": string, \"tags\": [string]}"},
        {"role": "user", "content": "Give me a title and tags for a post about slow travel."},
    ],
    response_format={"type": "json_object"},
)
data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])

L'appel de fonctions suit le modèle standard. Vous décrivez une fonction, le modèle peut demander à l'appeler, vous l'exécutez vous-même et renvoyez le résultat avec role: "tool".

Copytools = [{
    "type": "function",
    "function": {
        "name": "get_time",
        "description": "Return the current time for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

messages = [{"role": "user", "content": "What time is it in Lisbon?"}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)

msg = first.choices[0].message
if msg.tool_calls:
    call = msg.tool_calls[0]
    messages.append(msg)
    messages.append({
        "role": "tool",
        "tool_call_id": call.id,
        "content": json.dumps({"time": "14:05"}),
    })
    final = client.chat.completions.create(
        model="uncensored", messages=messages, tools=tools
    )
    print(final.choices[0].message.content)

Testez les appels de fonctions sur quelques prompts avant de vous y fier. Tout modèle peut choisir la mauvaise fonction ou remplir un argument mal, donc validez les arguments dans votre propre code avant d'exécuter quoi que ce soit avec des effets secondaires.

Étape 5 : gérer les limites et les erreurs

Les clés complètes permettent 8 requêtes simultanées et 300 requêtes par minute. Les clés d'essai permettent 2 et 60. Au-delà de ces limites, vous obtenez HTTP 429. Le code d'erreur rate_limited signifie trop de requêtes par minute, et concurrency signifie trop en même temps. En cas de surcharge temporaire, l'API retourne aussi 429 avec un en-tête Retry-After: 5.

Le client Python OpenAI réessaie certaines erreurs de lui-même, mais un wrapper explicite garde le comportement évident :

Copyimport time
from openai import RateLimitError

def ask(messages, tries=4):
    for attempt in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError:
            time.sleep(5 * (attempt + 1))
    raise RuntimeError("still rate limited after retries")

Chaque réponse contient les en-têtes X-Request-Id, X-Balance-USD et de limite de débit, que vous pouvez journaliser. Incluez l'ID de requête si vous contactez le support. Les requêtes échouées ou refusées ne sont pas facturées, donc réessayer n'entraîne pas de coût supplémentaire.

Planifiez aussi les limites de taille. La fenêtre de contexte est de 100 000 tokens, prompt plus complétion, et le corps de requête maximum est de 8 Mo. Les historiques de chat longs doivent être tronqués ou résumés avant d'atteindre ces nombres.

Quand l'appel ne fonctionne pas

La plupart des problèmes de première exécution viennent d'une poignée d'erreurs. Vérifiez ceci dans l'ordre avant de soupçonner autre chose.

• URL de base sans le chemin de version. La valeur doit se terminer par /v1. Le client ajoute /chat/completions à celle-ci, donc une absence de /v1 envoie la requête à la mauvaise route.
• Clé incorrecte ou manquante. La clé se place dans l'en-tête Authorization: Bearer, que le client construit à partir de api_key. Si la variable d'environnement est vide, le client lève soit une erreur au démarrage, soit envoie une clé vide. Affichez bool(os.environ.get("API_KEY")) pour vérifier.
• Un nom de modèle d'un autre service. Le seul ID de modèle ici est uncensored. Des noms comme ceux dans d'autres tutoriels ne correspondront pas.
• Solde insuffisant. Consultez l'en-tête X-Balance-USD. Un essai ayant dépassé ses 7 jours, ou un solde épuisé, nécessite un rechargement à partir de 20 $.
• Package ancien. Si un exemple utilise OpenAI( et Python dit qu'il ne peut pas importer ce nom, vous avez le package pré-1.0. Exécutez pip install --upgrade openai.

Pour voir la réponse brute incluant les en-têtes, utilisez le wrapper de réponse brute du client :

Copyraw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "ping"}],
    max_tokens=5,
)
print(raw.headers.get("x-request-id"), raw.headers.get("x-balance-usd"))
completion = raw.parse()
print(completion.choices[0].message.content)

Cela imprime l'ID de requête et votre solde restant à côté de la réponse, ce qui est un test de santé rapide que vous pouvez exécuter depuis un job cron ou un script de démarrage.

Utilisation depuis d'autres outils

Parce que l'endpoint suit le format OpenAI, d'autres bibliothèques Python peuvent l'utiliser avec les mêmes deux paramètres. Les frameworks qui acceptent une base URL OpenAI personnalisée n'ont besoin que de base_url et api_key. Pour Node, le package officiel openai prend les mêmes champs :

Copyimport OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.getaiapikey.com/v1",
  apiKey: process.env.API_KEY,
});

const r = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Say hello in five words." }],
});
console.log(r.choices[0].message.content);

Ceci est un service textuel uniquement : pas de génération d'image ou d'audio, pas d'embeddings et pas de fine-tuning. Si votre projet a besoin de cela, associez cette API avec un autre outil pour cette partie. Le modèle est un modèle à poids ouverts exécuté par un fournisseur indépendant et ajusté pour répondre sans refus de contenu pour une utilisation adulte légale. Le contenu sexuel impliquant des mineurs n'est jamais autorisé.

Plus de guides

• Clé API LLM gratuite : ce que couvre le crédit d'essai
• Clé API LLM pour un bot Discord : Guide d'installation
• Liste de contrôle de l'API IA