Tutoriel d'installation d'OpenFang

Niveau : Débutant | Durée : 15 minutes | Gain : Maîtriser le déploiement d'OpenFang et la configuration des modèles

Avant-propos

Si vous recherchez un framework d'AI Agent léger et puissant, OpenFang mérite votre attention. Il s'agit d'un système d'exploitation pour Agents (Agent Operating System) open-source écrit en Rust. L'ensemble du système ne pèse qu'environ 32 Mo après compilation, tout en supportant nativement plus de 20 fournisseurs de LLM majeurs, dont Anthropic Claude, Google Gemini, OpenAI GPT, DeepSeek, Groq, etc.

Contrairement aux frameworks traditionnels, OpenFang n'est pas un simple wrapper de Chatbot, mais un véritable système d'Agents autonomes capables de travailler pour vous : il peut s'exécuter selon un calendrier défini, vous aider à construire des graphes de connaissances, surveiller des cibles, générer des prospects, gérer les réseaux sociaux et rapporter automatiquement les résultats sur votre Dashboard.

Aujourd'hui, nous allons l'installer ensemble.

Lecteurs cibles

Développeurs ayant 1 à 5 ans d'expérience
Profils techniques intéressés par les AI Agents
Passionnés de technologie souhaitant déployer rapidement des capacités d'IA locales

Dépendances et environnement

Avant de commencer, assurez-vous que votre machine remplit les conditions suivantes :

Système d'exploitation : Linux, macOS, Windows (WSL2 ou PowerShell)
Rust : 1.75+ (recommandé d'utiliser rustup)
Mémoire : Au moins 4 Go de RAM
Disque : Au moins 500 Mo d'espace libre

Installer Rust (si non installé)

# Linux/macOS
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Windows (via PowerShell)
irm https://sh.rustup.rs | iex

Une fois l'installation terminée, exécutez rustc --version pour confirmer la version.

Structure du projet

openfang/
├── agents/                 # Répertoire des templates d'Agents
│   ├── hello-world/
│   ├── coder/
│   ├── researcher/
│   └── ...
├── crates/                # Crates Rust (14 au total)
│   ├── openfang-cli/      # CLI en ligne de commande
│   ├── openfang-runtime/  # Cœur du runtime
│   ├── openfang-api/      # API REST
│   └── ...
├── docs/                  # Documentation officielle
├── sdk/                   # SDK multi-langages
│   ├── python/
│   └── javascript/
└── config.toml.example    # Exemple de configuration

Installation rapide

Option 1 : Installation officielle en une ligne (recommandé)

Linux/macOS :

curl -fsSL https://openfang.sh/install | sh

Windows PowerShell :

irm https://openfang.sh/install.ps1 | iex

Une fois l'installation terminée, vous verrez le message suivant :

✅ OpenFang installed successfully!
Run 'openfang init' to get started.

Option 2 : Compilation manuelle

Si vous souhaitez construire à partir de la source ou si vous êtes dans un environnement non supporté par le script :

# Cloner le dépôt
git clone https://github.com/RightNow-AI/openfang.git
cd openfang

# Compiler la version release
cargo build --release

# Ou compiler uniquement le CLI
cargo build --release -p openfang-cli

Après compilation, le fichier binaire se trouve dans target/release/openfang (ou target/release/openfang.exe).

Configuration initiale

Créer le fichier de configuration

Exécutez la commande d'initialisation :

openfang init

Cela créera un dossier de configuration dans votre répertoire personnel :

~/.openfang/
└── config.toml    # Fichier de configuration principal

Structure du fichier de configuration

Ouvrez ~/.openfang/config.toml, la configuration de base ressemble à ceci :

# Configuration du service API
host = "127.0.0.1"
port = 4200

# Clé API (optionnel, recommandé en production)
api_key = ""

# Configuration du modèle par défaut
[default_model]
provider = "groq"
model = "llama-3.3-70b-versatile"

# Configuration par défaut des Agents
[agents.defaults]

[!TIP]
Tous les champs du fichier de configuration sont optionnels ; les valeurs par défaut seront utilisées si des champs manquent.

Configurer les clés API

OpenFang supporte la configuration des clés API via des variables d'environnement. Nous recommandons de tester d'abord avec Groq (quota gratuit) ou Defapi (moitié prix) :

# Option 1 : Groq (gratuit, avec limites de débit)
export GROQ_API_KEY="gsk_votre_cle_Groq"

# Option 2 : Defapi (moitié prix, recommandé)
export DEFAPI_API_KEY="votre_cle_Defapi"

[!WARNING]
N'écrivez pas vos clés API directement dans le fichier de configuration ; utilisez des variables d'environnement pour y faire référence.

Démarrage du service

Lancer OpenFang

openfang start

Vous verrez une sortie similaire à :

🚀 Starting OpenFang daemon...
📡 Server listening on http://127.0.0.1:4200
🌐 Dashboard: http://127.0.0.1:4200
✅ OpenFang is ready!

Vérifier le service

# Test de santé (Health check)
curl http://127.0.0.1:4200/api/health

# Voir les modèles disponibles
curl http://127.0.0.1:4200/api/models

# Voir l'état des fournisseurs
curl http://127.0.0.1:4200/api/providers

Accéder au Dashboard

Ouvrez votre navigateur et accédez à http://127.0.0.1:4200 pour voir le Dashboard Web d'OpenFang.

Votre premier Agent

Création via un template intégré

OpenFang propose plusieurs modèles d'Agents intégrés dans le dossier agents/ :

# Lister les templates disponibles
openfang template list

Templates courants :

hello-world : L'agent de discussion le plus simple
coder : Assistant à l'écriture de code
researcher : Assistant de recherche
assistant : Assistant polyvalent

Créer l'Agent

# Création via le template hello-world
openfang agent create hello-world my-first-agent

Test d'envoi de message

# Envoyer un message via le CLI
openfang agent message my-first-agent "Hello, say hi in 3 words"

Ou via l'API REST :

curl -X POST http://127.0.0.1:4200/api/agents/{agent-id}/message \
  -H "Content-Type: application/json" \
  -d '{"message": "Hello, say hi in 3 words"}'

Si vous recevez une réponse normale, votre Agent est opérationnel !

Pratique : Configuration des modèles

Configurer Groq (Tier gratuit)

Groq offre un tier gratuit extrêmement rapide, idéal pour le développement et les tests :

# ~/.openfang/config.toml
[default_model]
provider = "groq"
model = "llama-3.3-70b-versatile"

Variable d'environnement :

export GROQ_API_KEY="gsk_votre_cle"

[!TIP]
Le tier gratuit de Groq a des limites de débit, adapté pour le dev/test. Pour la production, utilisez d'autres fournisseurs.

Configurer Defapi (Recommandé, moitié prix)

Si vous souhaitez utiliser des modèles de haute qualité à moindre coût, Defapi est un excellent choix. Le prix est de seulement 50% du tarif officiel :

Gemini 2.5 Pro : Officiel $1.25/M → Defapi seulement $0.625/M
Claude Sonnet 4 : Officiel $3.00/M → Defapi seulement $1.50/M

# ~/.openfang/config.toml

# Ajouter un fournisseur personnalisé
[[providers]]
name = "defapi"
base_url = "https://api.defapi.org/v1"
api_key_env = "DEFAPI_API_KEY"

# Définir le modèle par défaut
[default_model]
provider = "defapi"
model = "claude-sonnet-4-20250514"

Variable d'environnement :

export DEFAPI_API_KEY="votre_cle_Defapi"

[!TIP]
Defapi supporte plusieurs protocoles : v1/chat/completions, v1/messages, v1beta/models/*, parfaitement compatible avec OpenFang.

Configurer Anthropic Claude

[default_model]
provider = "anthropic"
model = "claude-sonnet-4-20250514"

export ANTHROPIC_API_KEY="sk-ant-votre_cle"

Configurer Google Gemini

[default_model]
provider = "gemini"
model = "gemini-2.5-flash"

# GEMINI_API_KEY ou GOOGLE_API_KEY fonctionne
export GEMINI_API_KEY="AIza_votre_cle"

Configurer OpenAI

[default_model]
provider = "openai"
model = "gpt-4o-mini"

export OPENAI_API_KEY="sk-votre_cle"

Dépannage (FAQ)

Q1 : La clé API ne semble pas fonctionner

Étapes de vérification :

Vérifiez que la variable d'environnement est correctement exportée : echo $GROQ_API_KEY
Redémarrez le service OpenFang : openfang restart
Vérifiez l'état du fournisseur : curl http://127.0.0.1:4200/api/providers

Q2 : Le modèle est affiché comme indisponible

Causes possibles :

Clé API non configurée ou format incorrect
Le modèle n'est pas dans la liste supportée par le fournisseur
Problème de connexion réseau

Solution :

# Voir la liste détaillée des modèles
curl http://127.0.0.1:4200/api/models | jq

# Tester la connexion d'un fournisseur spécifique
curl -X POST http://127.0.0.1:4200/api/providers/groq/test

Q3 : Le port 4200 est déjà utilisé

# Identifier le processus occupant le port
lsof -i :4200   # Linux/macOS
netstat -ano | findstr :4200  # Windows

# Modifier le port dans la configuration
# ~/.openfang/config.toml
port = 4201

Q4 : Erreur de compilation

Assurez-vous que la version de Rust est à jour :

rustup update
rustc --version  # Doit être >= 1.75

Si vous rencontrez des problèmes de dépendances, essayez :

cargo clean
cargo build --release

Q5 : Commande introuvable sur Windows

Assurez-vous que le binaire OpenFang est dans votre PATH :

# Ajouter temporairement au PATH (Permanent via les paramètres système recommandé)
$env:PATH += ";$env:USERPROFILE\.openfang\bin"

# Ou utiliser le chemin complet
~\.openfang\bin\openfang.exe start

Q6 : Comment consulter les logs

# Voir les logs en temps réel
openfang logs

# Ou consulter le fichier log
cat ~/.openfang/logs/openfang.log

Directions avancées

Hands : 7 packs de capacités intégrés

La plus grande force d'OpenFang réside dans ses 7 "Hands" (capacités) intégrés :

Hand	Fonctionnalités
Clip	Téléchargement YouTube, montage, doublage, publication auto sur réseaux sociaux
Lead	Génération de prospects quotidiens, prospection, scoring, déduplication
Collector	Collecte OSINT, détection de changements, construction de graphes de connaissances
Predictor	Moteur de prédiction, intervalles de confiance, suivi de précision
Researcher	Recherche approfondie, validation multi-sources, rapports au format APA
Twitter	Tweets automatiques, réponses interactives, planning de publication
Browser	Automatisation Web, remplissage de formulaires, workflows multi-étapes

# Activer le Hand Researcher
openfang hand activate researcher

# Vérifier le statut
openfang hand status researcher

# Mettre en pause
openfang hand pause researcher

Développement d'Agents personnalisés

Créer un Agent personnalisé :

# my-agent.toml
name = "my-agent"
version = "0.1.0"
description = "Mon agent personnalisé"
author = "votre_nom"

[model]
provider = "groq"
model = "llama-3.3-70b-versatile"

[capabilities]
tools = ["file_read", "web_fetch", "bash"]
memory_read = ["*"]
memory_write = ["self.*"]

# Déployer l'Agent personnalisé
openfang agent deploy my-agent.toml

Intégration MCP

OpenFang supporte le protocole MCP (Model Context Protocol), permettant de se connecter à divers services externes :

[[mcp_servers]]
name = "filesystem"
command = "npx"
args = ["-y", "@modelcontextprotocol/server-filesystem", "/chemin/vers/dossier"]

Conclusion

Aujourd'hui, nous avons terminé l'installation complète d'OpenFang :

✅ Installé OpenFang (via script officiel ou compilation)
✅ Initialisé la configuration (config.toml + variables d'environnement)
✅ Lancé et vérifié le service
✅ Créé et testé le premier Agent
✅ Configuré plusieurs fournisseurs de LLM (Groq, Defapi, Claude, Gemini)
✅ Résolu les problèmes courants

Vous disposez maintenant d'une plateforme complète pour faire tourner des AI Agents ! Prochaines étapes suggérées :

Activez un "Hand" pour expérimenter l'automatisation.
Créez un Agent personnalisé avec vos propres outils.
Explorez l'intégration MCP pour connecter plus de services externes.

Amusez-vous bien !

[!TIP]
Pour un environnement de production, il est conseillé de choisir Defapi (moitié prix) ou de configurer plusieurs fournisseurs pour assurer le failover et la stabilité du service.