Skip to content

AgentFlow-AI

Agentflow Overview

AgentFlow-AI est un système d’agent intelligent basé sur une architecture micro-services.
Ce projet démontre comment un modèle de langage peut être combiné avec des outils, appelés actions, pour créer un agent capable d’exécuter des tâches concrètes.

Objectif du projet

L’objectif est de transformer une simple requête utilisateur en une série d’actions exécutables.

Le système permet de :

  • comprendre une demande en langage naturel
  • décider des actions nécessaires
  • exécuter ces actions
  • utiliser les résultats pour produire une réponse finale
  • maintenir un contexte avec history et state
  • visualiser le flux d’exécution

Architecture globale

Le système est composé de quatre services principaux :

  • Frontend
  • Backend API
  • LLM API
  • Agent API

Flux global :

Utilisateur → Frontend → Backend → LLM → Agent → Backend → Frontend

Agentflow Overview

Structure complète du projet

AgentFlow-AI/
│
├── backend_api/
│   ├── app/
│   │   ├── main.py
│   │   ├── routes.py
│   │   ├── core/
│   │   │   ├── agent_loop.py
│   │   │   └── history_manager.py
│   │   ├── services/
│   │   │   ├── llm_client.py
│   │   │   ├── agent_client.py
│   │   │   └── validator.py
│   │   └── config.py
│   ├── Dockerfile
│   └── requirements.txt
│
├── agent_api/
│   ├── app/
│   │   ├── main.py
│   │   ├── core/
│   │   │   ├── executor.py
│   │   │   └── action_registry.py
│   │   ├── actions/
│   │   │   ├── action_definitions.py
│   │   │   ├── create_file.py
│   │   │   ├── write_file.py
│   │   │   ├── read_file.py
│   │   │   ├── delete_file.py
│   │   │   ├── list_files.py
│   │   │   ├── list_notebooks.py
│   │   │   ├── read_notebook.py
│   │   │   ├── python_to_notebook.py
│   │   │   ├── get_datetime.py
│   │   │   ├── generate_image.py
│   │   │   ├── search_web.py
│   │   │   └── search_jobs.py
│   │   └── config.py
│   ├── Dockerfile
│   └── requirements.txt
│
├── llm_api/
│   ├── app/
│   │   ├── main.py
│   │   ├── core/
│   │   │   ├── prompt_builder.py
│   │   │   └── azure_client.py
│   │   └── config.py
│   ├── Dockerfile
│   └── requirements.txt
│
├── frontend/
│   ├── index.html
│   ├── style.css
│   ├── script.js
│   └── Dockerfile
│
├── shared/
│   ├── schemas.py
│   └── constants.py
│
├── data/
│   ├── files/
│   ├── notebooks/
│   └── images/
│
├── .env
├── .gitignore
├── docker-compose.yml
└── README.md

Description des services

Frontend

Interface utilisateur permettant :

  • l’envoi de messages
  • l’affichage de l’historique
  • la visualisation de la trace d’exécution

Backend API

Rôle :

  • orchestrer le flux complet
  • appeler le LLM
  • appeler l’agent
  • gérer history et state
  • retourner la réponse finale avec la trace

Fichiers importants :

  • agent_loop.py : logique principale
  • history_manager.py : gestion de l’historique
  • llm_client.py : communication avec le LLM
  • agent_client.py : communication avec l’agent
  • validator.py : validation des réponses

LLM API

Rôle :

  • construire le prompt
  • envoyer la requête à Azure OpenAI
  • retourner une réponse JSON structurée

Important : le LLM ne fait aucune exécution. Il décide uniquement des actions.

Agent API

Rôle :

  • exécuter les actions
  • utiliser un registre d’actions
  • retourner les résultats

Workflow

Agentflow Overview

Liste des actions disponibles

  • create_file
  • write_file
  • read_file
  • delete_file
  • delete_notebook
  • list_files
  • list_notebooks
  • read_notebook
  • python_to_notebook
  • get_datetime
  • search_web
  • search_jobs
  • generate_image

Gestion du contexte

History

Stocke la conversation complète.

State

Stocke des données structurées :

  • fichiers récents
  • notebooks récents
  • actions récentes
  • résultats de recherche

Cela permet de comprendre des références comme :

  • it
  • them
  • les deux fichiers

Trace d’exécution

Chaque étape contient :

  • numéro de step
  • source et destination
  • titre
  • contenu
  • durée d’exécution

Exemple de fonctionnement

Requête :

Create a file hello.py and write print("hello world")

Étapes :

1. Backend → LLM
2. LLM → actions
3. Backend → Agent
4. Agent → résultats
5. Backend → LLM
6. LLM → réponse finale

Variables d’environnement

AZURE_OPENAI_API_KEY=...
AZURE_OPENAI_ENDPOINT=...
AZURE_OPENAI_DEPLOYMENT=...
AZURE_OPENAI_API_VERSION=2024-12-01-preview

LLM_API_URL=http://llm_api:8002/generate
AGENT_API_URL=http://agent_api:8001/execute

Lancement

docker compose down
docker compose up --build

Frontend :

http://localhost:3000

Stockage des données

  • data/files : fichiers
  • data/notebooks : notebooks
  • data/images : images
  • data/temp : fichiers temporaires

Points forts

  • architecture micro-services
  • exécution réelle d’actions
  • interaction LLM + outils
  • gestion des fichiers et notebooks
  • date et heure réelles
  • recherche web et jobs
  • trace complète
  • compréhension du contexte

Limitations

  • mémoire simple
  • pas multi-utilisateur
  • recherche basique
  • validation partielle
  • dossier shared partiellement utilisé

Améliorations futures

  • gestion multi-utilisateur
  • validation stricte avec Pydantic
  • amélioration de la recherche jobs
  • amélioration de l’interface utilisateur
  • ajout de nouvelles actions
  • state avancé

Conclusion

AgentFlow-AI démontre un système d’agent complet.

Contrairement à un chatbot classique, il peut :

  • analyser une requête
  • planifier des actions
  • exécuter des outils
  • exploiter les résultats
  • maintenir le contexte
  • afficher le flux interne

Ce projet constitue une base solide pour un agent IA moderne.

Liens

Auteur

Ahmad Abo-Alola — Student Project (AI Developer Training)