LazyLLM : l'outil de développement Open Source Low-Code de Shangtang pour la création d'applications corporelles multi-intelligentes

Introduction générale

LazyLLM est un outil open source développé par l'équipe LazyAGI, qui vise à simplifier le processus de développement d'applications multi-intelligence à grand modèle. Il aide les développeurs à créer rapidement des applications d'intelligence artificielle complexes et à gagner du temps sur les configurations techniques fastidieuses grâce à un déploiement en un clic et à des mécanismes de passerelle légers. Que vous soyez un développeur débutant ou expérimenté, LazyLLM vous apporte son soutien : les novices peuvent facilement démarrer avec des modules préconstruits, tandis que les experts peuvent réaliser des développements avancés grâce à des fonctions de personnalisation flexibles. L'outil met l'accent sur l'efficacité et la praticité, en intégrant les composants préférés pour s'assurer que les applications prêtes à la production sont construites au coût le plus bas possible. Avec plus de 1100 étoiles sur GitHub, la communauté est active et les mises à jour sont permanentes.

Liste des fonctions

• Déployer des applications complexes en un seul clicLe système de gestion de l'information (SGI) : il prend en charge l'ensemble du processus, de la validation du prototype à la mise en production, grâce à la configuration automatisée des services du sous-module.
• Compatibilité multiplateformeLes avantages : s'adapter aux serveurs " bare metal ", aux machines de développement, aux clusters Slurm et aux clouds publics sans modification du code.
• Gestion des flux de données (Flow)Le système de gestion de l'information : Il fournit des processus prédéfinis tels que le pipeline et le parallèle pour organiser facilement la logique d'application complexe.
• composant modulaireLes outils d'aide à la décision : Prise en charge de la personnalisation et des extensions, intégration d'algorithmes d'utilisateurs ou d'outils de tiers.
• Mécanisme de passerelle légèreSimplifier le démarrage du service et la configuration de l'URL pour un développement plus efficace.
• Soutien au développement du multi-intelligenceLes applications : Construire rapidement des applications contenant de multiples agents d'intelligence artificielle adaptés à des tâches de modélisation de grande envergure.

Utiliser l'aide

Processus d'installation

LazyLLM est un projet open source basé sur Python, le processus d'installation est simple et direct. Voici les étapes détaillées :

Préparation de l'environnement

1. Vérification des exigences du systèmePour ce faire, vous devez vous assurer que Python 3.8 ou une version supérieure est installé sur votre appareil.
2. Installation de GitSi vous n'avez pas installé Git, vous pouvez utiliser un outil de ligne de commande tel que apt-get install git peut-être brew install git) Installation.
3. Création d'un environnement virtuel (facultatif mais recommandé): :

   python -m venv lazyllm_env
   source lazyllm_env/bin/activate  # Linux/Mac
   lazyllm_env\Scripts\activate  # Windows

Téléchargement et installation

1. Cloner un dépôt GitHub: :

   git clone https://github.com/LazyAGI/LazyLLM.git
   cd LazyLLM
   

2. Installation des dépendances: :
   • Exécutez la commande suivante pour installer les bibliothèques requises :

     pip install -r requirements.txt
     

   • Si vous rencontrez un conflit de dépendance, essayez de mettre à jour Pip :

     pip install --upgrade pip
     

3. Vérifier l'installation: :
   • Exécutez l'exemple de code pour confirmer la réussite de l'installation :

     python -m lazyllm --version
     

   • Si le numéro de version est renvoyé (par exemple v0.5), l'installation est terminée.

Facultatif : Déploiement Docker

• LazyLLM prend en charge l'empaquetage d'images Docker en un seul clic :
  1. Installer Docker (voir le site officiel : https://docs.docker.com/get-docker/).
  2. Exécutez-le dans le répertoire racine du projet :

     docker build -t lazyllm:latest .
     docker run -it lazyllm:latest
     

Comment l'utiliser

Au cœur de LazyLLM se trouve la capacité à construire rapidement des applications d'IA grâce à la modularité et à la gestion des flux de données. Vous trouverez ci-dessous un guide pratique détaillé des principales fonctionnalités :

Fonctionnalité 1 : Déployer des applications complexes en un seul clic

• procédure: :
  1. Préparation du fichier de configuration de l'application: Créer l'espace de travail config.yamldéfinir des modules et des services. Par exemple :

     modules:
     - name: llm
     type: language_model
     url: http://localhost:8000
     - name: embedding
     type: embedding_service
     url: http://localhost:8001
     

  2. Démarrage des services: :

     python -m lazyllm deploy
     

  3. vérifier l'étatLes modules de l'application peuvent être utilisés pour le contrôle de l'accès à l'application.
• Description détailléeCette fonction connecte automatiquement les sous-modules par l'intermédiaire d'une passerelle légère, ce qui élimine la nécessité de configurer manuellement les URL et en fait un outil idéal pour le prototypage rapide.

Fonctionnalité 2 : compatibilité multiplateforme

• procédure: :
  1. Plates-formes désignéesAjouter des paramètres à la ligne de commande, par exemple :

     python -m lazyllm deploy --platform slurm
     

  2. Environnements de commutationIl n'est pas nécessaire de modifier le code, il suffit de remplacer --platform paramètres (par exemple cloud peut-être bare_metal).
• scénario d'applicationLes développeurs peuvent migrer en toute transparence vers l'informatique dématérialisée après les tests locaux afin de réduire les efforts d'adaptation.

Fonction 3 : Gestion des flux de données (Flow)

• procédure: :
  1. Définir le flux de donnéesAppel d'un flux prédéfini dans un script Python : Appel d'un flux prédéfini dans un script Python : Appel d'un flux prédéfini dans un script Python, comme la construction d'un pipeline :

     from lazyllm import pipeline
     flow = pipeline(
     step1=lambda x: x.upper(),
     step2=lambda x: f"Result: {x}"
     )
     print(flow("hello"))  # 输出 "Result: HELLO"
     

  2. Exécution de processus complexesLes services d'assistance technique : Multitâches en combinaison avec le système parallèle ou le système de dérivation :

     from lazyllm import parallel
     par = parallel(
     task1=lambda x: x * 2,
     task2=lambda x: x + 3
     )
     print(par(5))  # 输出 [10, 8]
     

• Description détailléeFlow fournit des interfaces standardisées pour réduire la duplication de la conversion des données et soutenir le développement collaboratif entre les modules.

Fonction 4 : Personnalisation des composants modulaires

• procédure: :
  1. Enregistrement de fonctions personnalisées: :

     from lazyllm import register
     @register
     def my_function(input_text):
     return f"Processed: {input_text}"
     

  2. Intégration dans les applicationsAppelé dans la configuration du flux ou du déploiement my_function.
• Utilisation avancéeLe système d'enregistrement des commandes Bash pour le développement de scripts hybrides est pris en charge.

Conseils et astuces

• ajuster les composants pendant les essaisLes ajouts au fil de l'eau : ajouts au fil de l'eau --verbose pour afficher le journal détaillé :

  python -m lazyllm deploy --verbose
  

• Soutien communautaireLes commentaires : Vous pouvez soumettre vos commentaires sur GitHub Issues et l'équipe vous répondra dans les plus brefs délais.
• mise à jour: Tirez régulièrement les codes les plus récents :

  git pull origin main
  

Grâce à ces étapes, vous pouvez rapidement commencer à utiliser LazyLLM et créer des applications allant de simples prototypes à de grands modèles au niveau de la production.