1. Aperçu de LangServe

LangServe est une bibliothèque qui aide les développeurs à exécuter des programmes et des chaînes de LangChain en tant qu'API REST. Elle intègre FastAPI et utilise pydantic pour la validation des données.

2. Fonctionnalités

LangServe dispose des fonctionnalités suivantes :

  • Infère automatiquement les modes d'entrée et de sortie à partir des objets LangChain et effectue une validation pour chaque appel d'API, fournissant des messages d'erreur détaillés
  • Page de documentation de l'API contenant JSONSchema et Swagger
  • Points d'extrémité /invoke/, /batch/ et /stream/ efficaces prenant en charge de nombreuses requêtes simultanées sur un seul serveur
  • Point d'extrémité /stream_log/ pour diffuser toutes (ou une partie) des étapes intermédiaires de la chaîne/agent
  • Nouvelle fonctionnalité depuis la version 0.0.40, prend en charge astream_events pour faciliter la diffusion sans analyser la sortie de stream_log
  • Page /playground/ avec sortie en streaming et étapes intermédiaires
  • Traçabilité intégrée en option vers LangSmith, simplement en ajoutant votre clé API
  • Construit avec des bibliothèques Python open source éprouvées sur le terrain telles que FastAPI, Pydantic, uvloop et asyncio
  • Appelle le serveur LangServe à l'aide d'un SDK client comme pour appeler localement un Runnable (ou en appelant directement l'API HTTP)
  • LangServe Hub

3. Limitations

  • Les rappels client pour les événements provenant du serveur ne sont pas encore pris en charge
  • La documentation OpenAPI n'est pas générée lors de l'utilisation de Pydantic V2. FastAPI ne prend pas en charge les espaces de noms mixtes pydantic v1 et v2. Voir la section ci-dessous pour plus de détails.

4. Installation

Vous pouvez installer LangServe en utilisant la commande suivante :

pip install "langserve[all]"

Ou installer le code client en utilisant pip install "langserve[client]", et le code serveur en utilisant pip install "langserve[server]".

4. Application d'exemple

Ci-dessous, nous montrons comment publier des modèles, des chaînes et des agents définis dans LangChain en tant qu'API REST pour que d'autres applications puissent les appeler. Si vous êtes familiarisé avec FastAPI, c'est simple, il suffit d'utiliser la classe utilitaire fournie par langserve pour enregistrer les routes FastAPI.

L'exemple suivant déploie un modèle de discussion OpenAI, un modèle de discussion Anthropic et une chaîne utilisant le modèle Anthropic pour raconter des blagues sur des sujets spécifiques.

Voici le code d'exemple :

from fastapi import FastAPI
from langchain.prompts import ChatPromptTemplate
from langchain.chat_models import ChatAnthropic, ChatOpenAI
from langserve import add_routes

app = FastAPI(
    title="Serveur LangChain",
    version="1.0",
    description="Serveur API simple utilisant l'interface Runnable de LangChain",
)

add_routes(
    app,
    ChatOpenAI(),
    path="/openai",
)

add_routes(
    app,
    ChatAnthropic(),
    path="/anthropic",
)

model = ChatAnthropic()
prompt = ChatPromptTemplate.from_template("raconte-moi une blague sur {sujet}")
add_routes(
    app,
    prompt | model,
    path="/blague",
)

if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="localhost", port=8000)

Si vous avez l'intention d'appeler les points d'extrémité à partir d'un navigateur, vous devez également définir des en-têtes CORS. Vous pouvez y parvenir en utilisant le middleware intégré dans FastAPI :

from fastapi.middleware.cors import CORSMiddleware

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
    expose_headers=["*"],
)

5. Documentation

Après avoir exécuté l'exemple ci-dessus, LangServe génère automatiquement la documentation de l'API pour toutes les routes enregistrées. Vous pouvez consulter la documentation OpenAPI générée à l'adresse suivante :

http://localhost:8000/docs

Assurez-vous de rajouter le suffixe /docs.

⚠️ Si vous utilisez pydantic v2, la documentation ne sera pas générée pour invoke, batch, stream et stream_log. Il est recommandé d'utiliser la version pydantic v1.

6. Introduction aux routes de l'API

Ci-dessous se trouve une introduction aux interfaces de l'API générées par LangServe après l'enregistrement d'une route de l'API.

Par exemple, considérez le code suivant :

add_routes(
    app,
    runnable,
    path="/my_runnable",
)

LangServe générera les interfaces suivantes :

  • POST /my_runnable/invoke - Interface pour l'invocation du modèle
  • POST /my_runnable/batch - Interface pour l'invocation en lot du modèle
  • POST /my_runnable/stream - Interface pour l'invocation en continu du modèle
  • POST /my_runnable/stream_log - Interface pour l'invocation en continu du modèle avec sortie de journal
  • POST /my_runnable/astream_events - Invocation de modèle en continu asynchrone avec sortie d'événements
  • GET /my_runnable/input_schema - Description des paramètres d'interface pour l'invocation du modèle
  • GET /my_runnable/output_schema - Description des paramètres d'interface pour la sortie du modèle
  • GET /my_runnable/config_schema - Description de la configuration du modèle

7. Espace de jeux (Playground)

LangServe offre une page de débogage UI pour chaque route enregistrée, rendant pratique le débogage des services Chain, Agent, et autres services LangChain que nous définissons.

Vous pouvez accéder à l'exemple de l'Espace de jeux dans le format suivant : visitez /my_runnable/playground/.