Exposer une application LLM en point de terminaison d’API avec FastAPI en Python

Introduction

Les grands modèles de langage (LLM) sont au premier plan de l’IA générative et transforment la façon dont les machines comprennent et produisent un texte proche du langage humain. Des modèles LLM comme GPT, Claude, LLaMA, Mistral, etc. stimulent l’innovation pour les chatbots, la création de contenu et bien plus, avec des capacités inédites en traitement et génération du langage naturel.

Cependant, l’utilité réelle des LLM va au-delà de leur seule puissance de calcul ; l’accessibilité est clé. Les API (interfaces de programmation applicative) servent de ponts qui permettent à des applications variées d’exploiter la puissance des LLM. Elles offrent aux développeurs un moyen d’intégrer des fonctions sophistiquées de compréhension et de génération du langage, depuis l’analyse de texte la plus simple jusqu’à des systèmes de dialogue complexes.

Dans ce tutoriel, nous allons créer une application Python simple utilisant le modèle GPT d’OpenAI et l’exposer via un point de terminaison d’API développé avec le framework FastAPI en Python.

Grands modèles de langage

Les grands modèles de langage (LLM) désignent des systèmes d’intelligence artificielle avancés conçus pour comprendre et générer un texte proche du langage humain. Entraînés sur d’immenses volumes de données, ils apprennent des schémas complexes, saisissent les nuances et produisent des réponses cohérentes.

Les LLM sont capables d’accomplir de nombreuses tâches liées au langage : traduction, complétion de texte, synthèse, ou encore conversation. GPT est un exemple de LLM.

Dans cet article, nous allons créer une application Python simple en utilisant l’API GPT d’OpenAI, puis développer un point de terminaison REST pour notre application avec le framework FastAPI en Python.

Un LLM est un type d’IA générative. Si vous souhaitez en savoir plus sur l’IA générative et comment elle peut stimuler votre créativité, consultez nos billets Utiliser l’IA générative pour booster votre créativité et notre podcast Au cœur de la révolution de l’IA générative.

Vous pouvez aussi vous inscrire à notre prochain cours sur les concepts des grands modèles de langage.

Qu’est-ce qu’une API ?

Une interface de programmation applicative (API) est l’épine dorsale de la communication logicielle : elle permet à des systèmes, applications et appareils de dialoguer et d’échanger des données en toute fluidité. Elle définit un ensemble de règles et de protocoles offrant à une application un moyen prédéfini de tirer parti des capacités ou des données d’une autre, sans avoir à en connaître le fonctionnement interne.

Omniprésentes dans l’écosystème numérique actuel, les API alimentent les services web, les applications mobiles et le cloud, facilitant la communication interapplications et l’intégration de services tiers. Elles simplifient le développement en fournissant des briques réutilisables qui accélèrent la création de nouveaux logiciels, enrichissent les fonctionnalités et améliorent l’expérience utilisateur sans repartir de zéro.

Grâce aux API, les développeurs peuvent étendre leurs applications de façons autrement complexes, voire impossibles ; elles sont donc essentielles au développement logiciel moderne.

Source de l’image

Si l’ingénierie autour du déploiement de modèles de machine learning en production vous intéresse, consultez ce guide complet sur les pipelines de machine learning, le déploiement et le MLOps. Vous pouvez également suivre le cours gratuit Introduction aux API sur DataCamp.

FastAPI

FastAPI est un framework Python conçu pour créer des API haute performance. Sa montée en puissance s’explique par sa rapidité, sa simplicité et sa compatibilité avec la programmation asynchrone. FastAPI permet d’exposer des fonctionnalités LLM sous forme de points de terminaison d’API, ce qui facilite le déploiement, la gestion et la montée en charge de services dopés à l’IA.

FastAPI se distingue par ses performances et son efficacité, en s’appuyant sur des fonctionnalités modernes de Python comme les annotations de type et l’asynchrone, offrant des gains de vitesse comparables à NodeJS et même Go.

Cet avantage de performance est crucial pour les applications nécessitant un traitement des données en temps réel et la gestion de requêtes concurrentes, comme celles qui interagissent avec des LLM. Sa capacité à valider automatiquement les données entrantes et à sérialiser les réponses réduit le code standard, ce qui rend le développement d’API plus propre et plus direct.

La documentation automatique, basée sur des standards comme OpenAPI, fournit aux développeurs et aux utilisateurs une documentation claire et interactive, simplifiant encore l’intégration et les tests.

Exemple de création d’API :

from typing import Union

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}

Ce code crée un serveur web simple avec FastAPI. Le serveur répond à deux types de requêtes : l’une qui salue l’utilisateur avec « Hello World » à la visite de la page d’accueil ("/") ; l’autre qui affiche l’identifiant d’un item et un paramètre de requête optionnel "q" lorsque l’utilisateur visite une page d’item spécifique ("/items/{item_id}"). L’identifiant de l’item est obligatoire et doit être un entier, tandis que le paramètre "q" est optionnel et peut être une chaîne de caractères ou être absent.

Lancez le serveur FastAPI avec :

Créer une application de bout en bout en Python

Le but principal de cet article est de montrer comment créer rapidement des points de terminaison REST pour vos applications LLM. Nous allons développer une application Python très simple (une seule fonction) qui utilise l’API OpenAI GPT-4 pour traduire de l’anglais vers le français. Cette application ne comporte qu’une fonction, translate_text :

from openai import OpenAI
import os

os.environ["OPENAI_API_KEY"] = "..."

# Initialize OpenAI client with your API key
client = OpenAI()

def translate_text(input_str):
    completion = client.chat.completions.create(
        model="gpt-4-0125-preview",
        messages=[
            {
                "role": "system",
                "content": "You are an expert translator who translates text from english to french and only return translated text",
            },
            {"role": "user", "content": input_str},
        ],
    )

    return completion.choices[0].message.content

Cette fonction prend une entrée utilisateur et la transmet simplement au modèle GPT-4 d’OpenAI. Une instruction système définit le contexte, et l’invite utilisateur correspond au texte reçu dans input_str.

Vous pouvez tester cette fonction en exécutant ce qui suit. Vous devriez obtenir le texte en français en retour.

# test the function
translate_text("this is a test string to translate")

Si vous envisagez de partager cette application, envoyer le fichier Python pour exécution en ligne de commande peut convenir à certains utilisateurs, notamment ceux à l’aise avec Python et les outils en CLI.

Cependant, cette approche a ses limites. Tout le monde n’est pas à l’aise avec la ligne de commande et, même pour ceux qui le sont, exécuter un script Python suppose un environnement configuré avec toutes les dépendances nécessaires. Cela peut être fastidieux et constituer un frein à l’adoption de votre application de traduction.

D’où l’intérêt d’« envelopper » votre application avec FastAPI pour l’exposer via un point de terminaison d’API REST. Vous créez ainsi une interface accessible sur Internet, sans que les utilisateurs aient à exécuter eux-mêmes des scripts Python. Ils peuvent interagir avec votre application au moyen de requêtes web simples, depuis un large éventail de plateformes et de langages, pas uniquement Python.

Créer une API REST avec FastAPI automatise la réception des demandes de traduction et l’envoi des réponses. Les utilisateurs peuvent soumettre du texte à traduire via une interface web ou un appel API, ce qui facilite grandement l’usage et couvre plus de cas d’utilisation.

Pour transformer cette fonction en point de terminaison d’API avec FastAPI, nous allons modifier notre code :

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import os


os.environ["OPENAI_API_KEY"] = "..."


# Initialize OpenAI client with your API key
client = OpenAI()


# Initialize FastAPI client
app = FastAPI()


# Create class with pydantic BaseModel
class TranslationRequest(BaseModel):
    input_str: str


def translate_text(input_str):
    completion = client.chat.completions.create(
        model="gpt-4-0125-preview",
        messages=[
            {
                "role": "system",
                "content": "You are an expert translator who translates text from english to french and only return translated text",
            },
            {"role": "user", "content": input_str},
        ],
    )


    return completion.choices[0].message.content


@app.post("/translate/")  # This line decorates 'translate' as a POST endpoint
async def translate(request: TranslationRequest):
    try:
        # Call your translation function
        translated_text = translate_text(request.input_str)
        return {"translated_text": translated_text}
    except Exception as e:
        # Handle exceptions or errors during translation
        raise HTTPException(status_code=500, detail=str(e))

Pour exécuter et tester cette API en local, lancez simplement la commande suivante :

uvicorn main:app --reload

Ici, main.py est le fichier qui contient votre code. Le terme app désigne l’instance de l’application FastAPI, définie dans votre code par app = FastAPI().

Rendez-vous sur localhost:8000/docs pour afficher l’interface, qui devrait ressembler à ceci :

Cliquez sur POST, puis sur Try it out, saisissez votre texte et cliquez sur Execute.

Vous devriez voir la commande curl envoyée à l’API, l’URL de requête (votre localhost à ce stade) et la réponse du serveur. Le code 200 indique le succès ; la traduction en français apparaît à côté.

Conclusion

Cet article vous a guidé pour mettre en place un point de terminaison d’API avec FastAPI afin d’exposer des applications motorisées par des grands modèles de langage comme GPT. Grâce à ses performances et à sa simplicité, FastAPI offre un moyen direct de créer des API performantes, idéal pour intégrer des LLM dans vos projets.

Pour découvrir tout le potentiel des LLM avec un cours conceptuel unique couvrant les applications, les méthodes d’entraînement, les considérations éthiques et les dernières avancées, consultez ce cours gratuit Mastering Large Language Models (LLMs) sur DataCamp.

Vous souhaitez élargir votre boîte à outils ? Découvrez les 21 outils Python essentiels pour le développement logiciel, le web scraping et le développement web, l’analyse et la visualisation de données, ainsi que le machine learning.