Guides

User Guide

Learn how to use deployit

Projets & collaboration

Organisez et administrez vos espaces de travail, membres et la vitrine publique d'un projet. Suivez l'historique des commits et des contenus générés pour garder la traçabilité des activités.

Gestion de projets

Créer et administrer des espaces de travail appelés projets pour centraliser repositories, agents, hooks et sites publics. Utile pour organiser les sources de code, les paramètres (langue, prompt utilisateur, clé OpenAI) et contrôler qui peut agir sur un périmètre de travail.

Création et démarrage d'un projet

Guide pas à pas pour créer un nouvel espace de travail (projet) : prérequis d'authentification, saisie du nom et des paramètres initiaux, validation et visibilité du projet dans la liste. Comprend conseils et erreurs fréquentes lors de la création.

Sources & intégrations

Connectez et maintenez toutes les sources de contenu (repositories Git, fichiers uploadés, plugins) et gérez les intégrations tierces. Comprend les outils de diagnostic, la gestion des tokens et la sécurité des webhooks.

Intégration de repositories Git

Connecter des repositories GitHub ou GitLab à un projet pour que DeployIt indexe le code, crée des webhooks et exécute des automatisations. Indispensable pour transformer commits/branches/releases en contenu et déclencher agents.

Paramètres et administration du projet

Modifier et gérer les paramètres d'un projet : nom, langue, prompt utilisateur et clé OpenAI. Procédure pour ouvrir les paramètres, éditer les champs et enregistrer les changements, ainsi que bonnes pratiques de gestion des clés et des prompts.

Indexation & recherche (RAG)

Indexez le contenu des sources dans un vecteur store et effectuez des recherches sémantiques pour fournir un contexte pertinent aux outils. Surveillez les travaux d'indexation et interagissez via un chat contextuel alimenté par le code indexé.

Indexation des sources & Recherche RAG

Indexer le contenu des repositories (fichiers, diffs de commits) dans un vecteur store (Milvus) pour récupérer du contexte via RAG. Permet aux agents et au chat d'utiliser le code source comme contexte pertinent.

Site public et branding du projet

Configurer l'apparence publique du projet : logo, couleurs, liens et domaine personnalisé. Explication du workflow de publication du site, validation du domaine et contraintes d'unicité par projet.

Automatisation & génération de contenu

Concevez et déclenchez des agents et hooks pour transformer l'activité code en contenus structurés (release notes, articles, etc.). Gérez le cycle de révision, l'envoi vers des destinations externes et les notifications associées.

Agents d'automatisation

Concevoir, exécuter et réutiliser des workflows multi-étapes pilotés par LLM (agents). Les agents transforment des commits, diffs ou prompts en contenus structurés (release notes, articles SEO, etc.).

Tableau de bord, onglets et Insights

Présentation du tableau de bord du projet et navigation entre les onglets (Chat, Agents, Site). Détail sur la génération et le formatage des insights projet (implémentation serveur et helpers front) pour l'onglet Insights.

Plateforme & accès utilisateur

Gérez l'accès à la plateforme via authentification, profils, clés API et préférences utilisateur. Fournit également les endpoints publics et utilitaires pour intégrations et diagnostics côté client.

Hooks d'automatisation (Triggers)

Configurer des déclencheurs (hooks) qui exécutent des agents automatiquement sur événements Git (push, pull_request) ou sur un planning. Permet d'automatiser la génération de contenu à partir d'activité code.

Suppression et nettoyage des ressources

Procédure sécurisée pour supprimer un projet et toutes ses ressources associées : menu de suppression, confirmation requise, et conséquences (suppression des collections Milvus, webhooks et autres indexations). Bonnes pratiques pour sauvegarder les données avant suppression.

Administration & développement

Outils et services pour les administrateurs et développeurs : facturation, base de données, migrations et utilitaires frontaux. Comprend aussi les plugins et analytics pour enrichir l'expérience produit.

GenerationLogs & Documents (Revue et publication)

Consulter, réviser, finaliser et publier les contenus générés (GenerationLogs). Les utilisateurs peuvent approuver, exporter ou renvoyer ces documents vers des destinations externes.

Ajouter et connecter un repository

Guide pas à pas pour connecter un repository GitHub ou GitLab à un projet DeployIt via OAuth ou GitHub App. Couvre l'ouverture du formulaire, le choix du fournisseur, le flux OAuth/GitHub App, la sélection du repository et la création (inclut l'ajout asynchrone via worker).

Destinations & Webhooks externes

Configurer des destinations externes (webhooks) et règles d'envoi pour recevoir automatiquement les outputs générés. Utile pour publier release notes, articles, ou intégration avec Notion/CM tools.

Gestion et suppression de repositories

Opérations courantes pour lister, afficher et supprimer des repositories connectés à un projet. Expliquer la vue Repos du projet, la suppression d'un repository et les conséquences côté DeployIt et côté Git (webhook/suppression déclenchée).

Chat contextuel (Chat with code)

Conversation interactive alimentée par LLMs avec accès au contexte code indexé du projet. Permet poser des questions sur le code, générer analyses de bugs et obtenir réponses contextualisées.

Webhooks et automatisations

Créer et gérer les webhooks nécessaires pour que DeployIt reçoive événements push, pull request et release. Inclut la création automatique de webhooks depuis la vue repository, la génération des secrets, et les erreurs usuelles liées aux permissions.

Notifications & Emails

Recevoir des alertes sur le statut d'exécution des agents et envoyer les outputs par email via templates automatisés. Permet informer les responsables et publier les résultats par email.

Diagnostiques, permissions et tokens côté client

Outils et bonnes pratiques pour diagnostiquer l'accès aux repositories, vérifier permissions et webhooks, et gérer les tokens OAuth côté client (extraction, préparation des données et détection d'expiration). Contient instructions pour lancer un diagnostic et interpréter les résultats.

Clés API & Accès programmatique

Générer et gérer des clés API pour accéder aux endpoints publics/privés de DeployIt en dehors de la session utilisateur. Utile pour intégrations CI, scripts ou automation externes.

Vue d'ensemble et concepts

Présentation du flux d'indexation, des composants (workers, Milvus, embeddings), des règles opérationnelles (asynchronisme, rate limits, retry policy) et des cas d'usage RAG pour agents et chat.

Authentification & Comptes utilisateurs

S'enregistrer, se connecter (email/password), se connecter via OAuth (GitHub/GitLab), et gérer mot de passe. Permet protéger l'accès aux projets et gérer l'identité utilisateur.

Indexation complète d'un repository

Guide pas à pas pour indexer l'ensemble d'un repository : ajout du repo, file de workers, récupération des fichiers, génération d'embeddings et insertion dans Milvus. Comportement asynchrone et impacts (quota, temps).

Équipe & Permissions

Gérer les accès aux projets via des rôles utilisateur (propriétaire, éditeur) et membres de projet. Permet contrôler qui peut modifier projets, agents et configures les intégrations.

Re-indexation incrémentale et webhooks

Processus de mise à jour ciblée : comment les webhooks Git déclenchent la re-indexation des fichiers modifiés, le rôle de updateFileIndexAndMilvus et la synchronisation vers Milvus avec gestion des retries et rate limits.

Facturation & Crédits

Suivre et gérer la facturation via Paddle et un grand-livre de crédits qui trace l'usage. Les crédits sont consommés par les appels LLM et la persistance des documents.

RAG sync manuel et recherche vectorielle

Mode d'emploi du RAG sync manuel depuis l'interface, description du backend qui récupère les commits et met à jour l'index, et guide pour interroger Milvus par texte depuis les agents (recherche vectorielle).

Site public & Branding

Gérer la vitrine publique d'un projet : branding, liens, domaine personnalisé et formulaire de contact public (messenger ticket). Permet exposer la documentation générée ou une page marketing.

Créer et éditer des agents

Guide pas à pas pour définir des agents basés sur des steps JSON : ouvrir le dialogue Agent, définir le nom et les étapes, valider la structure JSON et sauvegarder. Inclut les règles de validation et bonnes pratiques pour écrire des workflows multi-étapes pilotés par LLM.

Suivi de jobs & traitement asynchrone

Suivre l'état des travaux d'indexation, synchronisation et exécution d'agents via workers et sockets. Autoriser l'annulation des jobs en cours et visualiser la progression en temps réel.

Templates et duplication d'agents

Utiliser des templates préconçus (ex. SEO Article Generator) pour démarrer rapidement, et dupliquer des agents existants pour créer des variantes sans repartir de zéro.

Diagnostics & gestion des tokens

Tester et corriger les problèmes d'accès aux repositories (permissions, webhooks) et gérer le renouvellement automatique des tokens GitLab ou l'utilisation du GitHub App token. Indispensable pour maintenir les intégrations actives.

Exécution, hooks et facturation

Comment lancer un agent manuellement ou l'associer à un hook pour exécution automatisée, et comprendre l'impact sur les crédits/consommation (usage OpenAI). Explication des endpoints disponibles et du flux d'exécution.

Exploration des commits & changelogs

Parcourir commits récents, voir les diffs et consulter le journal des générations (changelogs) produits par les agents sur chaque commit. Permet suivre l'historique des contenus générés par l'activité de code.

Modèles LLM et configuration avancée

Sélectionner et configurer le modèle LLM utilisé par chaque agent. Détails sur l'inventaire des modèles (/api/ai-models), comment exclure certains modèles par défaut et bonnes pratiques pour choisir le modèle adapté à chaque workflow.

Export et publication de documents

Exporter les documents générés en Markdown ou JSON, et publier/envoier ces documents vers des destinations externes (webhooks, email). Pratique pour diffuser release notes et contenus marketing.

Introduction aux Hooks d'automatisation

Contexte et concepts clés des AgentHooks : qu'est-ce qu'un hook, comment les fréquences (count + durée) définissent la prochaine exécution côté serveur, le rôle des workers et du scheduler, et l'impact sur la consommation de crédits.

Internationalisation & Préférences UI

Sélectionner la langue de l'interface et préférences d'affichage (thème clair/sombre). Assure une expérience localisée et adaptée aux préférences utilisateur.

Créer, éditer et désactiver un AgentHook

Guide pas-à-pas pour ajouter ou modifier un AgentHook via le DialogAgentHook : sélectionner l'agent, définir la fréquence, appliquer des filtres de base, choisir les destinations et sauvegarder. Inclut bonnes pratiques et implications (activation/désactivation).

Recherche vectorielle & Milvus (RAG)

Effectuer des recherches sémantiques sur le contenu indexé via Milvus pour retrouver les passages de code pertinents. Fournit le contexte nécessaire aux agents et au chat.

Filtres d'entrée et prévisualisation

Comment filtrer les événements entrants (branches, fichiers, auteurs) pour cibler précisément quelles activités déclenchent un AgentHook. Utiliser la fonction 'Preview documents' pour tester la configuration et voir exemples de documents générés avant d'activer le hook.

Uploads de fichiers & traitement de sites

Ajouter des sources non-Git (uploads de fichiers, scraping de sites, URLs) au projet pour être indexées et utilisées par RAG et agents. Permet enrichir le contexte au-delà du code stocké en repo.

Planification, exécution et gestion des jobs

Fonctionnement du scheduler et de la file d'exécution : comment sont planifiées les exécutions, calcul de next_execution_at, exécution via workers, mise en file, et comment annuler des jobs en cours sur un projet.

API publique & utilitaires (Server time, docs)

Fournir endpoints utilitaires accessibles côté client et via API pour diagnostics, documentation et synchronisation (heure serveur). Utile pour UI, debugging et intégrations tierces.

Dispatch d'événements repository côté serveur

Architecture et code serveur pour router les événements repository (push, pull_request) vers les AgentHooks et pipelines. Explication du dispatcher (server/events/repositoryEvents.ts), application des filtres (branches/fichiers/auteurs) et séquence d'exécution initiée par événements Git.

Intégrations externes (GitHub App, OAuth, plugins)

Gérer les intégrations tierces comme GitHub App, GitHub/GitLab OAuth et plugins externes (ex : Crisp). Facilite l'installation, l'authentification et le lien des ressources externes.

Aperçu et navigation des Changelogs

Comment parcourir et filtrer les GenerationLogs (changelogs) par projet, agent, branche ou auteur. Comprend la navigation vers l'onglet Changelogs, les filtres, et l'ouverture d'un log pour consulter les métadonnées (agent_id, agent_hook_id, batch_uuid) et l'historique des générations.

Sécurité & Webhooks (secrets, suppression)

Gérer la sécurité des webhooks (secrets, signatures) ainsi que la suppression sécurisée des webhooks côté provider. Important pour garantir l'intégrité des événements entrants.

Revue, finalisation et édition de documents

Procédure de revue d'un GenerationLog : ouverture du DialogDocument, inspection du contenu généré, visualisation du prompt utilisé, marquage review, finalisation de la revue et mise à jour du statut. Inclut actions d'édition légère, duplication et suppression de documents.

Profil utilisateur & paramètres personnels

Gérer les informations de compte (nom, email, mot de passe) et préférences utilisateur. Permet mettre à jour le profil et ses paramètres liés à l'expérience produit.

Export, envoi et intégrations externes

Exporter des GenerationLogs en Markdown ou JSON, et envoyer des documents vers des destinations configurées (webhook, email, Notion, etc.). Décrit le flux depuis DialogDocument : choisir Export Markdown/JSON, choisir Destination, cliquer 'Send' et lire les notifications de succès/erreur. Explique les implications (appels externes, consommation de crédits si régénération LLM).

Plugins & Analytics intégrés

Intégrations frontales comme Crisp pour support et analytics, initialisées côté client pour enrichir l'expérience et fournir assistance en contexte.

Administration, schéma et migrations

Aspects d'administration des GenerationLogs : schéma de stockage (ajout des colonnes input_prompt et execution_frequency), migration de la base, lien optionnel vers AgentHooks via agent_hook_id (FK nullable), règles de conservation des métadonnées et bonnes pratiques pour suppression/duplication automatisée. Inclut considérations sur sécurité, permissions et impact des appels externes.

Outils développeur & utilitaires front

Fonctions côté client pour faciliter le développement et l'interaction UI : loaders, components partagés (dialogs, theme toggle), utilitaires de couleur. Améliore productivité et cohérence de l'interface.

Gestion des destinations (webhooks)

Créer, configurer et lister les destinations externes (endpoints webhook) pour recevoir automatiquement les outputs générés. Couvrir les champs essentiels : URL, méthode HTTP, en‑têtes, options d'authentification/signature et paramètres de retry. Présentation de l'interface « gestionnaire de destinations » et bonnes pratiques par projet.

Base de données & Migrations

Associer une destination à un AgentHook

Comment lier une destination webhook à un AgentHook afin d'automatiser l'envoi des outputs. Explications pas à pas lors de la création ou de l'édition d'un hook, gestion des sélections, et implications du scope par projet.

Envoi manuel et monitoring des webhooks

Envoyer manuellement un document à une destination et suivre la livraison via les logs. Guide d'utilisation de DialogDocument pour sélectionner une destination et déclencher l'envoi, plus comment interpréter les journaux et statuts d'acheminement.

Retries et stratégie de backoff

Configurer les tentatives de renvoi (retries) et la stratégie de backoff pour gérer les échecs temporaires de livraison. Explications sur les paramètres disponibles (retries, backoff_seconds), comportement de DeployIt et recommandations pour la résilience des intégrations.

Sécurité : authentification et signature des webhooks

Bonnes pratiques et configuration des mécanismes d'authentification et de signature pour les webhooks. Détails sur le secret, les en‑têtes attendus côté destinataire, méthodes supportées et vérifications à effectuer pour garantir l'intégrité et l'authenticité des payloads.

Démarrer une conversation

Guide pas à pas pour lancer des échanges avec le chat contextuel : ouvrir l'onglet 'Chat with code', sélectionner le modèle AI adapté, rédiger votre message et l'envoyer. Inclut conseils sur le choix de modèle et le comportement du chat selon la configuration du projet.

Contexte code et RAG (Retrieval-Augmented Generation)

Explique comment le chat intègre automatiquement le contexte code indexé du projet via RAG pour enrichir les réponses : fonctionnement des recherches dans l'index, portée du contexte utilisé et bonnes pratiques pour obtenir des réponses pertinentes.

Historique, streaming et limites

Documentation sur l'historique de conversation, le streaming des réponses longues et les limites associées (taux, quotas et comportement selon modèle). Comprend comment naviguer dans l'historique et gérer les réponses en streaming.

Configuration & gestion : clés API et emails entrants

Regroupe la configuration nécessaire pour que le chat fonctionne : gestion des API keys, navigation vers l'aide associée, et gestion des emails entrants du projet (affichage et copie de l'adresse inbound pour envoyer des tickets).

Configuration SMTP et règles d'envoi

Paramétrer les envois d'emails : activer les sorties par email au niveau des AgentHook, définir les adresses de destinataires, et comprendre les contraintes liées à la configuration SMTP et aux quotas/consommations de crédits.

Templates d'email d'agents

Comment les templates d'email sont générés pour chaque agent, structure HTML/texte, usage de generateAgentEmailTemplate et gestion du fallback vers un mode simple si nécessaire.

Envois : automatique et manuel

Processus d'envoi automatique lors de l'exécution d'un agent et options d'envoi manuel depuis l'interface (DialogDocument). Inclut l'exécution, le format des emails et la sélection des destinataires.

Emails entrants et support (Crisp)

Afficher et copier les emails entrants liés au projet, et intégrer le support utilisateur via le plugin Crisp pour gérer conversations et assistance directement depuis l'interface.

Présentation & Guide rapide

Introduction aux clés API DeployIt et guide pas‑à‑pas pour commencer : créer une clé, l'utiliser dans des requêtes, et la révoquer. Idéal pour les intégrations CI, scripts et automations externes.

Gestion des clés (interface & cycle de vie)

Tout ce qu'il faut savoir pour créer, lister, afficher une seule fois, révoquer et administrer le cycle de vie des clés API depuis l'interface Déploiement / Paramètres > API Keys.

Authentification & intégration développeur

Détails techniques et exemples pour authentifier les requêtes à DeployIt via en‑têtes X-API-KEY ou Authorization: Bearer. Documentation des utilitaires et du middleware serveur fournis pour valider et traiter les clés API.

Sécurité & bonnes pratiques

Recommandations pour stockage sécurisé, rotation, expiration et révoquation des clés API. Explications sur traçabilité (last_used_at), visibilité limitée de la clé et stratégies pour réduire les risques en production.

Inscription & connexion par email

Guides pratiques pour l'inscription via formulaire (email/password) et la connexion standard. Comprend validation côté client/serveur, attribution de crédits initiaux et flux post-connexion vers le dashboard.

OAuth (GitHub / GitLab) et GitHub App

Documentation des flows OAuth avec GitHub et GitLab, y compris les variantes GitHub App. Couverture de l'inscription via providers, autorisations, callbacks, et génération de jetons JWT pour GitHub App.

Réinitialisation & gestion des mots de passe

Processus complets pour demander une réinitialisation, envoyer les instructions par email et définir un nouveau mot de passe en toute sécurité. Inclut validations, expirations de token et recommandations UX.

Sessions, JWT et protection des accès

Comment gérer les sessions utilisateur, JWT (notamment pour GitHub App), et protéger l'accès aux projets. Détails sur expiration, rotation, stockage sécurisé et vérification côté serveur.

Helpers d'auth & flux hybrides (server + client)

Référence pour les utilitaires serveur (server/utils/auth/authHelpers.ts, hybridAuth.ts) et les composants front pour orchestrer sessions, OAuth et authentification par clé. Inclut exemples d'implémentation et patterns hybrides (iframe signup, callbacks client).

Aperçu : Site public & Branding

Introduction au périmètre : ce que couvre la vitrine publique d'un projet, scénarios d'utilisation (documentation, page marketing), flux globaux et règles importantes (scraping asynchrone, validation de domaine, routage des tickets).

Branding et théming

Configurer l'identité visuelle du site : logo, couleurs, titre, liens de footer, et comment ces réglages sont appliqués globalement via les variables de design et tokens CSS (src/assets/css/tailwind.css) et la configuration Tailwind (tailwind.config.js).

Scraper et import automatique de branding

Utiliser le scraper pour pré-remplir les champs de branding depuis une URL externe : comment lancer l'opération, gérer son caractère asynchrone, interpréter les résultats et intégrer automatiquement les champs au formulaire de configuration.

Domaine personnalisé et validation

Configurer un domaine personnalisé pour la vitrine : procédure d'ajout, exigences DNS, validation automatique et règles d'unicité par projet (champ unique dans Prisma). Résolution des erreurs fréquentes lors de la validation.

Formulaire public & gestion des tickets

Fonctionnement du formulaire de contact public (messenger ticket) exposé sur la vitrine : envoi, validation, routage vers les contacts configurés, et intégration backend (/api/public-site/:slug/messenger-ticket).

Surveillance & progression en temps réel

Vue d'ensemble pour visualiser les jobs d'indexation, de synchronisation et d'exécution d'agents. Expliquer l'UI (liste des jobs, barres de progression, détails par job), comment lancer un traitement et suivre sa progression en temps réel via sockets, et bonnes pratiques pour la reconnexion côté client.

Queues, workers et traitement asynchrone

Détails d'implémentation du pipeline d'exécution : enqueuing (projectSourceQueue), workers, processQueue, gestion de la concurrence et respect des délais. Inclut workflows courants (enfilement d'un repo/site/upload), observabilité des étapes et stratégies de retry/échec.

Annulation et gestion des jobs

Comment annuler des jobs en cours au niveau projet : UI (menu projet → 'Cancel jobs'), flux backend pour vider la queue et marquer/terminer les tâches. Explication du comportement best-effort (certaines opérations côté provider peuvent déjà être ininterrompues) et recommandations pour l'utilisateur.

Rate limiter, scheduler et hooks d'exécution planifiée

Documentation des utilitaires servant à contrôler le débit et la planification : rate limiter pour opérations de storage et exécution asynchrone (exécuter des opérations via execute<T>), scheduler et helpers pour tâches planifiées, et traitement des commits récents. Contient exemples d'utilisation et paramètres configurables.

Diagnostic d'accès et Webhooks

Comment lancer et interpréter un diagnostic d'accès au repository et vérifier l'état des webhooks côté provider, ainsi que les limitations et erreurs courantes.

Gestion et rafraîchissement des tokens GitLab

Vérifier la durée de vie des tokens GitLab, automatiser leur rafraîchissement via gitlabAuth, et procédure de ré-authentification manuelle lorsque nécessaire.

Token d'installation GitHub App (backend)

Récupérer et utiliser le token d'installation GitHub App côté serveur, avec exemples d'implémentation et référence au fichier utilitaire server/utils/github/getInstallationToken.ts.

Aperçu & navigation

Vue d'ensemble du module Commits & Changelogs : organisation des écrans, filtres principaux (branche, agent, développeur), groupements de logs par commit et règles de récupération (single branch vs allBranches). Idéal pour comprendre où trouver l'information et comment naviguer efficacement.

Afficher commits et diffs

Comment parcourir les commits récents, ouvrir l'onglet Commits/Changelogs, filtrer la liste et consulter les diffs fournis par le provider. Détails sur la sélection d'un commit et l'interprétation des changements code/texte.

Changelogs produits par les agents

Exploration des journaux de générations (changelogs) créés par les agents pour chaque commit : affichage du détail, rendu du contenu Markdown, statut d'exécution (success/error) et groupement des entrées. Bonnes pratiques pour relire l'historique de génération de contenu.

Traitement manuel des commits récents

Procédure pour lancer manuellement le traitement des commits récents via le bouton 'Process recent commits'. Explication de la simulation des événements push côté backend, des AgentHooks exécutés, des risques et de l'impact (plusieurs exécutions d'agents), et comment vérifier les résultats dans les logs.

Exporter des documents (Markdown & JSON)

Guide pas à pas pour générer et télécharger des exports Markdown ou JSON côté client : comportement navigateur, nommage de fichier, conseils pour gros documents et limitations. Explique que l'API peut fournir le contenu brut mais que l'assemblage et le téléchargement final se font dans le navigateur.

Envoyer des documents vers des destinations configurées (webhooks, email)

Comment configurer et envoyer des documents vers des destinations externes (webhooks, e‑mail, etc.). Détails sur l'authentification, les en‑têtes, les templates de payload, la logique de retry et le suivi des envois (succès/erreur).

Prévisualiser les documents via l'API

Utiliser l'endpoint de prévisualisation pour tester filtres et templates avant export/envoi. Exemples de requêtes, paramètres de filtre, format des résultats exemplaires et intégration dans les flux CI/CD. Rappel : l'API fournit un aperçu, l'assemblage final reste côté client si export nécessaire.

Bonnes pratiques et dépannage

Conseils pour fiabiliser les exports et les envois : gestion des erreurs, journaux, stratégies de retry, sécurisation des destinations, modèles de payload robustes, tests de prévisualisation, et résolution des problèmes fréquents (timeouts, échecs d'authentification, fichiers trop volumineux).

Introduction à la recherche vectorielle avec Milvus

Vue d'ensemble des concepts, bénéfices et contraintes de l'utilisation de Milvus pour la recherche sémantique (RAG). Expose le rôle des embeddings, du FileIndex, et les implications coûts / réseau.

Indexation et insertion de vecteurs

Procédure et bonnes pratiques pour insérer vecteurs et métadonnées dans des collections Milvus lors du traitement d'un repo. Détaille insertSource, contrôle de cohérence avec le FileIndex, et stratégies de retry / rate limiting.

Recherche vectorielle depuis une requête texte

Guide pour effectuer des recherches sémantiques : construction d'embeddings côté agent/chat, utilisation de queryVectorFromString, récupération des topK matches et injection du contexte pertinent dans les agents.

Maintenance et administration des collections

Opérations d'administration : créer / supprimer collections et index, gestion des index Milvus, commandes backend (createIndex, dropCollection) et impact opérationnel. Inclut recommandations liées au rate limiter et retry.

Suppression et gestion de la cohérence des sources

Procédures pour supprimer des sources ou entrées spécifiques d'une collection Milvus, implications sur le FileIndex et la pertinence du RAG, et précautions pour éviter la perte de contexte.

Concepts et flux de traitement

Vue d'ensemble des sources non-Git, du rôle de la file/worker et des règles opérationnelles (asynchronisme, limites et échecs). Indispensable pour comprendre comment uploads, scraping et repositories sont orchestrés.

Téléversement et indexation de fichiers

Guide pas à pas pour téléverser des fichiers depuis l'UI, bonnes pratiques de préparation et détails sur l'indexation asynchrone.

Ajout de sites et scraping

Comment ajouter une URL pour scraping, options de crawl et intégration des résultats dans l'indexation ou le formulaire de branding, avec gestion des erreurs de scraping.

Interface et supervision des jobs

Utiliser l'UI pour initialiser la pipeline de processing, suivre la progression des jobs d'upload et de scraping, et diagnostiquer les échecs ou goulots d'étranglement.

Installation et tokens GitHub App

Guide pas-à-pas pour installer la GitHub App depuis l'UI, récupérer le token d'installation et comprendre les prérequis (droits administrateur). Contient le flow d'installation côté produit et les vérifications à effectuer après le retour à DeployIt.

Lister et gérer les repos via GitHub App

Comment lister les dépôts accessibles par une installation GitHub App, utiliser Octokit avec le token d'installation et gérer les permissions d'accès aux repos depuis le backend.

Flux OAuth (GitHub & GitLab) avec PKCE

Explication des flows OAuth pour GitHub et GitLab en utilisant PKCE : démarrage, stockage d'état dans cookies, gestion du finalRedirectUrl et échange de code -> token. Exemple d'intégration pour GitLab (useAuthProviders.gitlabSignin et callback).

Intégration et initialisation de plugins externes (Crisp)

Guide d'initialisation côté client pour plugins de support externes (ex. Crisp). Inclut l'initialisation au chargement, l'enrichissement du widget avec les informations utilisateur et bonnes pratiques pour la sécurité et la confidentialité.

Composants UI réutilisables

Présentation et bonnes pratiques pour utiliser et réutiliser les composants front fournis : Dialogs, Loaders et ThemeToggle. Exemples d'usage, patterns pour cloner/copier des composants et conseils d'intégration dans une SPA (SSR désactivé).

Thème et langue (hooks et contrôles)

Guide d'utilisation des contrôles UI et des hooks pour changer le thème et la langue : comment intégrer ThemeToggle, useTheme et useLanguage, et comment persister les préférences côté client (localStorage). Scénarios et exemples de migration de préférences entre sessions.

Helpers client & intégration d'auth

Documentation des hooks utilitaires côté client, notamment useAuthProviders, ainsi que recommandations d'intégration dans l'UI et gestion des flux d'authentification dans une SPA. Exemples d'appel et patterns pour réutiliser ces helpers dans des composants et dialogs.

Génération de couleurs pour avatars et projets

Algorithme et utilitaire pour générer des couleurs déterministes à partir de noms (avatars, projets). Règles de contrastes, variantes claires/sombres et intégration avec les composants UI pour assurer cohérence visuelle et accessibilité.

Alias module loader (alias-loader.mjs)

Détail du module alias-loader.mjs utilisé durant le build/dev : résolution d'alias d'import et ajout automatique du suffixe .ts. Exemples de configuration, cas d'utilisation et conseils pour résoudre les erreurs d'importation durant le développement.