Expérimentez l'interface Chainlit AI avec RAG sur Upsun

Chainlit : un cadre d'IA conversationnelle évolutif

Chainlit est un framework Python asynchrone open source conçu pour créer des applications d'IA conversationnelles robustes et évolutives. Il offre une base flexible, permettant aux développeurs d'intégrer de manière transparente des API externes, une logique personnalisée et des modèles locaux.

Ce tutoriel présente deux implémentations de Retrieval Augmented Generation (RAG) dans Chainlit :

1. Exploiter les assistants OpenAI avec les documents téléchargés.
2. Utilisation de llama_index avec un dossier de documents local.

Configuration locale de Chainlit

Environnement virtuel

Créez un environnement virtuel :

<code class="language-bash">mkdir chainlit && cd chainlit
python3 -m venv venv
source venv/bin/activate</code>

Installer les dépendances

Installez les packages requis et enregistrez les dépendances :

<code class="language-bash">pip install chainlit
pip install llama_index  # For implementation #2
pip install openai
pip freeze > requirements.txt</code>

Tester Chainlit

Démarrer Chainlit :

<code class="language-bash">chainlit hello</code>

Accédez à l'espace réservé sur https://www.php.cn/link/2674cea93e3214abce13e072a2dc2ca5

Déploiement Upsun

Initialisation de Git

Initialiser un dépôt Git :

<code class="language-bash">git init .</code>

Créer un fichier .gitignore :

<code>.env
database/**
data/**
storage/**
.chainlit
venv
__pycache__</code>

Création du projet Upsun

Créez un projet Upsun à l'aide de la CLI (suivez les invites). Upsun configurera automatiquement le référentiel distant.

Configuration

Exemple de configuration Upsun pour Chainlit :

<code class="language-yaml">applications:
  chainlit:
    source:
      root: "/"
    type: "python:3.11"
    mounts:
      "/database":
        source: "storage"
        source_path: "database"
      ".files":
        source: "storage"
        source_path: "files"
      "__pycache__":
        source: "storage"
        source_path: "pycache"
      ".chainlit":
        source: "storage"
        source_path: ".chainlit"
    web:
      commands:
        start: "chainlit run app.py --port $PORT --host 0.0.0.0"
      upstream:
        socket_family: tcp
      locations:
        "/":
          passthru: true
        "/public":
          passthru: true
    build:
      flavor: none
    hooks:
      build: |
        set -eux
        pip install -r requirements.txt
      deploy: |
        set -eux
      # post_deploy: |
routes:
  "https://{default}/":
    type: upstream
    upstream: "chainlit:http"
  "https://www.{default}":
    type: redirect
    to: "https://{default}/"</code>

Définissez la variable d'environnement OPENAI_API_KEY via Upsun CLI :

<code class="language-bash">upsun variable:create env:OPENAI_API_KEY --value=sk-proj[...]</code>

Déploiement

Commettre et déployer :

<code class="language-bash">git add .
git commit -m "First chainlit example"
upsun push</code>

Examinez l'état du déploiement. Un déploiement réussi montrera que Chainlit s'exécute sur votre environnement principal.

Implémentation 1 : Assistant OpenAI et fichiers téléchargés

Cette implémentation utilise un assistant OpenAI pour traiter les documents téléchargés.

Assistant Création

Créez un nouvel assistant OpenAI sur la plateforme OpenAI. Définissez les instructions du système, choisissez un modèle (avec format de réponse texte) et maintenez la température basse (par exemple, 0,10). Copiez l'ID de l'assistant (asst_[xxx]) et définissez-le comme variable d'environnement :

<code class="language-bash">upsun variable:create env:OPENAI_ASSISTANT_ID --value=asst_[...]</code>

Téléchargement de contenu

Téléchargez vos documents (Markdown de préférence) vers l'assistant. OpenAI créera un magasin de vecteurs.

Assistant Logique (app.py)

Remplacez le contenu app.py par le code fourni. Éléments clés : @cl.on_chat_start crée un nouveau fil de discussion OpenAI et @cl.on_message envoie les messages de l'utilisateur au fil de discussion et diffuse la réponse.

Commit et déployez les modifications. Testez l'assistant.

Implémentation 2 : OpenAI llama_index

Cette implémentation utilise llama_index pour la gestion des connaissances locales et OpenAI pour la génération de réponses.

Création de succursale

Créer une nouvelle branche :

<code class="language-bash">mkdir chainlit && cd chainlit
python3 -m venv venv
source venv/bin/activate</code>

Création de dossiers et montages

Créez des dossiers data et storage. Ajoutez des montures à la configuration Upsun.

Mise à jour app.py

Mettez à jour app.py avec le code llama_index fourni. Ce code charge des documents, crée un VectorStoreIndex et l'utilise pour répondre aux requêtes via OpenAI.

Déployez le nouvel environnement et téléchargez le dossier data. Testez l'application.

Bonus : Authentification

Ajoutez une authentification à l'aide d'une base de données SQLite.

Configuration de la base de données

Créez un dossier database et ajoutez un support à la configuration Upsun. Créez une variable d'environnement pour le chemin de la base de données :

<code class="language-bash">pip install chainlit
pip install llama_index  # For implementation #2
pip install openai
pip freeze > requirements.txt</code>

Logique d'authentification (app.py)

Ajoutez une logique d'authentification à app.py en utilisant @cl.password_auth_callback. Cela ajoute un formulaire de connexion.

Créez un script pour générer des mots de passe hachés. Ajoutez des utilisateurs à la base de données (à l'aide de mots de passe hachés). Déployez l'authentification et testez la connexion.

Conclusion

Ce tutoriel a démontré le déploiement d'une application Chainlit sur Upsun avec deux implémentations RAG et une authentification. L'architecture flexible permet diverses adaptations et intégrations.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!