| Guides | Clore.ai

Intégrez les modèles IA exécutés sur Clore.ai dans vos applications

Intégrez des modèles d'IA exécutés sur CLORE.AI dans vos applications.

Déployez des serveurs API à CLORE.AI Marketplace.

Démarrage rapide

La plupart des services d'IA sur CLORE.AI fournissent des API compatibles OpenAI. Remplacez l'URL de base et vous êtes prêt.

from openai import OpenAI

client = OpenAI(
    base_url="http://<votre-serveur-clore>:8000/v1",
    api_key="pas-nécessaire"  # La plupart des auto-hébergés n'exigent pas de clé
)

response = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[{"role": "user", "content": "Bonjour !"}]
)
print(response.choices[0].message.content)

APIs LLM

vLLM (Compatible OpenAI)

Configuration du serveur :

python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-8B-Instruct \
    --host 0.0.0.0 --port 8000

Client Python :

from openai import OpenAI

client = OpenAI(base_url="http://server:8000/v1", api_key="dummy")

# Complétion de chat
response = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant serviable."},
        {"role": "user", "content": "Écris un poème sur la programmation"}
    ],
    temperature=0.7,
    max_tokens=500
)
print(response.choices[0].message.content)

# Streaming
stream = client.chat.completions.create(
    model="meta-llama/Llama-3.1-8B-Instruct",
    messages=[{"role": "user", "content": "Raconte-moi une histoire"}],
    stream=True
)
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Client Node.js :

import OpenAI from 'openai';

const client = new OpenAI({
    baseURL: 'http://server:8000/v1',
    apiKey: 'dummy'
});

async function chat(message) {
    const response = await client.chat.completions.create({
        model: 'meta-llama/Llama-3.1-8B-Instruct',
        messages: [{ role: 'user', content: message }]
    });
    return response.choices[0].message.content;
}

// Streaming
async function streamChat(message) {
    const stream = await client.chat.completions.create({
        model: 'meta-llama/Llama-3.1-8B-Instruct',
        messages: [{ role: 'user', content: message }],
        stream: true
    });

    for await (const chunk of stream) {
        process.stdout.write(chunk.choices[0]?.delta?.content || '');
    }
}

cURL :

curl http://server:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "meta-llama/Llama-3.1-8B-Instruct",
        "messages": [{"role": "user", "content": "Bonjour !"}]
    }'

API Ollama

Python :

import requests

# Générer
response = requests.post('http://server:11434/api/generate', json={
    'model': 'llama3.2',
    'prompt': 'Pourquoi le ciel est-il bleu ?',
    'stream': False
})
print(response.json()['response'])

# Chat
response = requests.post('http://server:11434/api/chat', json={
    'model': 'llama3.2',
    'messages': [
        {'role': 'user', 'content': 'Bonjour !'}
    ],
    'stream': False
})
print(response.json()['message']['content'])

# Streaming
response = requests.post('http://server:11434/api/chat', json={
    'model': 'llama3.2',
    'messages': [{'role': 'user', 'content': 'Raconte-moi une histoire'}],
    'stream': True
}, stream=True)

for line in response.iter_lines():
    if line:
        data = json.loads(line)
        print(data['message']['content'], end='', flush=True)

Ollama prend également en charge le format OpenAI :

from openai import OpenAI

client = OpenAI(base_url='http://server:11434/v1', api_key='ollama')
# Utilisez le même code que les exemples vLLM

API TGI

Python :

import requests

# Générer
response = requests.post('http://server:8080/generate', json={
    'inputs': 'Qu'est-ce que l'apprentissage automatique ?',
    'parameters': {
        'max_new_tokens': 200,
        'temperature': 0.7,
        'do_sample': True
    }
})
print(response.json()['generated_text'])

# Streaming
response = requests.post('http://server:8080/generate_stream', json={
    'inputs': 'Explique l'informatique quantique',
    'parameters': {'max_new_tokens': 500}
}, stream=True)

for line in response.iter_lines():
    if line:
        data = json.loads(line.decode().replace('data:', ''))
        print(data.get('token', {}).get('text', ''), end='', flush=True)

APIs de génération d'images

API Stable Diffusion WebUI

Activer l'API : Ajoutez --api à la commande de lancement.

Python :

import requests
import base64
from PIL import Image
from io import BytesIO

def txt2img(prompt, negative_prompt="", steps=20, width=512, height=512):
    response = requests.post('http://server:7860/sdapi/v1/txt2img', json={
        'prompt': prompt,
        'negative_prompt': negative_prompt,
        'steps': steps,
        'width': width,
        'height': height,
        'sampler_name': 'DPM++ 2M Karras',
        'cfg_scale': 7
    })

    # Décoder l'image en base64
    image_data = base64.b64decode(response.json()['images'][0])
    return Image.open(BytesIO(image_data))

# Générer
image = txt2img(
    prompt="Un magnifique coucher de soleil sur des montagnes, photoréaliste, 8k",
    negative_prompt="flou, basse qualité"
)
image.save("output.png")

# img2img
def img2img(prompt, image_path, denoising=0.5):
    with open(image_path, 'rb') as f:
        image_b64 = base64.b64encode(f.read()).decode()

    response = requests.post('http://server:7860/sdapi/v1/img2img', json={
        'prompt': prompt,
        'init_images': [image_b64],
        'denoising_strength': denoising,
        'steps': 30
    })

    image_data = base64.b64decode(response.json()['images'][0])
    return Image.open(BytesIO(image_data))

Node.js :

const axios = require('axios');
const fs = require('fs');

async function txt2img(prompt) {
    const response = await axios.post('http://server:7860/sdapi/v1/txt2img', {
        prompt: prompt,
        steps: 20,
        width: 512,
        height: 512
    });

    const imageBuffer = Buffer.from(response.data.images[0], 'base64');
    fs.writeFileSync('output.png', imageBuffer);
}

API ComfyUI

Python :

import json
import urllib.request
import urllib.parse
import websocket
import uuid

SERVER = "server:8188"

def queue_prompt(workflow):
    """Mettre en file d'attente un workflow pour exécution"""
    data = json.dumps({"prompt": workflow}).encode('utf-8')
    req = urllib.request.Request(f"http://{SERVER}/prompt", data=data)
    return json.loads(urllib.request.urlopen(req).read())

def get_image(filename, subfolder, folder_type):
    """Télécharger l'image générée"""
    params = urllib.parse.urlencode({
        "filename": filename,
        "subfolder": subfolder,
        "type": folder_type
    })
    with urllib.request.urlopen(f"http://{SERVER}/view?{params}") as response:
        return response.read()

# Charger le workflow depuis un fichier
with open('workflow.json') as f:
    workflow = json.load(f)

# Modifier le prompt
workflow["6"]["inputs"]["text"] = "Un chat portant un chapeau"

# Mettre en file d'attente et obtenir le résultat
result = queue_prompt(workflow)
print(f"Mis en file d'attente : {result}")

WebSocket pour la progression :

import websocket
import json

def on_message(ws, message):
    data = json.loads(message)
    if data['type'] == 'progress':
        print(f"Progression : {data['data']['value']}/{data['data']['max']}")
    elif data['type'] == 'executed':
        print("Génération terminée !")

ws = websocket.WebSocketApp(
    f"ws://{SERVER}/ws",
    on_message=on_message
)
ws.run_forever()

FLUX avec Diffusers

import torch
from diffusers import FluxPipeline
import base64
from io import BytesIO

# Charger le modèle (faire une fois)
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")

def generate_image(prompt, height=1024, width=1024):
    image = pipe(
        prompt,
        height=height,
        width=width,
        num_inference_steps=4,
        guidance_scale=0.0
    ).images[0]
    return image

# Wrapper API simple avec Flask
from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/generate', methods=['POST'])
def generate():
    data = request.json
    image = generate_image(data['prompt'])

    # Convertir en base64
    buffer = BytesIO()
    image.save(buffer, format='PNG')
    img_b64 = base64.b64encode(buffer.getvalue()).decode()

    return jsonify({'image': img_b64})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

APIs audio

Whisper Transcription

Utilisation de whisper-asr-webservice :

import requests

def transcribe(audio_path):
    with open(audio_path, 'rb') as f:
        response = requests.post(
            'http://server:9000/asr',
            files={'audio_file': f},
            data={
                'task': 'transcribe',
                'language': 'en',
                'output': 'json'
            }
        )
    return response.json()['text']

text = transcribe('audio.mp3')
print(text)

API Whisper directe :

import whisper
from flask import Flask, request, jsonify

model = whisper.load_model("large-v3")

app = Flask(__name__)

@app.route('/transcribe', methods=['POST'])
def transcribe():
    audio = request.files['audio']
    audio.save('/tmp/audio.mp3')

    result = model.transcribe('/tmp/audio.mp3')
    return jsonify({'text': result['text']})

Synthèse vocale (Bark)

from bark import SAMPLE_RATE, generate_audio, preload_models
from scipy.io.wavfile import write as write_wav
import base64
from flask import Flask, request, jsonify

preload_models()

app = Flask(__name__)

@app.route('/tts', methods=['POST'])
def text_to_speech():
    text = request.json['text']
    audio = generate_audio(text)

    # Enregistrer dans un fichier
    write_wav('/tmp/output.wav', SAMPLE_RATE, audio)

    # Retourner en base64
    with open('/tmp/output.wav', 'rb') as f:
        audio_b64 = base64.b64encode(f.read()).decode()

    return jsonify({'audio': audio_b64})

Construction d'applications

Application de chat

from flask import Flask, request, jsonify, Response
from openai import OpenAI
import json

app = Flask(__name__)
client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")

@app.route('/chat', methods=['POST'])
def chat():
    messages = request.json.get('messages', [])

    response = client.chat.completions.create(
        model="meta-llama/Llama-3.1-8B-Instruct",
        messages=messages,
        temperature=0.7
    )

    return jsonify({
        'response': response.choices[0].message.content
    })

@app.route('/chat/stream', methods=['POST'])
def chat_stream():
    messages = request.json.get('messages', [])

    def generate():
        stream = client.chat.completions.create(
            model="meta-llama/Llama-3.1-8B-Instruct",
            messages=messages,
            stream=True
        )
        for chunk in stream:
            if chunk.choices[0].delta.content:
                yield f"data: {json.dumps({'content': chunk.choices[0].delta.content})}\n\n"
        yield "data: [DONE]\n\n"

    return Response(generate(), mimetype='text/event-stream')

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Service de génération d'images

from flask import Flask, request, jsonify, send_file
import requests
import base64
from io import BytesIO

app = Flask(__name__)
SD_API = "http://localhost:7860"

@app.route('/generate', methods=['POST'])
def generate():
    data = request.json

    response = requests.post(f'{SD_API}/sdapi/v1/txt2img', json={
        'prompt': data['prompt'],
        'negative_prompt': data.get('negative_prompt', ''),
        'steps': data.get('steps', 20),
        'width': data.get('width', 512),
        'height': data.get('height', 512)
    })

    image_b64 = response.json()['images'][0]

    if data.get('return_base64'):
        return jsonify({'image': image_b64})

    # Retourner en tant que fichier
    image_data = base64.b64decode(image_b64)
    return send_file(BytesIO(image_data), mimetype='image/png')

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Pipeline multimodal

from flask import Flask, request, jsonify
from openai import OpenAI
import requests
import base64

app = Flask(__name__)
llm_client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")
SD_API = "http://localhost:7860"

@app.route('/create-image-from-description', methods=['POST'])
def create_image():
    description = request.json['description']

    # Étape 1 : Générer un prompt détaillé avec le LLM
    prompt_response = llm_client.chat.completions.create(
        model="meta-llama/Llama-3.1-8B-Instruct",
        messages=[{
            "role": "user",
            "content": f"Créez un prompt détaillé pour la génération d'image pour : {description}. Incluez le style, l'éclairage et les détails de composition. Retournez uniquement le prompt, pas d'explication."
        }]
    )
    detailed_prompt = prompt_response.choices[0].message.content

    # Étape 2 : Générer l'image
    image_response = requests.post(f'{SD_API}/sdapi/v1/txt2img', json={
        'prompt': detailed_prompt,
        'steps': 25,
        'width': 1024,
        'height': 1024
    })

    return jsonify({
        'prompt_used': detailed_prompt,
        'image': image_response.json()['images'][0]
    })

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Gestion des erreurs

from openai import OpenAI, APIError, APIConnectionError
import time

client = OpenAI(base_url="http://server:8000/v1", api_key="dummy")

def chat_with_retry(messages, max_retries=3):
    for attempt in range(max_retries):
        try:
            response = client.chat.completions.create(
                model="meta-llama/Llama-3.1-8B-Instruct",
                messages=messages,
                timeout=60
            )
            return response.choices[0].message.content

        except APIConnectionError as e:
            print(f"Erreur de connexion (tentative {attempt + 1}) : {e}")
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)  # Repli exponentiel
            else:
                raise

        except APIError as e:
            print(f"Erreur API : {e}")
            raise

# Utilisation
try:
    result = chat_with_retry([{"role": "user", "content": "Bonjour"}])
    print(result)
except Exception as e:
    print(f"Échec après tentatives : {e}")

Bonnes pratiques

Pool de connexions - Réutiliser les connexions HTTP
Requêtes asynchrones - Utiliser aiohttp pour des appels concurrents
Délais d'attente - Toujours définir des délais pour les requêtes
Logique de retry - Gérer les pannes temporaires
Limitation de débit - Ne pas surcharger le serveur
Vérifications de santé - Surveiller la disponibilité du serveur

Prochaines étapes

Traitement par lots - Traiter de lourdes charges de travail
Configuration Multi-GPU - Échelonner votre déploiement
Comparaison LLM - Choisir le bon serveur

PrécédentConfiguration Multi-GPU SuivantTraitement par lots

Mis à jour il y a 1 jour

Ce contenu vous a-t-il été utile ?

hashtagDémarrage rapide

hashtagAPIs LLM

hashtagvLLM (Compatible OpenAI)

hashtagAPI Ollama

hashtagAPI TGI

hashtagAPIs de génération d'images

hashtagAPI Stable Diffusion WebUI

hashtagAPI ComfyUI

hashtagFLUX avec Diffusers

hashtagAPIs audio

hashtagWhisper Transcription

hashtagSynthèse vocale (Bark)

hashtagConstruction d'applications

hashtagApplication de chat

hashtagService de génération d'images

hashtagPipeline multimodal

hashtagGestion des erreurs

hashtagBonnes pratiques

hashtagProchaines étapes

Démarrage rapide

APIs LLM

vLLM (Compatible OpenAI)

API Ollama

API TGI

APIs de génération d'images

API Stable Diffusion WebUI

API ComfyUI

FLUX avec Diffusers

APIs audio

Whisper Transcription

Synthèse vocale (Bark)

Construction d'applications

Application de chat

Service de génération d'images

Pipeline multimodal

Gestion des erreurs

Bonnes pratiques

Prochaines étapes