Finyuus
Finyuus é uma plataforma "code-first" que usa um DSL baseado em indentação e um tempo de execução baseado em Temporal para construir, executar, versionar e governar fluxos de trabalho de IA duráveis com agentes, ferramentas, "guards", aprovações humanas, observabilidade e publicação de API.
https://github.com/mariusndini/Finyuus?ref=producthunt&utm_source=aipure
Informações do Produto
Atualizado:Aug 6, 2026
O que é Finyuus
Finyuus é uma plataforma para definir e operar o comportamento da IA como um sistema autónomo e versionado, em vez de incorporar "prompts" e lógica de orquestração em todo o código da aplicação. Combina uma linguagem de fluxo de trabalho pequena, legível e baseada em indentação (DSL) com um tempo de execução de produção e um plano de controlo para que as equipas possam compor agentes, ferramentas, verificações de políticas ("guards"), aprovações humanas e fluxos de trabalho aninhados em texto. Finyuus executa fluxos de trabalho de forma duradoura usando Temporal, fornece um painel para autoria e revisão de execuções, e suporta operações de estilo empresarial através de versionamento, auditoria e observabilidade centralizada.
Principais Recursos do Finyuus
Finyuus é uma plataforma "code-first" para definir, executar e governar fluxos de trabalho de IA duráveis usando uma pequena DSL baseada em indentação. Ela separa o comportamento da IA (agentes, prompts, ferramentas, guardas, aprovações, esquemas e pipelines) do código do aplicativo, e então executa fluxos de trabalho no Temporal para estado durável, novas tentativas, cancelamento e capacidade de repetição. A plataforma adiciona versionamento centralizado, auditoria e histórico de execução (incluindo fluxos de trabalho aninhados), observabilidade via rastreamento Langfuse e relatórios de custos, manipulação de dados e artefatos através do ClickHouse e armazenamento de objetos (MinIO/S3), e a capacidade de publicar pipelines como APIs autenticadas com validação, idempotência, limitação de taxa e eventos enviados pelo servidor.
DSL de Pipeline Baseada em Indentação: Uma DSL de texto focada para compor agentes, ferramentas, guardas, aprovações, fluxo de controle (if/else, loops, rotas, paralelo), pipelines filhos e retornos estruturados – otimizada para "diffs" legíveis e revisão de código.
Execução durável no Temporal: Executa fluxos de trabalho com estado durável, novas tentativas, cancelamento, execução de longa duração e capacidade de repetição; suporta orquestração de fluxos de trabalho filhos e semântica consistente para pipelines aninhados.
Blocos de construção de IA versionados: Registro central para agentes, ferramentas, guardas, esquemas e pipelines com histórico de versões e "pins" de versão imutáveis (por exemplo, pipeline@v3) para garantir reprodutibilidade e lançamentos controlados.
Governança: guardas + aprovações humanas: Verificações de política de primeira classe (guardas baseados em LLM com roteamento de aprovação/bloqueio e confiança) mais etapas de aprovação que pausam a execução para revisão humana com atribuídos, tempos limite e ramificações explícitas aprovadas/rejeitadas.
Registro de ferramentas (nativas, HTTP, com suporte de pipeline): Suporta ferramentas nativas TypeScript, ferramentas HTTP configuráveis e ferramentas com suporte de pipeline chamáveis da DSL ou por agentes durante loops de ferramentas, permitindo capacidades operacionais reutilizáveis.
API de Produção + pilha de observabilidade: Publique pipelines como endpoints autenticados com limitação de taxa, idempotência, validação de entrada e streaming SSE; inspecione eventos de execução, histórico de fluxo de trabalho, chamadas de ferramentas e rastreamentos/custos de modelo via Langfuse e o painel.
Casos de Uso do Finyuus
Fluxos de trabalho de conformidade para serviços financeiros: Crie pipelines de conteúdo voltados para o cliente que encaminham solicitações através de guardas de aconselhamento financeiro, geram reformulações educacionais e exigem aprovações de conformidade antes do lançamento – totalmente auditáveis e repetíveis.
Suporte empresarial e automação de TI: Orquestre fluxos de trabalho de agente/ferramenta de várias etapas (triagem de tickets, diagnósticos via ferramentas HTTP, listas de verificação de remediação) com salvaguardas, aprovações de escalonamento humano e novas tentativas duráveis para integrações instáveis.
Pipelines de pesquisa e relatórios: Automatize a pesquisa de mercado/empresa combinando ferramentas de busca de dados (por exemplo, exemplos de SEC EDGAR/Yahoo Finance), agentes de análise com saídas estruturadas, guardas de política de publicação e armazenamento de artefatos.
Geração de conteúdo para saúde ou regulamentado: Gere materiais para pacientes/provedores ou resumos internos com guardas de política e aprovações humanas obrigatórias, mantendo um histórico de execução completo para auditoria e revisão de incidentes.
Operações de dados internas e fluxos de trabalho de análise: Construa pipelines que leem/escrevem tabelas ClickHouse, gerenciam arquivos/artefatos em armazenamento de objetos e produzem retornos estruturados – útil para aumento de IA tipo ETL e enriquecimento de dados repetível.
Endpoints de IA "productizados" para aplicativos: Exponha fluxos de trabalho de IA estáveis como APIs para que vários aplicativos possam chamar o mesmo pipeline versionado, enquanto as equipes de operações gerenciam mudanças de comportamento, monitoramento e governança fora da base de código do aplicativo.
Vantagens
Semântica de execução durável e de nível de produção via Temporal (novas tentativas, cancelamento, capacidade de repetição, fluxos de trabalho de longa duração).
Fortes primitivas de governança (guardas, "pins" de versão, aprovações) mais auditoria centralizada/histórico de execução.
A DSL "code-first" permite revisão baseada em Git, reutilização e "diffs" fáceis de manter em comparação com grandes fluxos de trabalho visuais.
Desvantagens
Complexidade operacional: requer a execução e manutenção de vários serviços (Temporal, Postgres, Redis, ClickHouse, armazenamento de objetos, Langfuse).
Curva de aprendizado: as equipes devem adotar uma nova DSL e modelo de fluxo de trabalho em vez de permanecerem puramente no código do aplicativo.
O melhor valor aparece em escala; pode ser mais pesado do que o necessário para pequenos protótipos ou cadeias de prompt simples.
Como Usar o Finyuus
1) Instalar pré-requisitos: Instale Node.js 22+, pnpm 10+ e Docker Desktop (motor em execução). Prepare pelo menos uma chave de provedor LLM: OPENAI_API_KEY ou ANTHROPIC_API_KEY.
2) Obter o código: Clone o repositório Finyuus localmente (por exemplo, de https://github.com/mariusndini/Finyuus) e "cd" para a raiz do repositório.
3) Instalar dependências: Execute: pnpm install
4) Crie o seu ficheiro de ambiente local: Copie o modelo: cp .env.local.example .env.local
5) Configurar variáveis de ambiente necessárias: Edite .env.local e adicione pelo menos uma chave de provedor (OPENAI_API_KEY ou ANTHROPIC_API_KEY). Se planeia usar a API Pipeline publicada, defina PIPELINE_API_TOKEN. Opcional: defina SEC_USER_AGENT para as ferramentas de demonstração SEC EDGAR. Para armazenamento de objetos: deixe por definir para usar o MinIO local, ou defina OBJECT_STORAGE_PROVIDER=s3 mais as variáveis S3 se quiser AWS S3.
6) Gerar segredos locais e ficheiros de ambiente da aplicação: Execute: make init (isto gera infra/.env e outros ficheiros de ambiente gerados usados por serviços locais como Langfuse).
7) Iniciar infraestrutura local (Temporal, Postgres, ClickHouse, MinIO, Redis, Langfuse): Execute: make up
8) (Opcional) Preencher conteúdo de demonstração: Instalações novas começam vazias. Se quiser ferramentas/esquemas/agentes/pipelines de exemplo para explorar, execute: make demos
9) Construir e iniciar o painel web (recomendado para navegação mais rápida): Execute: pnpm build-web e depois pnpm start-web (o painel é executado em http://localhost:3001).
10) Iniciar o "worker" (motor de execução): Num segundo terminal, execute: pnpm start-worker (este "worker" Temporal executa pipelines).
11) Abrir as UIs locais: Abra o painel Finyuus: http://localhost:3001. UIs de suporte opcionais: Langfuse http://localhost:3000, Temporal UI http://localhost:8080, MinIO Console http://localhost:9001, Redis Insight http://localhost:5540.
12) Criar ou editar um pipeline usando o DSL baseado em indentação: No editor de pipeline do painel, escreva um fluxo de trabalho usando instruções de primeira classe como agent:, tool:, guard:, approval:, pipeline:, http:*, read/save file/table, if/else, for, parallel, route, return. Guarde-o como um pipeline versionado para que possa ser executado e fixado por versão.
13) Executar um pipeline a partir do painel: Na página do pipeline no painel, inicie uma execução com valores de entrada. Observe os eventos de execução, resultados de "guard", chamadas de ferramentas e etapas de fluxo de trabalho aninhadas. Use cancelamento/tentativas conforme suportado pela execução baseada em Temporal.
14) Adicionar governação com "guards" (verificações de política): Insira etapas guard:<key> antes/depois das chamadas de agente. Implemente ramificações de passagem/bloqueio para rotear a execução. Use os campos retornados pelo "guard" (por exemplo, mensagem/confiança) nos seus "payloads" de retorno ou lógica de ramificação.
15) Adicionar aprovações "human-in-the-loop": Insira etapas approval:<key> para pausar a execução até que um revisor a resolva. Configure -assigned-to e -timeout, e defina as ramificações approved:/rejected: (e ações de "timeout" se necessário). Os revisores resolvem as aprovações no painel ou via API.
16) Usar ferramentas (nativas, HTTP ou baseadas em pipeline): Chame ferramentas diretamente no DSL com tool:<name> e argumentos. Configure ferramentas HTTP no painel (cabeçalhos/URLs podem referenciar segredos de ambiente do lado do servidor como {{env.MY_API_KEY}}). Crie ferramentas baseadas em pipeline salvando pipelines e permitindo que os agentes as chamem durante o ciclo da ferramenta.
17) Usar dados e artefatos duráveis (tabelas + ficheiros): Use read:table/save:table para operações de dados estruturados baseadas em ClickHouse, e read:file/save:file para ficheiros/artefatos baseados em armazenamento de objetos (MinIO local por padrão, ou S3 se configurado).
18) Fixar versões para reprodutibilidade: Referencie versões imutáveis como pipeline:company_research@v3 ou agent:research_analyst@v2 para garantir um comportamento estável em todas as execuções e permitir a auditabilidade.
19) Publicar um pipeline como uma API HTTP autenticada: Publique o pipeline como um "endpoint" no painel. Em seguida, chame-o com um "bearer token" e uma chave de idempotência, por exemplo: 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"}}'. Use "endpoints" de "streaming" SSE para atualizações de execução ao vivo, se ativado.
20) Observar e auditar execuções: Use o painel para inspecionar o histórico de execuções, fluxos de trabalho aninhados, decisões de "guard"/aprovação e eventos. Use a UI Temporal para linhas de tempo de fluxo de trabalho e semântica de durabilidade (tentativas/cancelamento/reprodutibilidade). Use Langfuse para rastreios, uso de "tokens" e relatórios de custo de modelo (desative globalmente via LLM_TRACING_ENABLED=false, se desejar).
21) Desenvolver localmente (modo de observação) ao alterar o código: Se estiver a modificar o próprio Finyuus, execute pnpm dev para o modo de observação. Use pnpm typecheck (ou "typechecks" filtrados por pacote) durante o desenvolvimento.
22) Adicionar uma nova ferramenta nativa (estendendo Finyuus): Adicione metadados da ferramenta em packages/tools/src/metadata.ts, adicione uma fábrica em packages/tools/src/registry.ts, implemente a ferramenta em packages/tools/src/, e depois execute "typechecks" para os pacotes afetados.
23) Adicionar uma nova instrução DSL (estendendo a linguagem/tempo de execução): Adicione o tipo AST em packages/pipelines/src/types.ts, adicione suporte ao analisador em packages/pipelines/src/parser.ts, implemente a lógica de execução em apps/worker/src/workflows.ts, adicione atividades em apps/worker/src/activities.ts se houver efeitos secundários, e atualize a inteligência/preenchimento automático do editor em apps/web/src/lib/pipeline-intelligence.ts e apps/web/src/components/pipeline/pipeline-completions.ts.
24) Parar ou reiniciar a infraestrutura local: Para parar os serviços mantendo os dados: make down. Para seguir os registos: make logs. Para verificar a saúde: make verify. Para destruir os dados do serviço local: make reset.
Perguntas Frequentes do Finyuus
Finyuus é uma plataforma "code-first" para construir, executar e governar fluxos de trabalho de IA duráveis. Ela fornece um DSL baseado em indentação para compor agentes, ferramentas, guardas, aprovações humanas, operações de dados estruturados e fluxos de trabalho aninhados, e os executa usando Temporal com um ambiente centralizado para versionamento, observação, auditoria e operação de fluxos de trabalho.
Artigos Populares
Atoms: Uma Plataforma de IA Multiagente Que Transforma Ideias em Produtos Prontos para Lançamento
May 22, 2026
Nano Banana SBTI: O Que É, Como Funciona e Como Usá-lo em 2026
Apr 15, 2026
Análise do Atoms — O Construtor de Produtos de IA Redefinindo a Criação Digital em 2026
Apr 10, 2026
Kilo Claw: Como Implementar e Usar um Verdadeiro Agente de IA "Faça Você Mesmo" (Atualização de 2026)
Apr 3, 2026
Ferramentas de IA Mais Recentes Semelhantes a Finyuus
Gait
O Gait é uma ferramenta de colaboração que integra a geração de código assistida por IA com controle de versão, permitindo que as equipes rastreiem, entendam e compartilhem o contexto do código gerado por IA de forma eficiente.
invoices.dev
invoices.dev é uma plataforma de faturamento automatizada que gera faturas diretamente dos commits do Git dos desenvolvedores, com capacidades de integração para GitHub, Slack, Linear e serviços do Google.
EasyRFP
EasyRFP é um kit de ferramentas de computação de borda alimentado por IA que agiliza as respostas a RFP (Pedido de Proposta) e possibilita fenotipagem de campo em tempo real por meio de tecnologia de aprendizado profundo.
Cart.ai
O Cart.ai é uma plataforma de serviços impulsionada por IA que fornece soluções abrangentes de automação de negócios, incluindo codificação, gerenciamento de relações com clientes, edição de vídeo, configuração de e-commerce e desenvolvimento de IA personalizado com suporte 24/7.
Ferramentas de IA Populares Como Finyuus
GitHub Copilot Chat
O GitHub Copilot Chat é um assistente de codificação alimentado por IA que fornece interações em linguagem natural, sugestões de código em tempo real e suporte contextual diretamente dentro de IDEs suportadas e GitHub.com.
CopilotForXcode
O CopilotForXcode é uma Extensão do Editor de Código do Xcode que integra GitHub Copilot, Codeium e ChatGPT para fornecer sugestões de código impulsionadas por IA, assistência por chat e funcionalidade de prompt-para-código dentro do Xcode.
BrowserAI
BrowserAI é uma biblioteca de código aberto que permite executar Modelos de Linguagem Grandes (LLMs) locais diretamente em navegadores da web com aceleração WebGPU, oferecendo recursos de IA focados na privacidade sem exigir infraestrutura de servidor.
OpenAI Codex CLI
OpenAI Codex CLI é um agente de codificação leve e de código aberto que é executado no seu terminal, permitindo que os desenvolvedores traduzam linguagem natural em execução de código, ao mesmo tempo em que fornece raciocínio em nível de ChatGPT com a capacidade de executar código, manipular arquivos e iterar sob controle de versão.