API LLM pour développeurs : Guide complet d'intégration

Ce guide couvre tout ce qu'un développeur doit savoir pour intégrer les API LLM dans des applications de production : authentification, streaming, utilisation d'outils, embeddings, patterns RAG et gestion des coûts. Tous les exemples utilisent le format compatible OpenAI et fonctionnent avec APIMaster.ai.

Configuration

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_APIMASTER_KEY",
    base_url="https://apimaster.ai/v1",
)

Modèles de base

1. Chat de base

def ask(prompt: str, model: str = "claude-sonnet-4-6") -> str:
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
    )
    return response.choices[0].message.content

2. Prompt système + Conversation

class Conversation:
    def __init__(self, system: str, model: str = "claude-sonnet-4-6"):
        self.model = model
        self.messages = [{"role": "system", "content": system}]
    
    def send(self, user_msg: str) -> str:
        self.messages.append({"role": "user", "content": user_msg})
        resp = client.chat.completions.create(
            model=self.model,
            messages=self.messages,
        )
        reply = resp.choices[0].message.content
        self.messages.append({"role": "assistant", "content": reply})
        return reply

bot = Conversation("You are an expert Python developer.")
print(bot.send("What is the GIL?"))
print(bot.send("How do I work around it?"))

3. Streaming

def stream(prompt: str, model: str = "gpt-5.4"):
    with client.chat.completions.stream(
        model=model,
        messages=[{"role": "user", "content": prompt}],
    ) as s:
        for text in s.text_stream:
            yield text

for chunk in stream("Explain async/await in Python"):
    print(chunk, end="", flush=True)

4. Sortie structurée

from pydantic import BaseModel
from typing import List

class ExtractedData(BaseModel):
    entities: List[str]
    sentiment: str
    summary: str

import json

response = client.chat.completions.create(
    model="gpt-5.4",
    messages=[
        {"role": "system", "content": f"Extract data and return JSON matching this schema: {ExtractedData.schema()}"},
        {"role": "user", "content": "Apple reported record revenue. CEO Tim Cook called it exceptional."},
    ],
    response_format={"type": "json_object"},
)

data = ExtractedData(**json.loads(response.choices[0].message.content))
print(data.entities)    # ["Apple", "Tim Cook"]
print(data.sentiment)   # "positive"

5. Utilisation d'outils / Appel de fonctions

import json

tools = [
    {
        "type": "function",
        "function": {
            "name": "execute_sql",
            "description": "Run a read-only SQL query",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"},
                    "database": {"type": "string", "enum": ["users", "orders", "products"]},
                },
                "required": ["query", "database"],
            },
        },
    }
]

def handle_tool_call(tool_name: str, args: dict) -> str:
    # Your implementation
    return json.dumps({"result": "mock data"})

def agent_loop(user_msg: str):
    messages = [{"role": "user", "content": user_msg}]
    
    while True:
        resp = client.chat.completions.create(
            model="gpt-5.4",
            messages=messages,
            tools=tools,
        )
        
        if resp.choices[0].finish_reason != "tool_calls":
            return resp.choices[0].message.content
        
        # Process tool calls
        messages.append(resp.choices[0].message)
        for tc in resp.choices[0].message.tool_calls:
            result = handle_tool_call(tc.function.name, json.loads(tc.function.arguments))
            messages.append({"role": "tool", "tool_call_id": tc.id, "content": result})

6. Embeddings

def embed(texts: list[str]) -> list[list[float]]:
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=texts,
    )
    return [item.embedding for item in response.data]

# Semantic similarity
import numpy as np

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

vecs = embed(["Python is great", "I love Python", "Java is verbose"])
print(cosine_similarity(vecs[0], vecs[1]))  # High: ~0.95
print(cosine_similarity(vecs[0], vecs[2]))  # Lower: ~0.70

7. RAG (Génération augmentée par récupération)

from typing import List

def rag_query(user_question: str, knowledge_base: List[str]) -> str:
    # Step 1: Embed the question
    q_embedding = embed([user_question])[0]
    doc_embeddings = embed(knowledge_base)
    
    # Step 2: Find most relevant docs
    similarities = [cosine_similarity(q_embedding, d) for d in doc_embeddings]
    top_indices = sorted(range(len(similarities)), key=lambda i: similarities[i], reverse=True)[:3]
    context = "\n\n".join(knowledge_base[i] for i in top_indices)
    
    # Step 3: Generate answer with context
    response = client.chat.completions.create(
        model="claude-sonnet-4-6",
        messages=[
            {"role": "system", "content": f"Answer using only this context:\n\n{context}"},
            {"role": "user", "content": user_question},
        ],
    )
    return response.choices[0].message.content

8. Async pour haut débit

import asyncio
from openai import AsyncOpenAI

async_client = AsyncOpenAI(
    api_key="YOUR_APIMASTER_KEY",
    base_url="https://apimaster.ai/v1",
)

async def process_batch(prompts: list[str]) -> list[str]:
    tasks = [
        async_client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": p}],
            max_tokens=100,
        )
        for p in prompts
    ]
    responses = await asyncio.gather(*tasks)
    return [r.choices[0].message.content for r in responses]

# Process 50 prompts concurrently
results = asyncio.run(process_batch(my_prompts))

Checklist de production

• Clés API dans les variables d'environnement, pas dans le code source
• Logique de réessai avec backoff exponentiel pour les erreurs 429/500
• max_tokens défini pour éviter des coûts incontrôlés
• Streaming pour les réponses utilisateur >2 secondes
• Journalisation des requêtes avec comptage de tokens pour le suivi des coûts
• Limiteur de débit pour rester dans les limites du fournisseur

Choisir le bon modèle

Cas d'utilisation	Modèle	Niveau de coût
Prototypage	deepseek-v4-flash ou gpt-4o-mini	Très faible
Chatbot de production	claude-haiku-4-5	Faible
Assistant de code	deepseek-v4-flash ou claude-sonnet-4-6	Faible–Moyen
Analyse complexe	claude-sonnet-4-6	Moyen
Recherche/raisonnement	claude-opus-4-8 ou o3	Élevé

Foire aux questions

Qu'est-ce qu'une API LLM ? Une API LLM est une interface HTTP qui permet à votre code d'envoyer des prompts textuels et de recevoir des réponses générées par IA. Vous envoyez un tableau messages ; l'API renvoie une complétion. La plupart utilisent le format Chat Completions d'OpenAI.

Comment choisir entre les fournisseurs d'API LLM ? Considérez la capacité du modèle (benchmarks), le coût par token, la latence et la fiabilité. Pour la plupart des cas d'utilisation, DeepSeek V4 Flash (codage à faible coût), Claude Sonnet (écriture/analyse) ou GPT-4o (multimodal) couvrent les besoins courants. APIMaster vous permet de changer de fournisseur avec une seule ligne.

Qu'est-ce qu'une API compatible OpenAI ? Un endpoint qui implémente le même format /v1/chat/completions qu'OpenAI, vous permettant d'utiliser la bibliothèque Python openai ou tout outil compatible OpenAI avec des modèles non OpenAI.

Comment gérer les erreurs d'API LLM en production ? Capturez RateLimitError (réessayez avec backoff), APIConnectionError (réessayez) et InvalidRequestError (corrigez le prompt). Utilisez des timeouts et des circuit breakers pour la résilience en production.

Puis-je utiliser une seule clé API pour plusieurs fournisseurs LLM ? Oui—APIMaster fournit une clé unique et un endpoint pour GPT, Claude, DeepSeek et Gemini. Changez de modèle en modifiant le paramètre model. Pas besoin de clés ou SDK spécifiques au fournisseur.

Accéder à l'API LLM → · Comparer les modèles →