LeoYeAI/openclaw-master-skills

Warden Agent Builder

Erstelle und veröffentliche LangGraph-Agenten für das 'Agentic Wallet'-Ökosystem des Warden-Protokolls.

⚠️ WICHTIG: Über Beispiel-Agenten

Das Warden-Community-Repository enthält Beispiel-Agenten zum Lernen, keine vorlagenhaften Kopiervorlagen:

• Wetter-Agent – Studieren, um einfache Datenabfrage-Muster zu lernen
• CoinGecko-Agent – Studieren, um Schema-Guided Reasoning (SGR) zu lernen
• Portfolio-Agent – Studieren, um komplexe Multi-Source-Integration zu lernen

BAUE DIESE AGENTEN NICHT – sie existieren bereits. Stattdessen:

1. Studiere ihren Code, um Muster zu verstehen
2. Lerne aus ihrer Architektur und ihren Arbeitsabläufen
3. Baue etwas NEUES und Originelles für das Anreizprogramm

Dein Agent muss einzigartig sein und ein anderes Problem lösen, um für das Anreizprogramm förderfähig zu sein.

Übersicht

Warden Protocol ist ein "Agentic Wallet for the Do-It-For-Me economy" mit einem aktiven Agent Builder Incentive Programme, das für OpenClaw-Agenten offen ist, die auf Warden ausgerollt werden. Alle Agenten müssen LangGraph-basiert und über eine API erreichbar sein.

Wichtige Ressourcen:

• Community Agents Repository: https://github.com/warden-protocol/community-agents
• Dokumentation: https://docs.wardenprotocol.org
• Discord: #developers-Kanal für Unterstützung

Checkliste der Anforderungen

Stelle vor dem Bau sicher, dass dein Agent diese verbindlichen Anforderungen erfüllt:

✓ Framework: Mit LangGraph erstellt (TypeScript oder Python) ✓ Bereitstellung: LangSmith Deployments ODER eigene Infrastruktur ✓ Zugänglichkeit: Über API erreichbar (kein UI erforderlich – Warden stellt UI bereit) ✓ Isolation: Ein Agent pro LangGraph-Instanz ✓ Sicherheitseinschränkungen (Phase 1):

• Kein Zugriff auf Benutzer-Wallets
• Keine Datenspeicherung auf der Warden-Infrastruktur

✓ Funktionalität: Kann jeden Arbeitsablauf umsetzen:

• Web3/Web2-Automatisierung
• API-Integrationen
• Datenbankverbindungen
• Externe Tool-Interaktionen

Die Beispiel-Agenten verstehen

Das Community-Agents-Repository enthält Referenzbeispiele, von denen du lernen kannst, KEINE Vorlagen, die nachgebaut werden sollen:

Beispiel-Agent 1: LangGraph Quick Start (Für Grundlagen studieren)

Ort: agents/langgraph-quick-start (TypeScript) oder agents/langgraph-quick-start-py (Python) Lerne: LangGraph-Grundlagen, minimalen Agentenaufbau Studieren: Ein-Knoten-Chatbot mit OpenAI-Integration

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

Beispiel-Agent 2: Weather Agent (Für Struktur studieren)

Ort: agents/weather-agent Lerne: Einfaches Datenabrufen, API-Integration, benutzerfreundliche Antworten Studieren:

• Wie Daten von externen APIs abgerufen werden (WeatherAPI)
• Verarbeitung und Formatierung von Ergebnissen
• Klaren Umfang und klare Struktur ⚠️ NICHT NACHBAUEN: Dieser Agent existiert bereits. Studiere ihn, baue dann etwas NEUES.

Beispiel-Agent 3: CoinGecko Agent (Für SGR-Muster studieren)

Ort: agents/coingecko-agent Lerne: Schema-Guided Reasoning, komplexe Arbeitsabläufe Studieren:

• 5-Schritt-SGR-Arbeitsablauf: Validieren → Extrahieren → Abrufen → Validieren → Analysieren
• Muster für vergleichende Analysen
• Fehlerbehandlung und Datenvalidierung ⚠️ NICHT NACHBAUEN: Dieser Agent existiert bereits. Studiere das Muster, wende es auf neue Anwendungsfälle an.

Beispiel-Agent 4: Portfolio Analysis Agent (Für fortgeschrittene Muster studieren)

Ort: agents/portfolio-agent Lerne: Multi-Source-Datensynthese, Produktionsarchitektur Studieren:

• Integration mehrerer APIs (CoinGecko + Alchemy)
• Multi-Chain-Unterstützung (EVM und Solana)
• Komplexe SGR-Arbeitsabläufe
• Umfassende Berichterstattung ⚠️ NICHT NACHBAUEN: Dieser Agent existiert bereits. Studiere die Architektur für deinen eigenen komplexen Agenten.

WICHTIG: Baue etwas NEUES

Diese Beispiele dienen dazu, Muster und Best Practices zu vermitteln. Für das Anreizprogramm MUSST du einen originellen, einzigartigen Agenten erstellen, der ein anderes Problem löst. Baue nicht einfach den Wetter-Agenten, CoinGecko-Agenten oder Portfolio-Agenten nach.

Deinen eigenen Agenten bauen

Schritt 1: Beispiele studieren und eigenen Ansatz wählen

Klone KEIN Beispiel, um es zu modifizieren. Stattdessen:

1. Studiere die Beispiele, um Muster zu verstehen:

   • Einfaches Datenabrufen → Studiere Weather Agent
   • Komplexe Analyse → Studiere CoinGecko Agent
   • Multi-Source-Synthese → Studiere Portfolio Agent

2. Identifiziere DEINEN einzigartigen Anwendungsfall:

   • Welches Problem wird dein Agent lösen?
   • Welche APIs oder Datenquellen wird er nutzen?
   • Was macht ihn anders als bestehende Agenten?

3. Plane den Arbeitsablauf deines Agenten:

   • Einfaches Frage-Antwort-Schema?
   • Schema-Guided Reasoning (SGR)?
   • Mehrstufige Analyse?

Schritt 2: Deinen NEUEN Agenten initialisieren

Verwende das Initialisierungsskript, um ein frisches Projekt zu erstellen:

# Erstelle deinen einzigartigen Agenten
python scripts/init-agent.py my-unique-agent \
  --template typescript \
  --description "Beschreibung, was DEIN Agent tut"

# Zum Projekt navigieren
cd my-unique-agent

# Abhängigkeiten installieren
npm install  # TypeScript
# ODER
pip install -r requirements.txt  # Python

Dies erstellt einen sauberen Startpunkt, keine Kopie bestehender Agenten.

Schritt 3: Die LangGraph-Agentenstruktur verstehen

Jeder LangGraph-Agent folgt diesem grundlegenden Aufbau:

your-agent/
├── src/
│   ├── agent.ts/py          # Hauptagentenlogik (DEIN CODE)
│   ├── graph.ts/py          # LangGraph-Arbeitsablaufdefinition (DEIN CODE)
│   └── tools.ts/py          # Tool-Implementierungen (DEIN CODE)
├── package.json / requirements.txt
├── langgraph.json           # LangGraph-Konfiguration
└── README.md

Wichtige Dateien zur Implementierung:

• graph.ts/py – Definiere deinen Arbeitsablauf (validieren → verarbeiten → antworten)
• agent.ts/py – Implementiere deine Kernlogik
• tools.ts/py – Integriere externe APIs, die für den Zweck DEINES Agenten spezifisch sind

Schritt 4: Deine benutzerdefinierte Agentenlogik implementieren

Studiere Muster aus den Beispielen, wende sie auf DEINEN Anwendungsfall an:

Wenn du einen einfachen Datenabrufer baust (wie das Weather-Agent-Muster):

// Arbeitsablauf definieren
const workflow = new StateGraph({
  channels: agentState
})
  .addNode("fetch", fetchYourData)      // DEINE API
  .addNode("process", processYourData)  // DEINE Logik
  .addNode("respond", generateResponse);

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

Wenn du komplexe Analysen baust (wie das CoinGecko-Agent-Muster - SGR):

// 5-Schritt-SGR-Arbeitsablauf definieren
const workflow = new StateGraph({
  channels: agentState
})
  .addNode("validate", validateYourInput)     // DEINE Validierung
  .addNode("extract", extractYourParams)      // DEINE Extraktion
  .addNode("fetch", fetchYourData)            // DEINE APIs
  .addNode("analyze", analyzeYourData)        // DEINE Analyse
  .addNode("generate", generateYourResponse); // DEINE Formatierung

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

Wichtige Prinzipien:

1. Halte Arbeitsabläufe linear und vorhersehbar
2. Validiere Eingaben in jeder Stufe
3. Behandle Fehler elegant
4. Verwende OpenAI zur Generierung natürlicher Sprache
5. Strukturiere Antworten konsistent

KRITISCH: Dies sollte DEINE Implementierung sein, die DEIN Problem löst, keine Kopie der Beispiel-Agenten.

Schritt 5: Umgebung konfigurieren

Erstelle .env-Datei:

# Erforderlich
OPENAI_API_KEY=dein_openai_key

# Erforderlich für LangSmith Deployments (Cloud)
LANGSMITH_API_KEY=dein_langsmith_key

# Optional – basierend auf deinen Tools
WEATHER_API_KEY=dein_weather_key
COINGECKO_API_KEY=dein_coingecko_key
ALCHEMY_API_KEY=dein_alchemy_key

LangSmith-API-Schlüssel erhalten:

1. Konto erstellen unter https://smith.langchain.com
2. Navigiere zu Einstellungen → API-Schlüssel
3. Neuen API-Schlüssel erstellen
4. Zur .env-Datei hinzufügen

Aktualisiere langgraph.json:

{
  "agent_id": "[DEIN-AGENTENNAME]",
  "python_version": "3.11",  // oder weglassen für TypeScript
  "dependencies": ["."],
  "graphs": {
    "agent": "./src/graph.ts"  // oder .py
  },
  "env": ".env"
}

Schritt 6: Lokal testen

# TypeScript
npm run dev

# Python
langgraph dev

Teste die API deines Agenten:

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

Bereitstellungsoptionen

Option 1: LangSmith Deployments (Empfohlen)

Vorteile: Am schnellsten, einfachste, verwaltete Infrastruktur Voraussetzungen: LangSmith-API-Schlüssel

Schritte:

1. Schiebe dein Agenten-Repository auf GitHub.
2. Erstelle ein neues Deployment in LangSmith Deployments.
3. Verbinde das Repository, setze Umgebungsvariablen und stelle bereit.

Dein Agent erhält:

• API-Endpunkt-URL
• Automatische Authentifizierung (verwendet deinen LangSmith-API-Schlüssel)
• Automatische Skalierung und Überwachung

Authentifizierung für API-Aufrufe: Wenn du deinen bereitgestellten Agenten aufrufst, füge deinen LangSmith-API-Schlüssel hinzu:

curl AGENT_URL/runs/wait \
  --request POST \
  --header 'Content-Type: application/json' \
  --header 'x-api-key: [DEIN-LANGSMITH-API-SCHLÜSSEL]' \
  --data '{
    "assistant_id": "[DEINE-AGENTEN-ID]",
    "input": {
      "messages": [{"role": "user", "content": "test query"}]
    }
  }'

Option 2: Selbst gehostete Infrastruktur

Vorteile: Volle Kontrolle über die Laufzeit Voraussetzungen:

• Docker-Container-Hosting
• Offengelegter API-Endpunkt
• SSL-Zertifikat (HTTPS)
• Überwachung und Protokollierung

Basis-Docker-Setup:

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

Stelle bereit und notiere:

• API-URL: https://deine-domain.com/agent
• API-Schlüssel: Für die Authentifizierung generiert

Bei Warden Studio registrieren

Sobald dein Agent bereitgestellt und über HTTPS erreichbar ist, registriere ihn in Warden Studio:

1. API-Details angeben:

   • API-URL
   • API-Schlüssel

2. Metadaten hinzufügen:

   • Agentenname
   • Beschreibung
   • Liste der Fähigkeiten/Kompetenzen
   • Avatar-Bild

3. Veröffentlichen: Der Agent erscheint im Warden Agent Hub für Millionen von Benutzern

Keine zusätzliche Einrichtung erforderlich – dein über API erreichbarer Agent ist bereit!

Nächster Schritt (separater Skill): Wenn der Benutzer fragt, ob er in Warden Studio veröffentlichen soll oder geführte UI-Schritte benötigt, wechsle zum OpenClaw-Skill "Deploy Agent on Warden Studio": https://www.clawhub.ai/Kryptopaid/warden-studio-deploy

Best Practices

1. Agenten-Design

• Studiere die Struktur des Weather Agent, um Muster zu lernen
• Verwende Schema-Guided Reasoning für komplexe Arbeitsabläufe
• Halte Antworten präzise und handlungsorientiert
• Behandle API-Fehler elegant
• Validiere alle Eingaben

2. API-Integration

• Verwende Umgebungsvariablen für API-Schlüssel
• Implementiere Ratenbegrenzung
• Zwischenspeichere Antworten, wo angemessen
• Protokolliere Fehler zum Debuggen
• Gib strukturierte JSON-Antworten zurück

3. Testen

• Teste lokal vor der Bereitstellung
• Überprüfe, ob alle API-Endpunkte funktionieren
• Teste Randfälle und Fehler
• Stelle sicher, dass Antworten benutzerfreundlich sind
• Validiere gegen die Warden-Anforderungen

4. Dokumentation

• Schreibe eine klare README mit:
  • Zweck und Fähigkeiten des Agenten
  • Erforderliche API-Schlüssel
  • Einrichtungsanweisungen
  • Beispielabfragen
  • Bekannte Einschränkungen

Häufige Muster

Muster 1: Einfacher Datenabrufer

// Abrufen → Formatieren → Antworten
async function agent(input: string) {
  const data = await fetchAPI(input);
  const formatted = formatData(data);
  return generateResponse(formatted);
}

Muster 2: Mehrstufige Analyse

// Validieren → Extrahieren → Abrufen → Analysieren → Generieren
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);
}

Muster 3: Vergleichende Analyse

// Parsen → Mehrere Abrufen → Vergleichen → Zusammenfassen
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);
}

Fehlerbehebung

Häufige Probleme

"Agent nicht über API erreichbar"

• Überprüfe, ob die Bereitstellung erfolgreich abgeschlossen wurde
• Überprüfe Firewall-/Sicherheitsgruppeneinstellungen
• Stelle sicher, dass der API-Endpunkt öffentlich zugänglich ist
• Teste mit curl oder Postman

"LangGraph-Fehler beim Build"

• Überprüfe Node.js-Version (18+) oder Python (3.11+)
• Überprüfe, ob alle Abhängigkeiten installiert sind
• Validiere die Syntax von langgraph.json
• Überprüfe Fehlerprotokolle in der Bereitstellungskonsole

"OpenAI-API-Fehler"

• Überprüfe, ob der API-Schlüssel gültig ist
• Überprüfe, ob Ratenbegrenzungen nicht überschritten wurden
• Stelle ausreichende Guthaben sicher
• Überprüfe Fehlermeldungen für Details

"Agentenantworten sind langsam"

• Optimiere API-Aufrufe (parallelisieren, wo möglich)
• Implementiere Zwischenspeicherung für wiederholte Abfragen
• Reduziere die LLM-Token-Nutzung
• Erwäge ein Upgrade der Infrastruktur

Tipps für das Anreizprogramm

Das Anreizprogramm steht OpenClaw-Agenten offen, die auf Warden ausgerollt werden.

1. Sei originell: Erschaffe etwas NEUES, das es noch nicht gibt

   • Baue nicht den Weather Agent, CoinGecko Agent oder Portfolio Agent nach
   • Studiere ihre Muster, wende sie auf andere Probleme an

2. Löse echte Probleme: Konzentriere dich auf nützliche, einzigartige Funktionalität

   • Welche Lücke existiert im Warden-Ökosystem?
   • Was würden Benutzer tatsächlich wollen?

3. Fange einfach an: Es ist besser, eine Sache außergewöhnlich gut zu machen

   • Versuche nicht, alles auf einmal zu bauen
   • Einfache, fokussierte Agenten gewinnen oft

4. Qualität vor Funktionen: Zuverlässigkeit schlägt Komplexität

   • Teste gründlich
   • Behandle Fehler elegant
   • Gib klare, hilfreiche Antworten

5. Studiere die Beispiele: Lerne Muster, kopiere keine Implementierungen

   • Weather Agent → Einfaches Datenabrufmuster
   • CoinGecko Agent → SGR-Arbeitsablaufmuster
   • Portfolio Agent → Multi-Source-Integrationsmuster

6. Dokumentiere gut: Klare README mit Beispielen und Einrichtungsanweisungen

7. Trete dem Discord bei: Hole dir Feedback im #developers-Kanal, bevor du einreichst

Beispiel-Agentenideen (Baue diese!)

Dies sind NEUE Agentenideen, die es im Warden-Ökosystem noch nicht gibt. Baue eine davon (oder erstelle deine eigene einzigartige Idee):

Web3-Anwendungsfälle:

• Gaspreis-Optimierer (sagt optimale Gaspreise basierend auf Netzwerküberlastung und Transaktionsdringlichkeit voraus)
• NFT-Marktplatz-Aggregator (durchsucht mehrere Marktplätze nach den besten NFT-Angeboten)
• DeFi-Yield-Strateg (analysiert Yield-Farming-Möglichkeiten über mehrere Protokolle hinweg)
• Token-Launch-Monitor (verfolgt bevorstehende Token-Verkäufe und IDOs)
• On-Chain-Governance-Assistent (fasst Vorschläge zusammen, sagt Abstimmungsergebnisse voraus)

Web2-Anwendungsfälle:

• Meeting-Zusammenfassungs-Agent (verbindet sich mit Kalender-APIs, fasst Besprechungsnotizen zusammen)
• Dokumentenübersetzer und -formatierer (ruft Dokumente von verschiedenen Quellen ab, übersetzt und formatiert sie)
• Web Scraper und Daten-Erkenntnisse (durchsucht Websites nach bestimmten Daten, extrahiert und analysiert sie)
• E-Commerce-Preisverfolger (überwacht Preise auf mehreren E-Commerce-Websites)

Multi-Source-Integrations-Anwendungsfälle:

• Sozialplattform-Analysator (sammelt Daten von Twitter, Reddit, Discord zu einem Thema)
• Forschungsassistent (ruft Informationen von mehreren akademischen APIs und Nachrichtenquellen ab und fasst sie zusammen)
• Marktintelligenz-Agent (kombiniert Web3-On-Chain-Daten mit traditionellen Finanzdaten-APIs)

Lizenz

MIT