Architecture du Cadre MAF: Vue d'Ensemble

Version du document: v1.0 Date de création: 2026-03-12 Principes de conception: Séparation complète des interfaces et des implémentations Objectif: Construire un cadre multi-agent universel, extensible et facile à tester

Description du document

Ce document présente l'architecture du cadre MAF, offrant un aperçu rapide de l'architecture principale, des principes de conception et des choix technologiques.

Documents thématiques détaillés :

• Spécifications de conception d'interfaces - Toutes les définitions d'interface
• Guide d'implémentation - Détails de l'implémentation du code
• Système d'ordonnancement des tâches - Priorités, dépendances, ordonnancement
• Spécifications de conception UI - Architecture front-end
• Guide de déploiement - Déploiement et opérations
• Collection de diagrammes d'architecture - Diagrammes visuels

I. Principes de conception fondamentaux

1.1 Principes SOLID

Le cadre MAF suit strictement les principes SOLID :

Principe	Description	Application dans MAF
Responsabilité unique (SRP)	Chaque classe ne fait qu'une seule chose	IAgentPrincipal ne s'occupe que de l'exécution des tâches IDecomposeurTache ne s'occupe que de la décomposition des tâches
Principe d'ouverture/fermeture (OCP)	Ouvert à l'extension, fermé à la modification	Ajout d'agents sans modification du cadre Nouvelles fonctionnalités via extension d'interface
Substitution de Liskov (LSP)	Les sous-classes peuvent remplacer les classes parentes	BaseAgentMulti peut être remplacé par n'importe quel agent
Séparation des interfaces (ISP)	Interfaces minimales, implémentées selon les besoins	IAgentPrincipalPrincipal étend IAgentBase ICycleDeVieAgent indépendant du cycle de vie
Inversion des dépendances (DIP)	Dépendance des abstractions plutôt que des concret	Couche d'implémentation dépend des interfaces abstraites Hautes couches ne dépendent pas des basses couches

1.2 Architecture en couches

┌─────────────────────────────────────┐
│  Couche applicative     │  Maison intelligente, contrôle d'appareils, service client  │
├─────────────────────────────────────┤
│  Couche d'implémentation   │  Implémentation d'agents, services      │
├─────────────────────────────────────┤
│  Couche abstraite     │  Définitions d'interface, définitions de modèle      │
├─────────────────────────────────────┤
│  Couche infrastructure  │  LLM, base de données, file de messages    │
└─────────────────────────────────────┘

Sens des dépendances : Couche applicative → Couche d'implémentation → Couche abstraite → Couche infrastructure

II. Architecture principale

2.1 Mode Agent Principal + Agent Subordonné

graph TB User[entrée utilisateur] --> MainAgent[AgentPrincipal<br/>Agent principal] MainAgent --> Intent[reconnaissance d'intention] MainAgent --> Decompose[decomposition de tâche] MainAgent --> Match[correspondance d'agent] MainAgent --> Orchestrate[orchestration de tâche] MainAgent --> Aggregate[agrégation de résultats] MainAgent --> Sub1[AgentEclairage] MainAgent --> Sub2[AgentClimat] MainAgent --> Sub3[AgentMusique] Sub1 --> Device1[appareil intelligent] Sub2 --> Device2[appareil intelligent] Sub3 --> Device3[appareil intelligent] style MainAgent fill:#fff4e1 style Sub1 fill:#e1f5ff style Sub2 fill:#e1f5ff style Sub3 fill:#e1f5ff classDiagram class Conversation { +string ConversationId +string UserId +ListTachePrincipale TachesPrincipales +ConversationStatus Statut } class TachePrincipale { +string TacheId +string EntreeUtilisateur +TachePrincipaleStatus Statut +ListTacheSubordonnee TachesSubordonnees } class TacheSubordonnee { +string TacheSubId +string Intention +TacheSubStatus Statut +string AgentId } class SessionAgent { +string SessionId +string AgentId +ListContexteMessage Contexte } Conversation "1" --> "" TachePrincipale TachePrincipale "1" --> "" TacheSubordonnee SessionAgent --> TacheSubordonnee ### 3.2 Machine à états

Machine à états de TachePrincipale

Soumise → EnDecomposition → EnDistribution → EnAgrégation → Terminée/Échouée

Machine à états de TacheSubordonnee

EnAttente → Prête → EnCours → Terminée/Échouée/Timeout
         ↓                        ↓
      Annulée          RequisEntrée → EnAttente

3.3 Priorité des tâches

Système de notation multidimensionnel (0-100 points) :

• Priorité de base : 0-40 points
• Interaction utilisateur : 0-30 points
• Facteur temporel : 0-15 points
• Utilisation des ressources : 0-10 points
• Propagation des dépendances : 0-5 points

Niveaux de priorité :

• Critique (50 points) : Opérations critiques pour la sécurité, actions forcées par l'utilisateur
• Élevée (35-50 points) : Exigences explicites de l'utilisateur
• Normale (20-35 points) : Tâches courantes
• Basse (10-20 points) : Tâches en arrière-plan
• Arrière-plan (0-10 points) : Journaux, statistiques

IV. Démonstrations

4.1 Scénario de maison intelligente

Scénario 1 : Routine matinale

Entrée utilisateur : "Je me lève"
↓
Décomposition de tâche :
  1. Allumer les lumières du salon (Élevée, 45 points)
  2. Régler la climatisation à 26°C (Normale, 25 points)
  3. Jouer de la musique douce (Normale, 20 points, dépendante de la tâche 1)
  4. Ouvrir les rideaux (Basse, 10 points)
↓
Plan d'exécution :
  Groupe 1(parallèle) : Tâche 1
  Groupe 2(parallèle) : Tâche 2, Tâche 3
  Groupe 3(parallèle) : Tâche 4

Scénario 2 : Arrêt d'urgence

Entrée utilisateur : "Arrêt d'urgence"
↓
Tâche critique (Critique, 50 points) :
  - Interruption immédiate de toutes les tâches
  - Ressources exclusives
  - Timeout de 5 secondes

4.2 Comparaison de complexité de scénario

Scénario	Nombre d'agents	Nombre de tâches	Dépendances	Stratégie d'exécution
Contrôle simple	1	1-2	Aucune	Série
Scénario de mode	4-6	4-8	Simple	Mixte
Conversation longue	Plusieurs	10+	Complexe	Mixte

V. Caractéristiques techniques clés

5.1 Ordonnancement intelligent des tâches

• Reconnaissance automatique des dépendances (détection des dépendances implicites)
• Détection des dépendances cycliques (algorithme DFS)
• Tri topologique (algorithme de Kahn)
• Identification des groupes parallèles (par profondeur de dépendance)
• Optimisation des contraintes de ressources (ressources exclusives, limite de tâches)

5.2 Support de conversation multi-tours

• Gestion du contexte de conversation (SessionAgent)
• Résolution de référence ("il", "celui-là")
• Gestion du dérive d'intention
• Gestion de la mémoire (court terme, long terme, sémantique)

5.3 Caractéristiques de production

• Gestion des erreurs : Nouvelle tentative, disjoncteur, dégradation
• Optimisation des performances : Trois niveaux de cache, pool de connexions, opérations par lots
• Surveillance et alertes : Métriques Prometheus, traçage distribué
• Sécurité renforcée : Authentification et autorisation, limitation du débit, chiffrement des données
• Conteneurisation : Support Docker, Kubernetes

VI. Démarrage rapide

6.1 Préparation de l'environnement

# 1. Cloner le dépôt
git clone https://github.com/your-org/maf-framework.git

# 2. Démarrer les services de base
docker-compose up -d redis postgres milvus

# 3. Configurer les variables d'environnement
cp appsettings.Development.json.example appsettings.Development.json

# 4. Exécuter l'application
dotnet run --project src/ApplicationMaf

6.5 Exemple d'utilisation d'interfaces principales

// 1. Créer un AgentPrincipal
var agentPrincipal = serviceProvider.GetRequiredService<IAgentPrincipal>();

// 2. Traiter l'entrée utilisateur
var demande = new DemandeTacheMaf
{
    TacheId = Guid.NewGuid().ToString(),
    EntreeUtilisateur = "Je me lève",
    ConversationId = idConversation
};

var reponse = await agentPrincipal.ExecuterAsync(demande);

// 3. Vérifier le résultat
if (reponse.Succes)
{
    Console.WriteLine($"Succès : {reponse.Resultat}");
}
else
{
    Console.WriteLine($"Échec : {reponse.Erreur}");
}

VII. Navigation dans la documentation

7.1 Parcours de lecture par rôle

Rôle	Parcours de lecture recommandé
Architecte	Ce document → Spécifications de conception d'interfaces → Système d'ordonnancement → Collection de diagrammes
Développeur back-end	Ce document → Spécifications de conception d'interfaces → Guide d'implémentation → Guide de déploiement
Développeur front-end	Ce document → Spécifications de conception UI → Collection de diagrammes
Ingénieur test	Ce document → Guide d'implémentation → Guide de test
Ingénieur DevOps	Ce document → Guide de déploiement → Collection de diagrammes

7.2 Parcours d'apprentissage

Semaine 1 : Comprendre l'architecture principale

• Lire ce document (aperçu d'architecture)
• Consulter la collection de diagrammes

Semaine 2 : Approfondir la conception d'interfaces

• Étudier les spécifications de conception d'interfaces
• Comprendre le système d'ordonnancement des tâches

Semaine 3 : Pratique du codage

• Suivre le guide d'implémentation
• Exécuter les scénarios de démonstration

Semaine 4 : Déploiement en production

• Consulter le guide de déploiement
• Configurer la surveillance et les alertes

VIII. Questions fréquentes

Q1 : Différences entre MAF, LangGraph et AutoGen ?

Caractéristique	MAF	LangGraph	AutoGen
Espace de noms	Préfixe MAF, pas de conflit	Possibilité de conflit	Possibilité de conflit
Langage	C#/.NET	Python	Python/multi-langage
Stratégie d'exécution	Élastique (sélection automatique)	Machine à états de graphe	Conversationnel
Architecture de stockage	Stockage à trois niveaux	Stockage unique	Stockage unique
Conversation multi-tours	Support complet	Limité	Limité
Prêt pour la production	Oui	Partiellement	Partiellement

Q2 : Comment étendre un nouvel agent ?

// 1. Hériter de BaseAgentMulti
public class MonAgentPersonnalise : BaseAgentMulti
{
    public override string AgentId => "mondomaine:personnalise:agent";
    public override string Nom => "Mon agent personnalisé";
    public override IReadOnlyList<string> Competences =>
        new List<string> { "MonDomaine:Personnalise:Action" };

    protected override async Task<ResultatExecution> ExecuterLogiqueMetierAsync(
        DemandeTacheMaf demande,
        CancellationToken ct)
    {
        // Implémenter la logique métier
        return new ResultatExecution { Succes = true };
    }
}

// 2. Enregistrer dans le conteneur DI
services.AddSingleton<IAgentBase, MonAgentPersonnalise>();

Q3 : Comment gérer les conversations longues ?

MAF gère automatiquement le contexte des conversations longues :

• Mémoire à court terme : Cache mémoire L1 (durée de la session)
• Mémoire à long terme : Persistance en base de données L3
• Mémoire sémantique : Recherche dans la base de données vectorielle L2

IX. Annexes

9.1 Glossaire

Terme	Définition
MAF	Multi-Agent Framework (Cadre multi-agent)
AgentPrincipal	Agent principal, responsable de la reconnaissance d'intention, de la décomposition des tâches et de l'orchestration des agents
AgentSubordonné	Agent subordonné, responsable d'exécution de tâches spécifiques à un domaine
Conversation	Contexte complet de conversation entre l'utilisateur et le système
TachePrincipale	Processus complet de traitement d'une demande utilisateur unique
TacheSubordonnee	Unité d'exécution indépendante confiée à un AgentSubordonné
SessionAgent	Contexte LLM de l'AgentSubordonné, maintenu pendant la session

9.2 Références

• Index complet des documents de conception
• Spécifications de conception d'interfaces
• Guide d'implémentation
• Collection de diagrammes d'architecture

Version du document: v1.0 Dernière mise à jour: 2026-03-12 Équipe de maintenance: Équipe d'architecture MAF