Lancez sans effort les API LangChain avec l'intégration LangServe et MinIO

Notre voyage à travers le monde innovant de a dévoilé ses capacités substantielles à transformer la gestion des données et les fonctionnalités des applications. LangChain Au cours de discussions précédentes, nous avons abordé plusieurs sujets tout en explorant les capacités complexes de LangChain. Dans cet article, nous nous appuierons sur les concepts abordés dans « Autonomiser les agents Langchain avec MinIO » à mesure que nous étendons les fonctionnalités d'un agent MinIO pour encapsuler des capacités supplémentaires et déployer l'agent personnalisé via LangServe. Présentation pas à pas de l'exploitation des chargeurs S3 de LangChain et de l'API OpenAI pour créer des agents d'IA conversationnels personnalisés, établissant ainsi une approche rationalisée pour la gestion des données. Récupération innovante du bucket S3 avec LangChain : Une plongée approfondie dans l'exploitation de MinIO, montrant comment LangChain, associé au GPT d'OpenAI, ouvre de nouvelles frontières dans le traitement des données d'IA et de ML. Autonomiser les agents LangChain avec MinIO : Forts de ces connaissances, nous nous concentrons désormais sur , un outil essentiel dans la transition des applications LangChain du développement au déploiement, simplifiant le processus de lancement d'API prêtes pour la production. LangServe LangServe : simplifier le déploiement des applications LangChain constitue la pierre angulaire pour les développeurs, éliminant les complexités traditionnellement associées au déploiement d'API. Il permet une transition en douceur des applications LangChain intégrées à MinIO vers des API accessibles et conviviales. Voici comment LangServe redéfinit le paysage du déploiement : LangServe les capacités d'automatisation de LangServe génèrent sans effort les points de terminaison d'API nécessaires, rationalisant les efforts de développement et réduisant considérablement le temps de déploiement. Création automatique de points de terminaison d'API : grâce à son inférence de schéma intelligente, LangServe garantit que les API offrent des interfaces bien définies, facilitant une intégration plus facile et une expérience utilisateur transparente. Génération et validation de schémas : LangServe offre une variété de points de terminaison pour répondre à divers besoins d'applications, des opérations synchrones aux mises à jour en temps réel, offrant aux développeurs une flexibilité inégalée. Configuration des points de terminaison personnalisable : Peut-être sa fonctionnalité la plus intéressante, la capacité de LangServe à s'intégrer de manière transparente au code LangChain existant signifie que les développeurs peuvent exploiter leur base de code et leur expertise actuelles sans modifications significatives. Intégration sans effort : Plonger profondément dans LangChain et Langserve Nous approfondirons le processus d'intégration de MinIO avec LangChain dans les étapes suivantes. Créez une application LangChain avec . langchain-cli Développez un agent LangChain personnalisé dans un fichier . agent.py Implémentez notre agent dans pour qu'il s'exécute en tant qu'API LangServe. server.py Utilisation de l'interface de ligne de commande de LangChain pour créer des applications Le déploiement d'applications LangChain avec LangServe apporte un parcours d'intégration transparent, comblant le fossé entre les fonctionnalités complexes d'IA et l'exposition aux API RESTful, permettant aux développeurs d'exploiter efficacement l'ensemble des capacités de LangChain, établissant ainsi une nouvelle norme pour le déploiement d'applications intelligentes dans le paysage numérique en évolution rapide d'aujourd'hui. . LangChain offre une méthode pratique et simple pour créer des applications à l'aide de leur qui peut être installé avec . Ce package fournit une interface qui permet aux utilisateurs de créer facilement de nouvelles applications en utilisant les applications existantes. ou créer le vôtre. langchain-cli bibliothèque pip Modèles d'applications LangChain Remarque : Tous les fichiers nécessaires se trouvent dans le référentiel MinIO « blog-assets » sous le répertoire nommé « ». minio-langserve-deployment Pour créer une nouvelle application LangChain, nous pouvons commencer avec les commandes suivantes pour créer un et installer le package : environnement virtuel langchain-cli mkdir minio-langserve-testing cd minio-Langserve-testing python -m venv .myenv source .myenv/bin/activate pip install langchain-cli Afin de créer une nouvelle application à l'aide nous pouvons taper dans notre terminal, la commande suivante est écrite pour créer un nouveau répertoire d'application nommé . langchain-cli langchain my-app langchain app new my-app L'application langchain créée avec les commandes ci-dessus fait tout le gros du travail en créant un environnement cohérent pour le développement. La structure d’une nouvelle application LangChain prête à l’emploi ressemble à ceci : ./my-app ├── Dockerfile ├── README.md ├── app │ ├── __init__.py │ └── server.py ⇐ (This is where we will import our agent into) ├── packages ⇐ (This directory is where we will write our agent) │ └── README.md └── pyproject.toml Dans les étapes suivantes, nous apporterons des modifications à l'application LangChain nouvellement créée ( ) en écrivant un nouveau fichier nommé packages/agent.py et en apportant des modifications à . my-app app/server.py Voici les fichiers dont nous parlerons dans cet article : my-app/packages/agent.py my-app/app/server.py Développement d'un agent LangChain MinIO à déployer avec LangServe Pour illustrer le déploiement d'un agent LangChain intégré à MinIO avec LangServe, nous commencerons par enregistrer le code de la chaîne d'agents dans . agent.py Tout d'abord, initialisons un qui se connecte au serveur public "play.min.io:443". Ce fichier finira par appeler de LangChain, nous permettant de le transmettre au wrapper de LangServe. minio_client agent_executor add_route Remarque : Lecture de la publication précédente " Outil MinIO Langchain " fournira des informations précieuses sur le développement conjoint avec LangChain et MinIO. Nous suivrons une approche conceptuelle similaire mais avec une logique d'outil MinIO supplémentaire. Pour commencer, ouvrez le fichier agent.py à l'aide d'un éditeur de texte : sudo nano packages/agent.py Au début du fichier, importez les packages nécessaires, tels que , , et : os io minio ChatOpenAI import os import io from minio import Minio from minio.error import S3Error from langchain_openai import ChatOpenAI os.environ["OPENAI_API_KEY"] = " >" # Initialize llm llm = ChatOpenAI(api_key=os.environ["OPENAI_API_KEY"]) # Initialize MinIO client minio_client = Minio('play.min.io:443', access_key='minioadmin', secret_key='minioadmin', secure=True) Dans cet extrait de code, nous importons les packages requis et initialisons le modèle de langage ChatOpenAI avec la clé API OpenAI stockée dans la variable d'environnement . Nous initialisons également le minio_client en fournissant les détails de connexion nécessaires au serveur public "play.min.io". OPENAI_API_KEY Ensuite, définissons le bucket MinIO et créons-le s'il n'existe pas : # This variable will check if bucket exists bucket_name = "test" try: # Check if bucket exists if not minio_client.bucket_exists(bucket_name): # Create the bucket because it does not exist minio_client.make_bucket(bucket_name) print(f"Bucket '{bucket_name}' created successfully.") else: print(f"Bucket '{bucket_name}' already exists.") except S3Error as err: print(f"Error encountered: {err}") Ici, nous définissons le comme "test" et vérifions s'il existe déjà à l'aide de la méthode . Si le bucket n'existe pas, nous le créons en utilisant . Si le bucket existe déjà, nous imprimons un message l'indiquant. Nous incluons également la gestion des erreurs à l'aide d'un bloc try-sauf pour détecter et imprimer toute pouvant survenir pendant le processus. bucket_name minio_client.bucket_exists() minio_client.make_bucket() S3Error Une fois la configuration de base en place, nous pouvons maintenant procéder à la définition des fonctions de l'outil MinIO et à la création de l'exécuteur d'agent, que nous aborderons dans les prochaines étapes. Utilisation du décorateur de fonctions de LangChain pour les outils d'agent Langchain et Langserve proposent tous deux une approche similaire pour encapsuler la logique et les fonctionnalités, ce qui permet de les intégrer de manière transparente dans la logique des agents et de la chaîne. Ceci est réalisé grâce à l'utilisation du décorateur avec une docstring détaillée à l'intérieur de la fonction définie, qui marque les fonctions comme des composants réutilisables pouvant être utilisés et interprétés par l'agent IA. @tool Examinons de plus près les exemples de code fournis : from langchain.agents import tool @tool def upload_file_to_minio(bucket_name: str, object_name: str, data_bytes: bytes): """ Uploads a file to MinIO. Parameters: bucket_name (str): The name of the bucket. object_name (str): The name of the object to create in the bucket. data_bytes (bytes): The raw bytes of the file to upload. """ data_stream = io.BytesIO(data_bytes) minio_client.put_object(bucket_name, object_name, data_stream, length=len(data_bytes)) return f"File {object_name} uploaded successfully to bucket {bucket_name}." La fonction est décorée de , indiquant qu'il s'agit d'un composant réutilisable. Il prend en compte les paramètres nécessaires pour télécharger un fichier dans un compartiment MinIO, tels que le nom du compartiment, le nom de l'objet et les octets bruts du fichier. La fonction utilise pour effectuer l'opération de téléchargement de fichier et renvoie un message de réussite une fois terminée. upload_file_to_minio @tool minio_client @tool def download_file_from_minio(file_info): """ Custom function to download a file from MinIO. Expects file_info dict with 'bucket_name', 'object_name', and 'save_path' keys. 'save_path' should be the local path where the file will be saved. """ bucket_name = file_info['bucket_name'] object_name = file_info['object_name'] save_path = file_info['save_path'] minio_client.get_object(bucket_name, object_name, save_path) De même, la fonction est également marquée par . Il attend un dictionnaire contenant les informations nécessaires pour télécharger un fichier à partir d'un compartiment MinIO, telles que le nom du compartiment, le nom de l'objet et le chemin local où le fichier doit être enregistré. La fonction utilise pour récupérer l'objet du compartiment spécifié et l'enregistrer dans le chemin local désigné. download_file_from_minio @tool file_info minio_client @tool def list_objects_in_minio_bucket(file_info): """ Custom function to list objects in a MinIO bucket. Expects file_info dict with 'bucket_name' key. Returns a list of dictionaries containing 'ObjectKey' and 'Size' keys. """ bucket_name = file_info['bucket_name'] response = minio_client.list_objects(bucket_name) return [{'ObjectKey': obj.object_name, 'Size': obj.size} for obj in response.items] La fonction , également agrémentée de se charge de lister les objets présents dans un bucket MinIO. Il attend un dictionnaire avec la clé . La fonction utilise pour récupérer la liste des objets dans le compartiment spécifié et renvoie une liste de dictionnaires contenant la clé et la taille de l'objet pour chaque objet. list_objects_in_minio_bucket @tool file_info bucket_name minio_client En encapsulant ces fonctionnalités sous forme d'outils, Langchain et Langserve permettent à l'agent IA de les intégrer de manière transparente dans sa logique et son processus décisionnel. L'agent peut sélectionner et exécuter intelligemment l'outil approprié en fonction de la tâche à accomplir, améliorant ainsi ses capacités et permettant des interactions plus complexes et dynamiques avec le système de stockage MinIO. Comprendre la méthode exécutable de LangChain LangChain propose une myriade de méthodes pour construire avec une logique personnalisée, l'une de ces approches est celle de « ». Quant à la logique démonstrative ci-dessus, est une construction fournie par LangChain qui permet de traiter les fonctions comme des unités exécutables dans la logique de l'agent IA. exécutables RunnableLambda from langchain_core.runnables import RunnableLambda upload_file_runnable = RunnableLambda(upload_file_to_minio) download_file_runnable = RunnableLambda(download_file_from_minio) list_objects_runnable = RunnableLambda(list_objects_in_minio_bucket) En encapsulant les fonctions de l'outil avec RunnableLambda, nous créons des instances exécutables ( , et ) qui peuvent être invoquées par l'agent lors de son exécution. Ces exécutables encapsulent les fonctions de l'outil correspondantes et fournissent une interface uniforme permettant à l'agent d'interagir avec elles. upload_file_runnable download_file_runnable list_objects_runnable tools = [upload_file_to_minio, download_file_from_minio, list_objects_in_minio_bucket] llm_with_tools = llm.bind_tools(tools) La liste des outils contient les fonctions de l'outil d'origine ( , et ), qui servent de blocs de construction pour les capacités de l'agent. La ligne lie les outils au modèle de langage ( ), établissant une connexion entre les capacités de raisonnement du modèle et les fonctionnalités spécifiques fournies par les outils. Le résultant représente le modèle de langage amélioré avec les connaissances et la capacité d'utiliser les outils liés. upload_file_to_minio download_file_from_minio list_objects_in_minio_bucket llm.bind_tools(tools) llm llm_with_tools L'utilisation de et la liaison d'outils au modèle de langage démontrent la flexibilité et l'extensibilité de LangChain et LangServe dans la création d'agents d'IA puissants et personnalisables. En combinant la puissance du modèle de langage avec les fonctionnalités spécifiques encapsulées dans les outils, l'agent IA acquiert la capacité d'effectuer des tâches complexes, telles que le téléchargement de fichiers vers MinIO, le téléchargement de fichiers depuis MinIO et la liste d'objets dans un compartiment MinIO. RunnableLambda Rédaction d'un modèle d'invite pour guider notre agent Ensuite, nous nous concentrons sur le modèle d'invite qui guide l'agent IA dans la compréhension et la réponse aux entrées de l'utilisateur. Il est défini à l'aide de la méthode , qui prend une liste de messages représentés sous forme de tuples contenant le rôle et le contenu du message. ChatPromptTemplate.from_messages() from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder from langchain.agents.format_scratchpad.openai_tools import format_to_openai_tool_messages from langchain.agents.output_parsers.openai_tools import OpenAIToolsAgentOutputParser from langchain_core.messages import AIMessage, HumanMessage prompt_template = ChatPromptTemplate.from_messages([ ("system", "You are a powerful assistant equipped with file management capabilities."), ("user", "{input}"), MessagesPlaceholder(variable_name="agent_scratchpad"), ]) L'invite se compose de trois messages : Un message « système » définissant le contexte de l'agent IA en tant qu'assistant puissant doté de capacités de gestion de fichiers. Un message "utilisateur" représentant l'entrée de l'utilisateur, utilisant l'espace réservé . {input} Un nommé "agent_scratchpad" pour stocker les étapes intermédiaires et le processus de réflexion de l'agent. MessagesPlaceholder La fonction formate le bloc-notes de l'agent dans un format compatible pour les outils d'OpenAI, tandis que la classe OpenAIToolsAgentOutputParser analyse la réponse du modèle dans un format structuré interprétable par l'agent. format_to_openai_tool_messages Les classes et représentent les messages échangés entre l'agent et l'utilisateur, fournissant un moyen standardisé de gérer la communication au sein de la logique de l'agent. AIMessage HumanMessage En définissant le modèle d'invite, nous fournissons à l'agent IA une structure et un contexte clairs pour comprendre et répondre aux entrées de l'utilisateur, en utilisant l'espace réservé « agent_scratchpad » pour suivre ses étapes intermédiaires et son processus de réflexion tout en résolvant la tâche. Définir l'agent avec ses outils Enfin, pour compléter notre nous définissons notre agent et créons un AgentExecutor qui peut être importé et appelé à partir d'un script à l'aide de la fonction de la bibliothèque LangServe. agent.py server.py add_route Nous instancions les composants nécessaires et les chaînons ensemble pour créer une variable d'agent unique. agent = ( { "input": lambda x: x["input"], "agent_scratchpad": lambda x: format_to_openai_tool_messages(x["intermediate_steps"]), } | prompt_template | llm_with_tools | OpenAIToolsAgentOutputParser() ) L'agent est défini à l'aide d'une combinaison de dictionnaires et d'opérations chaînées. La clé d'entrée extrait les entrées de l'utilisateur des données entrantes, tandis que la clé formate les étapes intermédiaires du processus de réflexion de l'agent à l'aide de la fonction . L'agent intègre également le modèle d'invite ( ), le modèle de langage avec les outils ( ) et l'analyseur de sortie ( ). agent_scratchpad format_to_openai_tool_messages prompt_template llm_with_tools OpenAIToolsAgentOutputParser() Définition d'un AgentExecutor pour exécuter l'agent Pour créer un , nous lui fournissons l'agent défini, les outils disponibles et définissons pour une sortie détaillée. AgentExecutor verbose=True from langchain.agents import tool, AgentExecutor agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True) utilise l'agent et les outils fournis pour comprendre la tâche et sélectionner l'outil approprié en fonction de la saisie de l'utilisateur. Au lieu d'avoir des invites distinctes pour chaque outil, l'agent utilise un modèle d'invite unique qui le guide sur la façon d'utiliser les outils en fonction de l'entrée donnée. L'agent sélectionne dynamiquement l'outil approprié pendant le processus d'exécution. AgentExecutor Définir la route LangServe avec notre AgentExecutor La configuration de notre application en l'intégrant à LangServe fournit un chemin simplifié pour déployer et gérer nos applications LangChain en tant qu'API. FastAPI est choisi pour ses performances et sa facilité d'utilisation, prenant en charge les opérations asynchrones et générant automatiquement la documentation de l'API. Le , construit avec FastAPI, enrichit cela en simplifiant le déploiement d'objets LangChain en tant qu'API REST, offrant un middleware intégré pour les paramètres CORS afin de garantir que notre API peut être appelée en toute sécurité à partir de différents domaines. Bibliothèque LangServe Pour des démonstrations plus approfondies/de cas d'utilisation, peuvent être explorées en visitant le langchain-ai/langserve Dépôt GitHub sous le répertoire d'exemples . from fastapi import FastAPI app = FastAPI( title="MinIO Agent API", version="1.0", description="A conversational agent facilitating data storage and retrieval with MinIO", ) Pour définir les en-têtes CORS, nous pouvons ajouter les lignes suivantes pour améliorer notre sécurité : from fastapi.middleware.cors import CORSMiddleware # Set all CORS enabled origins app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], expose_headers=["*"], ) Implémentation de l'agent à l'aide de LangServe Maintenant que nous avons terminé avec nous pouvons l'importer et utiliser la fonction de la bibliothèque LangServe dans notre script . packages/agent.py add_route app/server.py from packages.agent import agent_executor from langserve import add_routes add_routes( app, agent_executor.with_types(input_type=Input, output_type=Output).with_config( {"run_name": "agent"} ), path=”/invoke” ) En appelant , nous ajoutons une route à notre application serveur ( ) qui mappe le chemin à la fonction . Cela permet à l'exécuteur de l'agent d'être invoqué lorsqu'une requête est adressée au point de terminaison . add_route(app, agent_executor(…), path="/invoke") app /invoke agent_executor() /invoke Avec cette configuration, le serveur peut gérer les demandes entrantes, les transmettre à l'exécuteur de l'agent et renvoyer la réponse de l'agent au client. L'exécuteur d'agent utilise l'agent défini, qui intègre le modèle d'invite, le modèle de langage avec des outils et l'analyseur de sortie, pour traiter l'entrée de l'utilisateur et générer une réponse appropriée sur la base des outils disponibles. Lancement de l'application LangServe via Uvicorn Pour démarrer l'application LangServe, nous utilisons Uvicorn comme serveur ASGI, préparant ainsi le terrain pour l'exécution de notre application. Cet extrait de code est essentiel car il active le serveur, en spécifiant l'hôte universel et le port désigné pour les points d'accès de l'application. if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000) En intégrant ce bloc dans l'entrée principale de l'application, nous garantissons qu'Uvicorn prend la barre lorsque le script est exécuté directement, éclairant ainsi notre application FastAPI sur un hôte et un port prédéfinis. Cette approche simplifie non seulement le processus de déploiement, mais marque également une entrée claire pour exécuter l'application dans un environnement de développement ou de production. Démarrage de l'application serveur Le code ci-dessus a démontré une approche modulaire qui inclut l'utilisation de la bibliothèque « langchain-cli », la création d'une nouvelle application langchain et l'enregistrement de la logique de la chaîne dans tandis que l'implémentation de FastAPI et LangServe est enregistrée dans . agent.py server.py Ceci étant notre dernière étape, nous enregistrerons notre code d'application sur dans le but démonstratif de créer notre application. server.py La façon la plus simple d'exécuter notre service est de : python server.py Cette commande exécutera l'application, tout en renvoyant tous les journaux ou messages d'erreur qui doivent encore être débogués. Aire de jeux LangServe Dans la sortie Python, les journaux LangServe identifient comme point de terminaison de l'application. Nous pouvons maintenant visiter le WebUI du terrain de jeu ainsi que la documentation automatisée de notre API qui est disponible en visitant le chemin de notre API ; nous offrant une approche simplifiée des tests et de la configuration en incluant le bouton Essayer pour chacune des fonctionnalités de nos applications, ainsi que des requêtes cURL prédéfinies que nous pouvons exécuter à partir de l'interface Web. /invoke/playground /docs Par conséquent, notre agent LangChain intégré à MinIO est désormais habilement transformé en une API déployable, prête à être développée et étendue pour les utilisateurs avec des fonctionnalités allant du traitement par lots aux interactions en temps réel. Utilisation ultérieure de l'API LangServe Une fois l'application LangServe opérationnelle, nous pouvons l'utiliser depuis l'extérieur de notre , en ciblant notre point de terminaison et en l'encapsulant dans le module de Langserve : server.py RemoteRunnable from langserve import RemoteRunnable remote_runnable = RemoteRunnable("http://localhost:8000/ /") Ajouter LangChain propose une vaste gamme de modules dans ses bibliothèques, présentant une boîte à outils diversifiée conçue pour permettre aux développeurs de créer des applications sophistiquées basées sur l'IA. Des constructions de chaînes complexes à l'intégration transparente avec divers modèles d'IA, l'architecture modulaire de LangChain facilite un large éventail de fonctionnalités, permettant la création de solutions hautement personnalisables et avancées dans le domaine de l'IA et de l'apprentissage automatique. Développer des pipelines d'IA avec LangServe LangServe non seulement démystifie mais simplifie considérablement le processus de déploiement des applications LangChain. En comblant le fossé entre le développement et le déploiement, il garantit que les applications innovantes tirant parti de MinIO et LangChain peuvent rapidement passer du concept à la réalité, prêtes à être intégrées dans l'écosystème plus large et à améliorer l'expérience utilisateur. Grâce au développement couvert dans nos explorations, nous avons constaté l'intégration transparente de MinIO avec est tout à fait possible, et comment joue un rôle central dans le déploiement de ces solutions avancées. Alors que nous continuons à naviguer dans le paysage changeant de l’IA et du ML, des outils comme LangServe resteront déterminants pour mettre les technologies de pointe à l’avant-garde du développement d’applications. LangChaîne LangServe Chez MinIO, nous sommes stimulés par la créativité et le potentiel de la communauté des développeurs en cette ère riche en technologies. Il n'y a pas de meilleur moment pour la collaboration et l'échange de connaissances. Nous sommes impatients de communiquer avec vous ! Rejoignez-nous sur notre canal pour poursuivre la conversation et atteindre de nouveaux sommets ensemble. Slack MinIO