Vue d’ensemble du projet

Fichiers source

Cette page est générée à partir des fichiers source suivants :

• README.md
• apps/sim/package.json
• apps/sim/app/layout.tsx
• apps/sim/app/page.tsx
• apps/sim/tools/dub/types.ts
• apps/sim/tools/reducto/types.ts
• apps/sim/tools/pagerduty/types.ts
• apps/sim/blocks/blocks/schedule.ts
• apps/sim/tools/duckduckgo/types.ts
• apps/sim/app/api/schedules/route.ts

Sim est une plateforme open-source de nouvelle génération conçue pour construire, déployer et orchestrer des agents IA autonomes. Le projet répond à un besoin croissant d'outils permettant de créer des workflows agentiques complexes sans nécessiter une expertise approfondie en apprentissage automatique. La plateforme se distingue par son approche modulaire et sa capacité à intégrer plus de 1 000 connecteurs externes, permettant aux agents d'interagir avec des systèmes tiers de manière transparente.

La mission principale de Sim est de démocratiser la création d'agents IA en offrant une interface visuelle intuitive couplée à une infrastructure technique robuste. Les utilisateurs peuvent concevoir des agents capables d'exécuter des tâches complexes, de répondre à des questions basées sur des documents personnalisés via des bases vectorielles, et d'orchestrer des workflows multi-étapes avec des LLMs multiples. La plateforme supporte à la fois le déploiement cloud via sim.ai et l'auto-hébergement via NPM ou Docker Compose (README.md:33-72).

Les cas d'usage principaux incluent l'automatisation de processus métier, la création d'assistants intelligents avec accès à des connaissances spécifiques, et l'orchestration de tâches planifiées récurrentes. La plateforme cible aussi bien les développeurs individuels que les équipes enterprise cherchant à intégrer des capacités agentiques dans leurs systèmes existants. Les métadonnées officielles décrivent Sim comme « the open-source platform to build AI agents and run your agentic workforce » (apps/sim/app/page.tsx:31-51).

Architecture technique et stack

Stack technologique principal

Le projet repose sur une architecture moderne basée sur Next.js 16.1.6 et React 19.2.4, offrant un support natif pour le rendu côté serveur (SSR) et la génération statique. TypeScript 5.7.3 assure la sécurité des types à travers l'ensemble de la codebase. Le runtime Bun (version >= 1.2.13) est requis comme environnement d'exécution, offrant des performances supérieures à Node.js pour les opérations de bundling et d'exécution (apps/sim/package.json:1-100).

Intégrations LLM et IA

La plateforme supporte une large gamme de fournisseurs LLM, permettant aux développeurs de choisir le modèle le plus adapté à chaque cas d'usage. Les SDK officiels incluent OpenAI 4.91.1, Anthropic 0.71.2, AWS Bedrock Runtime 3.940.0, Google GenAI 1.34.0, Cerebras Cloud SDK 1.23.0, et Groq SDK 0.15.0. Cette architecture multi-fournisseur permet une flexibilité maximale dans le choix des modèles et une résilience face aux pannes (apps/sim/package.json:100-180).

L'intégration avec le Model Context Protocol (MCP) via @modelcontextprotocol/sdk 1.20.2 permet une standardisation des interactions entre agents et outils externes. Le SDK A2A (Agent-to-Agent) version 0.3.7 facilite la communication inter-agents pour les workflows complexes nécessitant une collaboration entre multiples agents spécialisés.

Infrastructure et stockage

L'infrastructure de Sim est conçue pour être agnostique en termes de stockage, supportant PostgreSQL (via postgres 3.4.5), MongoDB 6.19.0, MySQL 2.14.3, DynamoDB (via AWS SDK), et Neo4j 6.0.1 pour les cas d'usage graph. Redis 5.10.0 et ioredis 5.6.0 gèrent le caching et les sessions distribuées. Le stockage objet est assuré par AWS S3 et Azure Blob Storage (apps/sim/package.json:29-90).

正在加载图表渲染器...

Points clés de l'architecture :

• La couche client utilise React 19 avec Zustand pour l'état local et TanStack Query pour le cache serveur (apps/sim/package.json:85-86)
• Next.js 16 orchestre le rendu et expose les API REST, communiquant avec les services via des SDK dédiés
• Socket.io assure la communication temps réel pour les mises à jour de workflow en direct
• Trigger.dev gère l'exécution asynchrone des tâches longues, coordonnée par Croner pour la planification

Structure de lapplication et composants

Organisation modulaire des providers

L'application suit une architecture provider-based où chaque préoccupation transverse est encapsulée dans un composant dédié. Le fichier layout.tsx définit la structure racine avec une imbrication de providers : PostHogProvider pour l'analytics, ThemeProvider pour le theming, QueryProvider pour React Query, SessionProvider pour l'authentification, et TooltipProvider pour l'UX (apps/sim/app/layout.tsx:200-257).

tsx
1// Structure des providers (simplifié)
2<PostHogProvider>
3  <ThemeProvider>
4    <QueryProvider>
5      <SessionProvider>
6        <TooltipProvider>
7          <BrandedLayout>{children}</BrandedLayout>
8        </TooltipProvider>
9      </SessionProvider>
10    </QueryProvider>
11  </ThemeProvider>
12</PostHogProvider>

Cette imbrication assure que chaque couche a accès aux contextes dont elle dépend. PostHogProvider initialise le tracking analytics avant le rendu, ThemeProvider applique les préférences de thème (clair/sombre), QueryProvider configure le client React Query avec les paramètres de cache, et SessionProvider gère l'état d'authentification via better-auth 1.3.12.

Configuration et optimisations navigateur

Le layout racine intègre plusieurs polyfills et scripts d'optimisation pour assurer la compatibilité cross-browser. Un polyfill pour crypto.randomUUID est injecté pour les contextes non-sécurisés (HTTP non-localhost), permettant la génération d'identifiants uniques sans HTTPS (apps/sim/app/layout.tsx:50-100).

javascript
1// Polyfill crypto.randomUUID (layout.tsx:42-58)
2if (typeof crypto !== 'undefined' && typeof crypto.randomUUID !== 'function') {
3  crypto.randomUUID = function() {
4    var a = new Uint8Array(16);
5    crypto.getRandomValues(a);
6    a[6] = (a[6] & 0x0x0f) | 0x40;
7    a[8] = (a[8] & 0x3f) | 0x80;
8    // ... conversion en format UUID
9  };
10}

Les dimensions du workspace sont pré-calculées et injectées via CSS custom properties avant l'hydratation React, évitant les layout shifts. Le script workspace-layout-dimensions lit l'état du sidebar depuis localStorage et applique les variables CSS correspondantes (--sidebar-width, --left-panel-width) de manière synchrone (apps/sim/app/layout.tsx:93-130).

Système de theming et branding

Le module de whitelabeling (@/ee/whitelabeling) génère dynamiquement les métadonnées et les styles CSS thématiques via generateBrandedMetadata(), generateStructuredData() et generateThemeCSS(). Cette approche permet une personnalisation complète de l'interface sans modification du code source, supportant les déploiements white-label pour les entreprises (apps/sim/app/layout.tsx:1-30).

Écosystème dintégrations et outils

Connecteurs externes et SDK

Sim intègre un écosystème riche de connecteurs permettant aux agents d'interagir avec des services externes. Les intégrations incluent Linear SDK 40.0.0 pour la gestion de projets, Stripe 18.5.0 pour les paiements, Twilio 5.9.0 pour les communications, Resend 4.1.2 pour les emails, et des outils d'automatisation comme Puppeteer via @browserbasehq/stagehand 3.0.5 (apps/sim/package.json:29-90).

Les connecteurs de données incluent DuckDuckGo pour la recherche web, PagerDuty pour la gestion d'incidents, Dub pour le raccourcissement d'URLs, et Reducto pour l'extraction de documents. Chaque connecteur expose des types TypeScript fortement typés via des fichiers dédiés dans apps/sim/tools/*/types.ts, assurant la cohérence des contrats d'interface.

Système de blocs modulaires

Le système de blocs (apps/sim/blocks/blocks/) définit des composants réutilisables pour la construction de workflows. Le bloc schedule.ts implémente la logique de planification des tâches, permettant aux agents d'exécuter des actions à des intervalles définis via des expressions cron. Ce système s'appuie sur la bibliothèque Croner 9.0.0 pour le parsing et l'exécution des expressions cron (apps/sim/package.json:99).

正在加载图表渲染器...

Flux de planification détaillé :

1. L'utilisateur soumet une requête de création de schedule via l'API REST (apps/sim/app/api/schedules/route.ts)
2. L'API route valide l'expression cron et la persiste en base de données
3. Croner évalue les expressions cron et déclenche les exécutions aux moments définis
4. L'Agent Worker exécute le workflow associé en appelant les LLMs appropriés
5. Les résultats sont loggés et disponibles pour le monitoring

APIs et orchestration

Les API routes de Next.js servent de points d'entrée pour l'orchestration des workflows. Le fichier apps/sim/app/api/schedules/route.ts expose les endpoints CRUD pour la gestion des tâches planifiées, supportant la création, lecture, mise à jour et suppression de schedules. L'authentification est gérée par better-auth avec support SSO via @better-auth/sso 1.3.12 (apps/sim/package.json:42).

Trigger.dev 4.1.2 fournit une infrastructure de jobs asynchrones robuste, permettant l'exécution de tâches longues sans bloquer le thread principal. Cette architecture est particulièrement adaptée aux workflows agentiques qui peuvent nécessiter plusieurs appels LLM consécutifs ou des traitements de documents volumineux.

Flux de données et interactions système

Pipeline de traitement des requêtes

Le flux de données typique dans Sim suit un pattern request-response avec support temps réel. Lorsqu'un utilisateur interagit avec l'interface React, les actions sont capturées par les handlers d'événements, transformées en appels API via TanStack Query, et transmises aux API routes Next.js. Ces routes orchestrent les appels aux services externes (LLMs, bases de données, stockage) et retournent les résultats via le cache React Query.

正在加载图表渲染器...

Points d'interaction clés :

• L'interface utilise Radix UI pour les composants accessibles (Alert Dialog, Dropdown, Tabs) (apps/sim/package.json:60-78)
• React Hook Form 7.54.2 gère la validation des formulaires avec Zod 3.24.2 pour les schémas
• Drizzle ORM traduit les requêtes TypeScript en SQL optimisé pour PostgreSQL
• Le Vector Store stocke les embeddings générés par les LLMs pour la recherche sémantique

Gestion des erreurs et résilience

L'application implémente une stratégie de gestion d'erreurs multi-niveaux. Le composant HydrationErrorHandler détecte et signale les erreurs d'hydratation React côté client. Les erreurs API sont capturées par TanStack Query et exposées via les hooks useQuery et useMutation. Les jobs asynchrones via Trigger.dev supportent les retries automatiques avec backoff exponentiel (apps/sim/app/layout.tsx:241).

Capacités quantifiées et métriques

Étendue fonctionnelle

Sim offre une couverture fonctionnelle extensive avec plus de 180 dépendances de production listées dans package.json, incluant des SDK pour 6 fournisseurs LLM majeurs, 5 systèmes de base de données, et des dizaines d'intégrations SaaS. La plateforme supporte 3 modes de déploiement : cloud (sim.ai), NPM package, et Docker Compose (apps/sim/package.json:1-220).

Performance et scalabilité

L'architecture basée sur Bun offre des temps de démarrage significativement réduits par rapport à Node.js traditionnel. Le support de Socket.io avec Redis adapter permet une scalabilité horizontale pour les communications temps réel. Drizzle ORM génère des requêtes SQL optimisées, réduisant la charge sur les bases de données. Le système de cache multi-niveaux (React Query côté client, Redis côté serveur) minimise les appels redondants aux services externes.

Guide de lecture du rapport

Ce rapport technique est structuré pour guider le lecteur à travers une compréhension progressive de Sim. Le diagramme suivant illustre les relations entre les chapitres et suggère un ordre de lecture optimisé selon les objectifs du lecteur.

正在加载图表渲染器...

Recommandations de lecture :

• Développeurs backend : Architecture → API Design → Modèle de Données
• Développeurs frontend : Architecture → Fonctionnalités → Déploiement
• DevOps/SRE : Architecture → Déploiement → API Design
• Architectes : Lecture séquentielle complète recommandée

Chaque chapitre contient des références croisées vers les sections pertinentes et des liens vers le code source correspondant sur GitHub. Les diagrammes Mermaid sont interactifs dans la version web du rapport, permettant d'explorer les relations entre composants.