Constructeur d'Agents Warden

Que fait Constructeur d'Agents Warden ?

Créez et déployez des agents LangGraph pour l'écosystème Agentic Wallet du protocole Warden.

⚠️ IMPORTANT : À propos des Agents d'Exemple

Le dépôt communautaire Warden contient des agents d'exemple pour l'apprentissage, pas des modèles à recréer :

• Agent Météo - Étudiez-le pour apprendre les modèles simples de récupération de données
• Agent CoinGecko - Étudiez-le pour apprendre le Raisonnement Guidé par Schéma (SGR)
• Agent Portfolio - Étudiez-le pour apprendre l'intégration multi-source complexe

NE CONSTRUISEZ PAS CES AGENTS - ils existent déjà. À la place :

1. Étudiez leur code pour comprendre les modèles
2. Apprenez de leur architecture et de leurs flux de travail
3. Construisez quelque chose de NOUVEAU et d'original pour le programme incitatif

Votre agent doit être unique et résoudre un problème différent pour être éligible au programme incitatif.

Aperçu

Le protocole Warden est un "Portefeuille Agentique pour l'économie du Fais-le-pour-moi" avec un programme incitatif actif de construction d'agents, ouvert aux agents OpenClaw déployés sur Warden. Tous les agents doivent être basés sur LangGraph et accessibles via API.

Ressources clés :

• Dépôt des agents communautaires : https://github.com/warden-protocol/community-agents
• Documentation : https://docs.wardenprotocol.org
• Discord : canal #developers pour le support

Liste de Vérification des Prérequis

Avant de construire, assurez-vous que votre agent répond à ces exigences obligatoires :

✓ Framework : Construit avec LangGraph (TypeScript ou Python) ✓ Déploiement : LangSmith Deployments OU infrastructure personnalisée ✓ Accès : Accessible via API (pas d'interface utilisateur requise - Warden fournit l'interface) ✓ Isolation : Un agent par instance LangGraph ✓ Limitations de sécurité (Phase 1) :

• Ne peut pas accéder aux portefeuilles des utilisateurs
• Ne peut pas stocker de données sur l'infrastructure Warden

✓ Fonctionnalité : Peut implémenter n'importe quel flux de travail :

• Automatisation Web3/Web2
• Intégrations API
• Connexions à des bases de données
• Interactions avec des outils externes

Comprendre les Agents d'Exemple

Le dépôt community-agents contient des exemples de référence pour apprendre, PAS des modèles à recréer :

Exemple d'Agent 1 : Démarrage Rapide LangGraph (Étudier pour les Bases)

Emplacement : agents/langgraph-quick-start (TypeScript) ou agents/langgraph-quick-start-py (Python) Apprendre : Fondamentaux de LangGraph, structure minimale d'agent Étudier : Chatbot à nœud unique avec intégration OpenAI

git clone https://github.com/warden-protocol/community-agents.git
cd community-agents/agents/langgraph-quick-start

Exemple d'Agent 2 : Agent Météo (Étudier pour la Structure)

Emplacement : agents/weather-agent Apprendre : Récupération simple de données, intégration API, réponses conviviales Étudier :

• Comment récupérer des données depuis des API externes (WeatherAPI)
• Traitement et formatage des résultats
• Portée et structure claires ⚠️ NE CONSTRUISEZ PAS : Cela existe déjà. Étudiez-le, puis construisez quelque chose de NOUVEAU.

Exemple d'Agent 3 : Agent CoinGecko (Étudier pour le Modèle SGR)

Emplacement : agents/coingecko-agent Apprendre : Raisonnement Guidé par Schéma (SGR), flux de travail complexes Étudier :

• Flux de travail SGR en 5 étapes : Valider → Extraire → Récupérer → Valider → Analyser
• Modèles d'analyse comparative
• Gestion des erreurs et validation des données ⚠️ NE CONSTRUISEZ PAS : Cela existe déjà. Étudiez le modèle, appliquez-le à de nouveaux cas d'utilisation.

Exemple d'Agent 4 : Agent d'Analyse de Portfolio (Étudier pour les Modèles Avancés)

Emplacement : agents/portfolio-agent Apprendre : Synthèse de données multi-source, architecture de production Étudier :

• Intégration de plusieurs API (CoinGecko + Alchemy)
• Support multi-chaîne (EVM et Solana)
• Flux de travail SGR complexes
• Rapports complets ⚠️ NE CONSTRUISEZ PAS : Cela existe déjà. Étudiez l'architecture pour votre propre agent complexe.

IMPORTANT : Construisez Quelque Chose de NOUVEAU

Ces exemples existent pour enseigner des modèles et des bonnes pratiques. Pour le programme incitatif, vous DEVEZ créer un agent original et unique qui résout un problème différent. Ne recréez pas simplement l'Agent Météo, l'Agent CoinGecko ou l'Agent Portfolio.

Construire Votre Agent Original

Étape 1 : Étudier les Exemples et Choisir Votre Approche

NE clonez PAS un exemple pour le modifier. À la place :

1. Étudiez les exemples pour comprendre les modèles :

   • Récupération simple de données → Étudiez l'Agent Météo
   • Analyse complexe → Étudiez l'Agent CoinGecko
   • Synthèse multi-source → Étudiez l'Agent Portfolio

2. Identifiez VOTRE cas d'utilisation unique :

   • Quel problème votre agent résoudra-t-il ?
   • Quelles API ou sources de données utilisera-t-il ?
   • Qu'est-ce qui le rend différent des agents existants ?

3. Planifiez le flux de travail de votre agent :

   • Simple requête-réponse ?
   • Raisonnement Guidé par Schéma (SGR) ?
   • Analyse en plusieurs étapes ?

Étape 2 : Initialiser Votre NOUVEL Agent

Utilisez le script d'initialisation pour créer un projet frais :

# Créez votre agent unique
python scripts/init-agent.py mon-agent-unique \
  --template typescript \
  --description "Description de ce que fait VOTRE agent"

# Accédez au projet
cd mon-agent-unique

# Installez les dépendances
npm install  # TypeScript
# OU
pip install -r requirements.txt  # Python

Cela crée un point de départ propre, pas une copie des agents existants.

Étape 3 : Comprendre la Structure d'un Agent LangGraph

Chaque agent LangGraph suit cette structure de base :

votre-agent/
├── src/
│   ├── agent.ts/py          # Logique principale de l'agent (VOTRE CODE)
│   ├── graph.ts/py          # Définition du flux de travail LangGraph (VOTRE CODE)
│   └── tools.ts/py          # Implémentations des outils (VOTRE CODE)
├── package.json / requirements.txt
├── langgraph.json           # Configuration LangGraph
└── README.md

Fichiers clés à implémenter :

• graph.ts/py - Définissez votre flux de travail (valider → traiter → répondre)
• agent.ts/py - Implémentez votre logique principale
• tools.ts/py - Intégrez les API externes spécifiques à l'objectif de VOTRE agent

Étape 4 : Implémenter la Logique de Votre Agent Personnalisé

Étudiez les modèles des exemples, appliquez-les à VOTRE cas d'utilisation :

Si vous construisez un récupérateur de données simple (comme le modèle de l'Agent Météo) :

// Définir le flux de travail
const workflow = new StateGraph({
  channels: agentState
})
  .addNode("fetch", fetchYourData)      // VOTRE API
  .addNode("process", processYourData)  // VOTRE logique
  .addNode("respond", generateResponse);

workflow
  .addEdge(START, "fetch")
  .addEdge("fetch", "process")
  .addEdge("process", "respond")
  .addEdge("respond", END);

Si vous construisez une analyse complexe (comme le modèle de l'Agent CoinGecko - SGR) :

// Définir un flux de travail SGR en 5 étapes
const workflow = new StateGraph({
  channels: agentState
})
  .addNode("validate", validateYourInput)     // VOTRE validation
  .addNode("extract", extractYourParams)      // VOTRE extraction
  .addNode("fetch", fetchYourData)            // VOS API
  .addNode("analyze", analyzeYourData)        // VOTRE analyse
  .addNode("generate", generateYourResponse); // VOTRE formatage

workflow
  .addEdge(START, "validate")
  .addEdge("validate", "extract")
  .addEdge("extract", "fetch")
  .addEdge("fetch", "analyze")
  .addEdge("analyze", "generate")
  .addEdge("generate", END);

Principes clés :

1. Gardez les flux de travail linéaires et prévisibles
2. Validez les entrées à chaque étape
3. Gérez les erreurs avec élégance
4. Utilisez OpenAI pour la génération de langage naturel
5. Structurez les réponses de manière cohérente

CRITIQUE : Cela doit être VOTRE implémentation résolvant VOTRE problème, pas une copie des agents d'exemple.

Étape 5 : Configurer l'Environnement

Créez le fichier .env :

# Requis
OPENAI_API_KEY=your_openai_key

# Requis pour LangSmith Deployments (cloud)
LANGSMITH_API_KEY=your_langsmith_key

# Optionnel - basé sur vos outils
WEATHER_API_KEY=your_weather_key
COINGECKO_API_KEY=your_coingecko_key
ALCHEMY_API_KEY=your_alchemy_key

Obtenir une clé API LangSmith :

1. Créez un compte sur https://smith.langchain.com
2. Allez dans Paramètres → Clés API
3. Créez une nouvelle clé API
4. Ajoutez-la au fichier .env

Mettez à jour langgraph.json :

{
  "agent_id": "[NOM-DE-VOTRE-AGENT]",
  "python_version": "3.11",  // ou omettez pour TypeScript
  "dependencies": ["."],
  "graphs": {
    "agent": "./src/graph.ts"  // ou .py
  },
  "env": ".env"
}

Étape 6 : Tester Localement

# TypeScript
npm run dev

# Python
langgraph dev

Testez l'API de votre agent :

curl -X POST http://localhost:8000/invoke \
  -H "Content-Type: application/json" \
  -d '{"input": "test query"}'

Options de Déploiement

Option 1 : LangSmith Deployments (Recommandé)

Avantages : Le plus rapide, le plus simple, infrastructure gérée Prérequis : Clé API LangSmith

Étapes :

1. Poussez votre dépôt d'agent sur GitHub.
2. Créez un nouveau déploiement dans LangSmith Deployments.
3. Connectez le dépôt, définissez les variables d'environnement et déployez.

Votre agent reçoit :

• URL du point de terminaison API
• Authentification automatique (utilise votre clé API LangSmith)
• Mise à l'échelle et surveillance automatiques

Authentification pour les appels API : Lorsque vous appelez votre agent déployé, incluez votre clé API LangSmith :

curl AGENT_URL/runs/wait \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: [VOTRE-CLÉ-API-LANGSMITH]' \
  --data '{
    "assistant_id": "[ID-DE-VOTRE-AGENT]",
    "input": {
      "messages": [{"role": "user", "content": "test query"}]
    }
  }'

Option 2 : Infrastructure Auto-Hébergée

Avantages : Contrôle total de l'environnement d'exécution Prérequis :

• Hébergement de conteneur Docker
• Point de terminaison API exposé
• Certificat SSL (HTTPS)
• Surveillance et journalisation

Configuration Docker de Base :

FROM node:18
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
EXPOSE 8000
CMD ["npm", "start"]

Déployez et notez :

• URL API : https://votre-domaine.com/agent
• Clé API : Générée pour l'authentification

Enregistrer dans Warden Studio

Une fois votre agent déployé et accessible via HTTPS, enregistrez-le dans Warden Studio :

1. Fournissez les détails de l'API :

   • URL de l'API
   • Clé API

2. Ajoutez des métadonnées :

   • Nom de l'agent
   • Description
   • Liste des compétences/capacités
   • Image d'avatar

3. Publiez : L'agent apparaît dans l'Agent Hub de Warden pour des millions d'utilisateurs

Aucune configuration supplémentaire requise - votre agent accessible via API est prêt !

Prochaine étape (compétence séparée) : Si l'utilisateur demande à publier dans Warden Studio ou a besoin d'étapes guidées dans l'interface utilisateur, passez à la compétence OpenClaw "Déployer un Agent sur Warden Studio" : https://www.clawhub.ai/Kryptopaid/warden-studio-deploy

Bonnes Pratiques

1. Conception de l'Agent

• Étudiez la structure de l'Agent Météo pour apprendre les modèles
• Utilisez le Raisonnement Guidé par Schéma pour les flux de travail complexes
• Gardez les réponses concises et exploitables
• Gérez les échecs d'API avec élégance
• Validez toutes les entrées

2. Intégration API

• Utilisez des variables d'environnement pour les clés API
• Implémentez la limitation de débit
• Mettez en cache les réponses lorsque c'est approprié
• Enregistrez les erreurs pour le débogage
• Renvoyez des réponses JSON structurées

3. Tests

• Testez localement avant de déployer
• Vérifiez que tous les points de terminaison API fonctionnent
• Testez les cas limites et les erreurs
• Assurez-vous que les réponses sont conviviales
• Validez par rapport aux exigences de Warden

4. Documentation

• Rédigez un README clair avec :
  • Objectif et capacités de l'agent
  • Clés API requises
  • Instructions de configuration
  • Exemples de requêtes
  • Limitations connues

Modèles Courants

Modèle 1 : Récupérateur de Données Simple

// Récupérer → Formater → Répondre
async function agent(input: string) {
  const data = await fetchAPI(input);
  const formatted = formatData(data);
  return generateResponse(formatted);
}

Modèle 2 : Analyse Multi-Étapes

// Valider → Extraire → Récupérer → Analyser → Générer
async function agent(input: string) {
  const validated = await validateInput(input);
  const params = await extractParams(validated);
  const data = await fetchData(params);
  const analysis = await analyzeData(data);
  return generateReport(analysis);
}

Modèle 3 : Analyse Comparative

// Analyser → Récupérer Plusieurs → Comparer → Résumer
async function agent(input: string) {
  const items = await parseItems(input);
  const dataArray = await Promise.all(
    items.map(item => fetchData(item))
  );
  const comparison = compareData(dataArray);
  return generateComparison(comparison);
}

Dépannage

Problèmes Courants

"Agent non accessible via API"

• Vérifiez que le déploiement s'est terminé avec succès
• Vérifiez les paramètres du pare-feu/groupe de sécurité
• Assurez-vous que le point de terminaison API est accessible publiquement
• Testez avec curl ou Postman

"Erreurs LangGraph lors de la construction"

• Vérifiez la version de Node.js (18+) ou Python (3.11+)
• Vérifiez que toutes les dépendances sont installées
• Validez la syntaxe de langgraph.json
• Consultez les journaux d'erreurs dans la console de déploiement

"Erreurs d'API OpenAI"

• Vérifiez que la clé API est valide
• Vérifiez que les limites de débit ne sont pas dépassées
• Assurez-vous d'avoir des crédits suffisants
• Consultez les messages d'erreur pour plus de détails

"Les réponses de l'agent sont lentes"

• Optimisez les appels API (parallélisez si possible)
• Implémentez la mise en cache pour les requêtes répétées
• Réduisez l'utilisation des jetons LLM
• Envisagez de mettre à niveau l'infrastructure

Conseils pour le Programme Incitatif

Le programme incitatif est ouvert aux agents OpenClaw déployés sur Warden.

1. Soyez Original : Créez quelque chose de NOUVEAU qui n'existe pas encore

   • Ne recréez pas l'Agent Météo, l'Agent CoinGecko ou l'Agent Portfolio
   • Étudiez leurs modèles, appliquez-les à des problèmes différents

2. Résolvez de Vrais Problèmes : Concentrez-vous sur une fonctionnalité utile et unique

   • Quelle lacune existe dans l'écosystème Warden ?
   • Qu'est-ce que les utilisateurs voudraient réellement ?

3. Commencez Simplement : Il vaut mieux faire une chose exceptionnellement bien

   • N'essayez pas de tout construire à la fois
   • Les agents simples et ciblés gagnent souvent

4. Qualité Plutôt que Fonctionnalités : La fiabilité bat la complexité

   • Testez minutieusement
   • Gérez les erreurs avec élégance
   • Fournissez des réponses claires et utiles

5. Étudiez les Exemples : Apprenez les modèles, ne copiez pas les implémentations

   • Agent Météo → Modèle de récupération simple de données
   • Agent CoinGecko → Modèle de flux de travail SGR
   • Agent Portfolio → Modèle d'intégration multi-source

6. Documentez Bien : README clair avec exemples et instructions de configuration

7. Rejoignez Discord : Obtenez des commentaires dans le canal #developers avant de soumettre

Idées d'Agents d'Exemple (Construisez Ceux-ci !)

Ce sont des idées d'agents NOUVEAUX qui n'existent pas encore dans l'écosystème Warden. Construisez l'un de ceux-ci (ou créez votre propre idée unique) :

Cas d'Utilisation Web3 :

• Optimiseur de prix du gaz (prédire et recommander les moments optimaux pour les transactions)
• Surveillant de portefeuille de jetons (alerter sur les mouvements importants ou les nouvelles inscriptions)
• Agrégateur de ponts cross-chain (trouver les meilleurs itinéraires de pontage)
• Analyseur de protocole DeFi (évaluer les risques et les rendements)
• Tracker de NFT (surveiller les prix, les offres et les tendances)

Cas d'Utilisation Web2/Web3 Généraux :

• Assistant de recherche de chaîne d'approvisionnement (suivre les expéditions)
• Vérificateur de fiabilité des sources d'actualités (croiser plusieurs sources)
• Résumeur de documents techniques (extraire des informations clés)
• Agrégateur de recommandations de contenu (empiler et résumer les recommandations)

Prochaines Étapes

1. Choisissez votre cas d'utilisation unique
2. Étudiez les exemples pertinents
3. Initialisez votre agent avec init-agent.py
4. Implémentez votre logique personnalisée
5. Testez localement avec npm run dev ou langgraph dev
6. Déployez sur LangSmith ou auto-hébergement
7. Enregistrez dans Warden Studio et publiez
8. Participez au programme incitatif !

Rappelez-vous : L'écosystème Warden a besoin de votre créativité et de vos idées originales. Étudiez les exemples pour apprendre, mais construisez quelque chose de vraiment nouveau et utile.

Bonne construction ! 🚀