Constructor de Agentes para Warden

¿Qué hace Constructor de Agentes para Warden?

Construye y despliega agentes LangGraph para el ecosistema Agentic Wallet del Protocolo Warden.

⚠️ IMPORTANTE: Acerca de los Agentes de Ejemplo

El repositorio comunitario de Warden contiene agentes de ejemplo para aprendizaje, no plantillas para recrear:

• Weather Agent - Estúdialo para aprender patrones simples de obtención de datos
• CoinGecko Agent - Estúdialo para aprender Razonamiento Guiado por Esquemas (SGR)
• Portfolio Agent - Estúdialo para aprender integración compleja de múltiples fuentes

NO CONSTRUYAS ESTOS AGENTES - ya existen. En su lugar:

1. Estudia su código para comprender patrones
2. Aprende de su arquitectura y flujos de trabajo
3. Construye algo NUEVO y original para el programa de incentivos

Tu agente debe ser único y resolver un problema diferente para ser elegible para el programa de incentivos.

Resumen

El Protocolo Warden es una "Agentic Wallet para la economía 'Hazlo-por-mí'" con un programa activo de Incentivos para Constructores de Agentes, abierto a agentes OpenClaw que se desplieguen en Warden. Todos los agentes deben estar basados en LangGraph y ser accesibles vía API.

Recursos Clave:

• Repositorio de Agentes Comunitarios: https://github.com/warden-protocol/community-agents
• Documentación: https://docs.wardenprotocol.org
• Discord: canal #developers para soporte

Lista de Requisitos

Antes de construir, asegúrate de que tu agente cumpla con estos requisitos obligatorios:

✓ Framework: Construido con LangGraph (TypeScript o Python) ✓ Despliegue: LangSmith Deployments O infraestructura personalizada ✓ Acceso: Accesible vía API (no se requiere UI - Warden proporciona la UI) ✓ Aislamiento: Un agente por instancia de LangGraph ✓ Limitaciones de Seguridad (Fase 1):

• No puede acceder a billeteras de usuarios
• No puede almacenar datos en la infraestructura de Warden

✓ Funcionalidad: Puede implementar cualquier flujo de trabajo:

• Automatización Web3/Web2
• Integraciones de API
• Conexiones a bases de datos
• Interacciones con herramientas externas

Comprendiendo los Agentes de Ejemplo

El repositorio de agentes comunitarios contiene ejemplos de referencia para aprender, NO plantillas para recrear:

Agente de Ejemplo 1: Inicio Rápido de LangGraph (Estudiar para Conceptos Básicos)

Ubicación: agents/langgraph-quick-start (TypeScript) o agents/langgraph-quick-start-py (Python) Aprende: Fundamentos de LangGraph, estructura mínima de agente Estudia: Chatbot de un solo nodo con integración de OpenAI

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

Agente de Ejemplo 2: Weather Agent (Estudiar para Estructura)

Ubicación: agents/weather-agent Aprende: Obtención simple de datos, integración de API, respuestas amigables al usuario Estudia:

• Cómo obtener datos de APIs externas (WeatherAPI)
• Procesamiento y formateo de resultados
• Alcance y estructura claros ⚠️ NO CONSTRUYAS: Esto ya existe. Estúdialo, luego construye algo NUEVO.

Agente de Ejemplo 3: CoinGecko Agent (Estudiar para Patrón SGR)

Ubicación: agents/coingecko-agent Aprende: Razonamiento Guiado por Esquemas, flujos de trabajo complejos Estudia:

• Flujo de trabajo SGR de 5 pasos: Validar → Extraer → Obtener → Validar → Analizar
• Patrones de análisis comparativo
• Manejo de errores y validación de datos ⚠️ NO CONSTRUYAS: Esto ya existe. Estudia el patrón, aplícalo a nuevos casos de uso.

Agente de Ejemplo 4: Portfolio Analysis Agent (Estudiar para Patrones Avanzados)

Ubicación: agents/portfolio-agent Aprende: Síntesis de datos de múltiples fuentes, arquitectura de producción Estudia:

• Integración de múltiples APIs (CoinGecko + Alchemy)
• Soporte multi-cadena (EVM y Solana)
• Flujos de trabajo SGR complejos
• Generación de informes completos ⚠️ NO CONSTRUYAS: Esto ya existe. Estudia la arquitectura para tu propio agente complejo.

IMPORTANTE: Construye Algo NUEVO

Estos ejemplos existen para enseñar patrones y mejores prácticas. Para el programa de incentivos, DEBES crear un agente original y único que resuelva un problema diferente. No te limites a recrear el Weather Agent, CoinGecko Agent o Portfolio Agent.

Construyendo Tu Agente Original

Paso 1: Estudia Ejemplos y Elige Tu Enfoque

NO clones un ejemplo para modificarlo. En su lugar:

1. Estudia los ejemplos para comprender los patrones:

   • Obtención simple de datos → Estudia Weather Agent
   • Análisis complejo → Estudia CoinGecko Agent
   • Síntesis de múltiples fuentes → Estudia Portfolio Agent

2. Identifica TU caso de uso único:

   • ¿Qué problema resolverá tu agente?
   • ¿Qué APIs o fuentes de datos utilizará?
   • ¿Qué lo hace diferente de los agentes existentes?

3. Planifica el flujo de trabajo de tu agente:

   • ¿Solicitud-respuesta simple?
   • ¿Razonamiento Guiado por Esquemas (SGR)?
   • ¿Análisis multi-paso?

Paso 2: Inicializa Tu NUEVO Agente

Usa el script de inicialización para crear un proyecto limpio:

# Crea tu agente único
python scripts/init-agent.py mi-agente-unico \
  --template typescript \
  --description "Descripción de lo que hace TU agente"

# Navega al proyecto
cd mi-agente-unico

# Instala dependencias
npm install  # TypeScript
# O
pip install -r requirements.txt  # Python

Esto crea un punto de partida limpio, no una copia de agentes existentes.

Paso 3: Comprende la Estructura de un Agente LangGraph

Todo agente LangGraph sigue esta estructura básica:

tu-agente/
├── src/
│   ├── agent.ts/py          # Lógica principal del agente (TU CÓDIGO)
│   ├── graph.ts/py          # Definición del flujo de trabajo LangGraph (TU CÓDIGO)
│   └── tools.ts/py          # Implementaciones de herramientas (TU CÓDIGO)
├── package.json / requirements.txt
├── langgraph.json           # Configuración de LangGraph
└── README.md

Archivos clave a implementar:

• graph.ts/py - Define tu flujo de trabajo (validar → procesar → responder)
• agent.ts/py - Implementa tu lógica central
• tools.ts/py - Integra APIs externas específicas para el propósito de TU agente

Paso 4: Implementa la Lógica Personalizada de Tu Agente

Estudia los patrones de los ejemplos, aplícalos a TU caso de uso:

Si construyes un recuperador de datos simple (como el patrón de Weather Agent):

// Define el flujo de trabajo
const workflow = new StateGraph({
  channels: agentState
})
  .addNode("fetch", obtenerTusDatos)      // TU API
  .addNode("process", procesarTusDatos)  // TU lógica
  .addNode("respond", generarRespuesta);

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

Si construyes análisis complejo (como el patrón de CoinGecko Agent - SGR):

// Define el flujo de trabajo SGR de 5 pasos
const workflow = new StateGraph({
  channels: agentState
})
  .addNode("validate", validarTuInput)     // TU validación
  .addNode("extract", extraerTusParametros)      // TU extracción
  .addNode("fetch", obtenerTusDatos)            // TUS APIs
  .addNode("analyze", analizarTusDatos)        // TU análisis
  .addNode("generate", generarTuRespuesta); // TU formateo

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

Principios Clave:

1. Mantén los flujos de trabajo lineales y predecibles
2. Valida las entradas en cada etapa
3. Maneja los errores con elegancia
4. Usa OpenAI para la generación de lenguaje natural
5. Estructura las respuestas de manera consistente

CRÍTICO: Esto debe ser TU implementación resolviendo TU problema, no una copia de los agentes de ejemplo.

Paso 5: Configura el Entorno

Crea el archivo .env:

# Requerido
OPENAI_API_KEY=tu_clave_openai

# Requerido para LangSmith Deployments (nube)
LANGSMITH_API_KEY=tu_clave_langsmith

# Opcional - basado en tus herramientas
WEATHER_API_KEY=tu_clave_weather
COINGECKO_API_KEY=tu_clave_coingecko
ALCHEMY_API_KEY=tu_clave_alchemy

Obteniendo la Clave API de LangSmith:

1. Crea una cuenta en https://smith.langchain.com
2. Navega a Configuración → API Keys
3. Crea una nueva clave API
4. Agrégala al archivo .env

Actualiza langgraph.json:

{
  "agent_id": "[NOMBRE-DE-TU-AGENTE]",
  "python_version": "3.11",  // u omite para TypeScript
  "dependencies": ["."],
  "graphs": {
    "agent": "./src/graph.ts"  // o .py
  },
  "env": ".env"
}

Paso 6: Prueba Localmente

# TypeScript
npm run dev

# Python
langgraph dev

Prueba la API de tu agente:

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

Opciones de Despliegue

Opción 1: LangSmith Deployments (Recomendado)

Ventajas: Más rápido, más simple, infraestructura administrada Requisitos: Clave API de LangSmith

Pasos:

1. Sube el repositorio de tu agente a GitHub.
2. Crea un nuevo despliegue en LangSmith Deployments.
3. Conecta el repositorio, configura las variables de entorno y despliega.

Tu agente recibe:

• URL del endpoint de API
• Autenticación automática (usa tu clave API de LangSmith)
• Escalado y monitoreo automáticos

Autenticación para llamadas API: Al llamar a tu agente desplegado, incluye tu clave API de LangSmith:

curl AGENT_URL/runs/wait \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: [TU-CLAVE-API-DE-LANGSMITH]' \
  --data '{
    "assistant_id": "[TU-ID-DE-AGENTE]",
    "input": {
      "messages": [{"role": "user", "content": "consulta de prueba"}]
    }
  }'

Opción 2: Infraestructura Auto-Gestionada

Ventajas: Control total sobre el tiempo de ejecución Requisitos:

• Alojamiento de contenedor Docker
• Endpoint de API expuesto
• Certificado SSL (HTTPS)
• Monitoreo y registro

Configuración Básica de Docker:

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

Despliega y anota tu:

• URL de API: https://tu-dominio.com/agent
• Clave API: Generada para autenticación

Registro en Warden Studio

Una vez que tu agente esté desplegado y accesible vía HTTPS, regístralo en Warden Studio:

1. Proporciona Detalles de API:

   • URL de API
   • Clave API

2. Agrega Metadatos:

   • Nombre del agente
   • Descripción
   • Lista de habilidades/capacidades
   • Imagen de avatar

3. Publica: El agente aparece en el Hub de Agentes de Warden para millones de usuarios

No se requiere configuración adicional: ¡tu agente accesible vía API está listo!

Próximo paso (habilidad separada): Si el usuario solicita publicar en Warden Studio o necesita pasos guiados en la UI, cambia a la habilidad OpenClaw "Desplegar Agente en Warden Studio": https://www.clawhub.ai/Kryptopaid/warden-studio-deploy

Mejores Prácticas

1. Diseño del Agente

• Estudia la estructura del Weather Agent para aprender patrones
• Usa Razonamiento Guiado por Esquemas para flujos de trabajo complejos
• Mantén las respuestas concisas y accionables
• Maneja fallos de API con elegancia
• Valida todas las entradas

2. Integración de API

• Usa variables de entorno para las claves API
• Implementa limitación de tasa
• Almacena en caché las respuestas cuando sea apropiado
• Registra errores para depuración
• Devuelve respuestas JSON estructuradas

3. Pruebas

• Prueba localmente antes de desplegar
• Verifica que todos los endpoints de API funcionen
• Prueba casos límite y errores
• Asegúrate de que las respuestas sean amigables para el usuario
• Valida contra los requisitos de Warden

4. Documentación

• Escribe un README claro con:
  • Propósito y capacidades del agente
  • Claves API requeridas
  • Instrucciones de configuración
  • Consultas de ejemplo
  • Limitaciones conocidas

Patrones Comunes

Patrón 1: Recuperador de Datos Simple

// Obtener → Formatear → Responder
async function agent(input: string) {
  const data = await fetchAPI(input);
  const formatted = formatData(data);
  return generateResponse(formatted);
}

Patrón 2: Análisis Multi-Paso

// Validar → Extraer → Obtener → Analizar → Generar
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);
}

Patrón 3: Análisis Comparativo

// Analizar → Obtener Múltiples → Comparar → Resumir
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);
}

Solución de Problemas

Problemas Comunes

"El agente no es accesible vía API"

• Verifica que el despliegue se haya completado exitosamente
• Revisa la configuración del firewall/grupo de seguridad
• Asegúrate de que el endpoint de API sea accesible públicamente
• Prueba con curl o Postman

"Errores de LangGraph durante la compilación"

• Verifica la versión de Node.js (18+) o Python (3.11+)
• Revisa que todas las dependencias estén instaladas
• Valida la sintaxis de langgraph.json
• Revisa los registros de errores en la consola de despliegue

"Errores de API de OpenAI"

• Verifica que la clave API sea válida
• Revisa que no se hayan excedido los límites de tasa
• Asegúrate de tener créditos suficientes
• Revisa los mensajes de error para más detalles

"Las respuestas del agente son lentas"

• Optimiza las llamadas API (paraleliza cuando sea posible)
• Implementa almacenamiento en caché para consultas repetidas
• Reduce el uso de tokens de LLM
• Considera actualizar la infraestructura

Consejos para el Programa de Incentivos

El programa de incentivos está abierto a agentes OpenClaw que se desplieguen en Warden.

1. Sé Original: Crea algo NUEVO que aún no exista

   • No recrees el Weather Agent, CoinGecko Agent o Portfolio Agent
   • Estudia sus patrones, aplícalos a problemas diferentes

2. Resuelve Problemas Reales: Enfócate en funcionalidad útil y única

   • ¿Qué brecha existe en el ecosistema de Warden?
   • ¿Qué querrían realmente los usuarios?

3. Empieza Simple: Es mejor hacer una cosa excepcionalmente bien

   • No intentes construir todo de una vez
   • Los agentes simples y enfocados a menudo ganan

4. Calidad Sobre Funcionalidades: La fiabilidad supera a la complejidad

   • Prueba a fondo
   • Maneja errores con elegancia
   • Proporciona respuestas claras y útiles

5. Estudia los Ejemplos: Aprende patrones, no copies implementaciones

   • Weather Agent → Patrón de obtención simple de datos
   • CoinGecko Agent → Patrón de flujo de trabajo SGR
   • Portfolio Agent → Patrón de integración multi-fuente

6. Documenta Bien: README claro con ejemplos e instrucciones de configuración

7. Únete a Discord: Obtén retroalimentación en el canal #developers antes de enviar

Ideas de Agentes de Ejemplo (¡Construye Estos!)

Estas son ideas de agentes NUEVOS que aún no existen en el ecosistema de Warden. Construye uno de estos (o crea tu propia idea única):

Casos de Uso Web3:

• Optimizador de precios de gas (predice los mejores momentos para transacciones)
• Rastreador de carteras de ballenas con alertas personalizables
• Buscador de oportunidades de arbitraje entre DEXs

Casos de Uso DeFi:

• Agente de evaluación de riesgos de pools de liquidez
• Asistente de optimización de rendimiento agrícola
• Analizador de tarifas de gas entre cadenas

Casos de Uso de Gobernanza:

• Analizador de ánimo de propuestas de DAO
• Rastreador de asistencia a votaciones para protocolos
• Resumidor de discusiones sobre propuestas

Casos de Uso de NFT:

• Recomendador basado en preferencias del usuario
• Agente de análisis de tendencias de mercado
• Verificador de rareza y autenticidad

Casos de Uso Generales:

• Analizador de sentimiento de mercado de criptomonedas
• Monitor de explotación de seguridad
• Asistente personalizado de impuestos DeFi

Casos de Uso Educativos:

• Explicador de conceptos Web3 con ejemplos del mundo real
• Tutor interactivo de contratos inteligentes
• Simulador de estrategias DeFi

¡Recuerda elegir una idea y construir algo que NO exista ya en el repositorio!