Finyuus
Finyuus est une plateforme "code-first" qui utilise un DSL basé sur l'indentation et un runtime basé sur Temporal pour construire, exécuter, versionner et gouverner des flux de travail d'IA durables avec des agents, des outils, des gardes, des approbations humaines, de l'observabilité et la publication d'API.
https://github.com/mariusndini/Finyuus?ref=producthunt&utm_source=aipure
Informations sur le produit
Mis à jour:Aug 6, 2026
Qu'est-ce que Finyuus
Finyuus est une plateforme permettant de définir et d'opérer le comportement de l'IA en tant que système autonome et versionné, plutôt que d'intégrer des invites et une logique d'orchestration dans le code de l'application. Elle combine un langage de flux de travail petit, lisible et basé sur l'indentation (DSL) avec un environnement d'exécution de production et un plan de contrôle afin que les équipes puissent composer des agents, des outils, des contrôles de politique (gardes), des approbations humaines et des flux de travail imbriqués sous forme de texte. Finyuus exécute les flux de travail de manière durable à l'aide de Temporal, fournit un tableau de bord pour la création et la révision des exécutions, et prend en charge les opérations de style entreprise via le versionnement, l'audit et l'observabilité centralisée.
Caractéristiques principales de Finyuus
Finyuus est une plateforme "code-first" pour définir, exécuter et gouverner des workflows d'IA durables à l'aide d'un DSL basé sur l'indentation. Elle sépare le comportement de l'IA (agents, "prompts", outils, "guards", approbations, schémas et pipelines) du code de l'application, puis exécute les workflows sur Temporal pour un état durable, des "retries", l'annulation et la rejouabilité. La plateforme ajoute une gestion centralisée des versions, un audit et un historique d'exécution (y compris les workflows imbriqués), l'observabilité via le traçage Langfuse et le rapport de coûts, la gestion des données et des artefacts via ClickHouse et le stockage d'objets (MinIO/S3), et la capacité de publier des pipelines en tant qu'API authentifiées avec validation, idempotence, limitation de débit et événements envoyés par le serveur.
DSL de pipeline basé sur l'indentation: Un DSL textuel ciblé pour composer des agents, des outils, des "guards", des approbations, le flux de contrôle (if/else, boucles, routes, parallèle), des pipelines enfants et des retours structurés – optimisé pour des "diffs" lisibles et la révision de code.
Exécution durable sur Temporal: Exécute les workflows avec un état durable, des "retries", l'annulation, une exécution de longue durée et la rejouabilité ; prend en charge l'orchestration de workflows enfants et une sémantique cohérente pour les pipelines imbriqués.
Blocs de construction d'IA versionnés: Registre central pour les agents, les outils, les "guards", les schémas et les pipelines avec historique des versions et "pins" de version immuables (par exemple, pipeline@v3) pour assurer la reproductibilité et les déploiements contrôlés.
Gouvernance : "guards" + approbations humaines: Des vérifications de politique de première classe (des "guards" basés sur LLM avec routage "pass/block" et confiance) ainsi que des étapes d'approbation qui suspendent l'exécution pour une révision humaine avec des assignés, des délais d'attente et des branches approuvées/rejetées explicites.
Registre d'outils (natif, HTTP, basé sur pipeline): Prend en charge les outils natifs TypeScript, les outils HTTP configurables et les outils basés sur pipeline appelables depuis le DSL ou par des agents pendant les boucles d'outils, permettant des capacités opérationnelles réutilisables.
API de production + pile d'observabilité: Publiez des pipelines en tant que points de terminaison authentifiés avec limitation de débit, idempotence, validation d'entrée et "streaming" SSE ; inspectez les événements d'exécution, l'historique des workflows, les appels d'outils et les traces/coûts des modèles via Langfuse et le tableau de bord.
Cas d'utilisation de Finyuus
Workflows de conformité pour les services financiers: Créez des pipelines de contenu destinés aux clients qui acheminent les demandes via des "guards" de conseils financiers, génèrent des reformulations éducatives et nécessitent des approbations de conformité avant la publication – entièrement auditables et rejouables.
Support d'entreprise et automatisation informatique: Orchestrez des workflows d'agents/outils multi-étapes (tri des tickets, diagnostics via des outils HTTP, listes de contrôle de remédiation) avec des "safe-guards", des approbations d'escalade humaine et des "retries" durables pour les intégrations instables.
Pipelines de recherche et de reporting: Automatisez la recherche de marché/entreprise en combinant des outils de récupération de données (par exemple, des exemples SEC EDGAR/Yahoo Finance), des agents d'analyse avec des sorties structurées, des "guards" de politique de publication et le stockage d'artefacts.
Génération de contenu réglementé ou de soins de santé: Générez des documents pour les patients/prestataires ou des résumés internes avec des "guards" de politique et des approbations humaines obligatoires, en conservant un historique d'exécution complet pour l'audit et l'examen des incidents.
Opérations de données internes et workflows d'analyse: Construisez des pipelines qui lisent/écrivent des tables ClickHouse, gèrent des fichiers/artefacts dans le stockage d'objets et produisent des retours structurés – utiles pour l'augmentation de l'IA de type ETL et l'enrichissement reproductible des données.
Points de terminaison d'IA "productisés" pour les applications: Exposez des workflows d'IA stables en tant qu'API afin que plusieurs applications puissent appeler le même pipeline versionné, tandis que les équipes d'opérations gèrent les changements de comportement, la surveillance et la gouvernance en dehors de la base de code de l'application.
Avantages
Sémantique d'exécution durable et de qualité production via Temporal ("retries", annulation, rejouabilité, workflows de longue durée).
Primitifs de gouvernance solides ("guards", "pins" de version, approbations) ainsi qu'un historique d'audit/exécution centralisé.
Le DSL "code-first" permet une révision basée sur Git, la réutilisation et des "diffs" maintenables par rapport aux grands workflows visuels.
Inconvénients
Complexité opérationnelle : nécessite l'exécution et la maintenance de plusieurs services (Temporal, Postgres, Redis, ClickHouse, stockage d'objets, Langfuse).
Courbe d'apprentissage : les équipes doivent adopter un nouveau DSL et un nouveau modèle de workflow plutôt que de rester purement dans le code de l'application.
La meilleure valeur apparaît à grande échelle ; peut être plus lourd que nécessaire pour de petits prototypes ou de simples chaînes de "prompts".
Comment utiliser Finyuus
1) Installer les prérequis: Installez Node.js 22+, pnpm 10+ et Docker Desktop (moteur en cours d'exécution). Préparez au moins une clé de fournisseur LLM : OPENAI_API_KEY ou ANTHROPIC_API_KEY.
2) Obtenir le code: Clonez le dépôt Finyuus localement (par exemple, depuis https://github.com/mariusndini/Finyuus) et accédez à la racine du dépôt.
3) Installer les dépendances: Exécutez : pnpm install
4) Créez votre fichier d'environnement local: Copiez le modèle : cp .env.local.example .env.local
5) Configurer les variables d'environnement requises: Modifiez .env.local et ajoutez au moins une clé de fournisseur (OPENAI_API_KEY ou ANTHROPIC_API_KEY). Si vous prévoyez d'utiliser l'API Pipeline publiée, définissez PIPELINE_API_TOKEN. Facultatif : définissez SEC_USER_AGENT pour les outils de démonstration SEC EDGAR. Pour le stockage d'objets : laissez vide pour utiliser MinIO local, ou définissez OBJECT_STORAGE_PROVIDER=s3 plus les variables S3 si vous voulez AWS S3.
6) Générer les secrets locaux et les fichiers d'environnement d'application: Exécutez : make init (cela génère infra/.env et d'autres fichiers d'environnement générés utilisés par les services locaux comme Langfuse).
7) Démarrer l'infrastructure locale (Temporal, Postgres, ClickHouse, MinIO, Redis, Langfuse): Exécutez : make up
8) (Facultatif) Amorcer le contenu de démonstration: Les installations fraîches commencent vides. Si vous souhaitez explorer des exemples d'outils/schémas/agents/pipelines, exécutez : make demos
9) Construire et démarrer le tableau de bord web (recommandé pour une navigation plus rapide): Exécutez : pnpm build-web puis pnpm start-web (le tableau de bord s'exécute à http://localhost:3001).
10) Démarrer le worker (moteur d'exécution): Dans un deuxième terminal, exécutez : pnpm start-worker (ce worker Temporal exécute les pipelines).
11) Ouvrir les interfaces utilisateur locales: Ouvrez le tableau de bord Finyuus : http://localhost:3001. Interfaces utilisateur de support facultatives : Langfuse http://localhost:3000, Temporal UI http://localhost:8080, MinIO Console http://localhost:9001, Redis Insight http://localhost:5540.
12) Créer ou modifier un pipeline à l'aide du DSL basé sur l'indentation: Dans l'éditeur de pipeline du tableau de bord, écrivez un flux de travail en utilisant des instructions de première classe comme agent:, tool:, guard:, approval:, pipeline:, http:*, read/save file/table, if/else, for, parallel, route, return. Enregistrez-le en tant que pipeline versionné afin qu'il puisse être exécuté et épinglé par version.
13) Exécuter un pipeline depuis le tableau de bord: Depuis la page du pipeline dans le tableau de bord, démarrez une exécution avec des valeurs d'entrée. Observez les événements d'exécution, les résultats des gardes, les appels d'outils et les étapes de flux de travail imbriquées. Utilisez l'annulation/les nouvelles tentatives comme pris en charge par l'exécution basée sur Temporal.
14) Ajouter de la gouvernance avec des gardes (contrôles de politique): Insérez des étapes guard:<key> avant/après les appels d'agent. Implémentez des branches pass/block pour acheminer l'exécution. Utilisez les champs renvoyés par le garde (par exemple, message/confidence) dans vos charges utiles de retour ou votre logique de branchement.
15) Ajouter des approbations humaines: Insérez des étapes approval:<key> pour suspendre l'exécution jusqu'à ce qu'un réviseur la résolve. Configurez -assigned-to et -timeout, et définissez les branches approved:/rejected: (et les actions de timeout si nécessaire). Les réviseurs résolvent les approbations dans le tableau de bord ou via l'API.
16) Utiliser des outils (natifs, HTTP ou basés sur un pipeline): Appelez des outils directement dans le DSL avec tool:<name> et des arguments. Configurez les outils HTTP dans le tableau de bord (les en-têtes/URL peuvent référencer des secrets d'environnement côté serveur comme {{env.MY_API_KEY}}). Créez des outils basés sur un pipeline en enregistrant des pipelines et en permettant aux agents de les appeler pendant la boucle de l'outil.
17) Utiliser des données et des artefacts durables (tables + fichiers): Utilisez read:table/save:table pour les opérations de données structurées basées sur ClickHouse, et read:file/save:file pour les fichiers/artefacts basés sur le stockage d'objets (MinIO local par défaut, ou S3 si configuré).
18) Épingler les versions pour la reproductibilité: Référencez des versions immuables comme pipeline:company_research@v3 ou agent:research_analyst@v2 pour assurer un comportement stable sur toutes les exécutions et permettre l'auditabilité.
19) Publier un pipeline en tant qu'API HTTP authentifiée: Publiez le pipeline en tant que point de terminaison dans le tableau de bord. Appelez-le ensuite avec un jeton d'authentification et une clé d'idempotence, par exemple : curl -X POST http://localhost:3001/api/v1/responses/<pipeline-slug> -H "Authorization: Bearer $PIPELINE_API_TOKEN" -H "Idempotency-Key: request-001" -H "Content-Type: application/json" -d '{"input": {"query": "example"}}'. Utilisez les points de terminaison de streaming SSE pour les mises à jour d'exécution en direct si activé.
20) Observer et auditer les exécutions: Utilisez le tableau de bord pour inspecter l'historique des exécutions, les flux de travail imbriqués, les décisions de garde/approbation et les événements. Utilisez l'interface utilisateur de Temporal pour les chronologies de flux de travail et la sémantique de durabilité (nouvelles tentatives/annulation/rejouabilité). Utilisez Langfuse pour les traces, l'utilisation des jetons et les rapports de coûts de modèle (désactivez globalement via LLM_TRACING_ENABLED=false si vous le souhaitez).
21) Développer localement (mode veille) lors de la modification du code: Si vous modifiez Finyuus lui-même, exécutez pnpm dev pour le mode veille. Utilisez pnpm typecheck (ou des vérifications de type filtrées par package) pendant le développement.
22) Ajouter un nouvel outil natif (extension de Finyuus): Ajoutez les métadonnées de l'outil dans packages/tools/src/metadata.ts, ajoutez une fabrique dans packages/tools/src/registry.ts, implémentez l'outil dans packages/tools/src/, puis exécutez les vérifications de type pour les packages affectés.
23) Ajouter une nouvelle instruction DSL (extension du langage/runtime): Ajoutez le type AST dans packages/pipelines/src/types.ts, ajoutez le support de l'analyseur dans packages/pipelines/src/parser.ts, implémentez la logique d'exécution dans apps/worker/src/workflows.ts, ajoutez des activités dans apps/worker/src/activities.ts s'il y a des effets secondaires, et mettez à jour l'intelligence de l'éditeur/l'autocomplétion dans apps/web/src/lib/pipeline-intelligence.ts et apps/web/src/components/pipeline/pipeline-completions.ts.
24) Arrêter ou réinitialiser l'infrastructure locale: Pour arrêter les services tout en conservant les données : make down. Pour suivre les journaux : make logs. Pour vérifier la santé : make verify. Pour détruire les données de service locales : make reset.
FAQ de Finyuus
Finyuus est une plateforme "code-first" pour construire, exécuter et gouverner des flux de travail d'IA durables. Elle fournit un DSL basé sur l'indentation pour composer des agents, des outils, des gardes, des approbations humaines, des opérations de données structurées et des flux de travail imbriqués, et les exécute à l'aide de Temporal avec un environnement centralisé pour le versionnement, l'observation, l'audit et l'exploitation des flux de travail.
Articles populaires
Atoms : Une plateforme d'IA multi-agents qui transforme les idées en produits prêts à être lancés
May 22, 2026
Nano Banana SBTI : Qu'est-ce que c'est, comment ça marche et comment l'utiliser en 2026
Apr 15, 2026
Atoms : L'outil de création de produits IA qui redéfinit la création numérique en 2026
Apr 10, 2026
Kilo Claw : Comment déployer et utiliser un véritable agent d'IA "Faites-le pour vous" (Mise à jour 2026)
Apr 3, 2026
Derniers outils d'IA similaires à Finyuus
Gait
Gait est un outil de collaboration qui intègre la génération de code assistée par l'IA avec le contrôle de version, permettant aux équipes de suivre, comprendre et partager efficacement le contexte du code généré par l'IA.
invoices.dev
invoices.dev est une plateforme de facturation automatisée qui génère des factures directement à partir des commits Git des développeurs, avec des capacités d'intégration pour GitHub, Slack, Linear et les services Google.
EasyRFP
EasyRFP est un outil de calcul en périphérie alimenté par l'IA qui rationalise les réponses aux RFP (demande de proposition) et permet le phénotypage des champs en temps réel grâce à la technologie d'apprentissage profond.
Cart.ai
Cart.ai is an AI-powered service platform that provides comprehensive business automation solutions including coding, customer relations management, video editing, e-commerce setup, and custom AI development with 24/7 support.
Outils d'IA populaires comme Finyuus
GitHub Copilot Chat
GitHub Copilot Chat est un assistant de codage alimenté par l'IA qui fournit des interactions en langage naturel, des suggestions de code en temps réel et un soutien contextuel directement dans les IDE pris en charge et sur GitHub.com.
CopilotForXcode
CopilotForXcode est une extension d'Éditeur de Source Xcode qui intègre GitHub Copilot, Codeium et ChatGPT pour fournir des suggestions de code alimentées par l'IA, une assistance par chat et une fonctionnalité de prompt-à-code au sein de Xcode.
BrowserAI
BrowserAI est une bibliothèque open source qui permet d'exécuter des grands modèles de langage (LLM) locaux directement dans les navigateurs Web avec l'accélération WebGPU, offrant des capacités d'IA axées sur la confidentialité sans nécessiter d'infrastructure de serveur.
OpenAI Codex CLI
OpenAI Codex CLI est un agent de codage open source léger qui s'exécute dans votre terminal, permettant aux développeurs de traduire le langage naturel en exécution de code tout en fournissant un raisonnement de niveau ChatGPT avec la possibilité d'exécuter du code, de manipuler des fichiers et d'itérer sous contrôle de version.