undefined

undefined

awesome-openclaw-usecases-zh/
├── README.md                 # Main index with 50+ use cases
├── CONTRIBUTING.md           # Contribution guidelines
├── AGENT-GUIDE.md           # Guide for AI agents to use this repo
├── usecases/
│   ├── cn-*.md              # China-specific use cases (23)
│   ├── *.md                 # International use cases (27)
│   └── images/              # Screenshots and diagrams
└── templates/
    └── usecase-template.md  # Standard use case format

---
difficulty: ⭐ (copy-paste) | ⭐⭐ (config needed) | ⭐⭐⭐ (technical)
platform: [feishu|dingtalk|wecom|xiaohongshu|...]
tags: [automation, content-creation, ...]
---

undefined

// Install official Feishu SDK
npm install @larksuiteoapi/node-sdk

// Initialize bot
const lark = require('@larksuiteoapi/node-sdk');
const client = new lark.Client({
  appId: process.env.FEISHU_APP_ID,
  appSecret: process.env.FEISHU_APP_SECRET,
});

// Handle incoming messages
app.post('/webhook', async (req, res) => {
  const { event } = req.body;
  if (event.type === 'message') {
    const { message_id, content } = event.message;
    const userInput = JSON.parse(content).text;
    
    // Send to OpenClaw agent
    const response = await openclawAgent.process(userInput);
    
    // Reply in Feishu
    await client.im.message.reply({
      message_id,
      content: JSON.stringify({ text: response }),
      msg_type: 'text',
    });
  }
  res.json({ ok: true });
});

undefined

# Process with OpenClaw
response = openclaw_agent.process(content)

# Reply
dingtalk_client.send_text_message(
    message.sender_id,
    response
)
return AckMessage.STATUS_OK

undefined

undefined

**OpenClaw Skill Integration**:

```markdown

undefined

undefined

# Get sector money flow
sectors = ak.stock_sector_fund_flow_rank(indicator="今日")
top_sectors = sectors.head(5)

return {
    "sh_index": {
        "close": latest['close'],
        "change": latest['close'] - latest['open'],
        "volume": latest['volume']
    },
    "top_sectors": top_sectors.to_dict('records')
}

return {
    "gainers": gainers[['code', 'name', 'pct_chg']].to_dict('records'),
    "losers": losers[['code', 'name', 'pct_chg']].to_dict('records')
}

undefined

undefined

**Implementation Example**:

```javascript
// Coordinator agent prompt
const coordinatorPrompt = `
You are a coordinator. When given a task:
1. Break it into subtasks
2. Assign each to a specialist sub-agent:
   - @researcher for data collection
   - @writer for content creation
   - @publisher for distribution
3. Collect results and synthesize
4. Return final output

Current task: Create and publish a Xiaohongshu post about OpenClaw
`;

// Spawn sub-agents
const researchResult = await spawnAgent('researcher', {
  task: 'Find trending OpenClaw use cases',
  tools: ['perplexity_search', 'github_trending']
});

const content = await spawnAgent('writer', {
  task: 'Write Xiaohongshu post',
  context: researchResult,
  tools: ['markdown_formatter', 'emoji_suggester']
});

const published = await spawnAgent('publisher', {
  task: 'Publish to Xiaohongshu',
  content: content,
  tools: ['xiaohongshu_api']
});

undefined

# Create note
note = client.create_note(
    title=title,
    desc=content,
    image_ids=image_ids,
    tags=tags,
    post_time=None,  # Publish immediately, or set timestamp
    is_private=False
)

return note['note_id']

undefined

undefined

html = markdown2.markdown(md_content, extras=['fenced-code-blocks'])

# Apply WeChat styling
styled_html = f"""
<section style="font-size: 16px; color: #333;">
    {html}
</section>
"""
return styled_html

result = client.material.add_news(articles)
return result['media_id']

undefined

// Get meeting transcript from Feishu
const getMeetingTranscript = async (meetingId) => {
  const response = await fetch(
    `https://open.feishu.cn/open-apis/vc/v1/meetings/${meetingId}/recording`,
    {
      headers: {
        Authorization: `Bearer ${process.env.FEISHU_TENANT_TOKEN}`,
      },
    }
  );
  const data = await response.json();
  return data.data.recording_url;
};

// Download and transcribe
const transcription = await whisperAPI.transcribe(recordingUrl);

// OpenClaw processes transcript
const prompt = `
Analyze this meeting transcript and generate:
1. Summary (3-5 sentences)
2. Key decisions made
3. Action items with owners and deadlines
4. Follow-up questions

Transcript:
${transcription}
`;

const analysis = await openclawAgent.process(prompt);

// Create Feishu tasks automatically
for (const actionItem of analysis.action_items) {
  await feishuClient.task.create({
    summary: actionItem.task,
    due_date: actionItem.deadline,
    assignee: actionItem.owner,
  });
}

undefined

conn = sqlite3.connect('WeChat/Msg/Multi/MSG0.db')
cursor = conn.cursor()

cursor.execute("""
    SELECT strftime('%Y-%m-%d', CreateTime, 'unixepoch'), 
           Message, IsSender
    FROM MSG
    WHERE Type = 1  -- Text messages only
    ORDER BY CreateTime DESC
    LIMIT 10000
""")

messages = cursor.fetchall()
return [{'date': m[0], 'text': m[1], 'is_sender': m[2]} 
        for m in messages]

undefined

undefined

undefined

import time
from functools import wraps

def rate_limit(calls_per_minute=60):
    min_interval = 60.0 / calls_per_minute
    last_called = [0.0]
    
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            elapsed = time.time() - last_called[0]
            if elapsed < min_interval:
                time.sleep(min_interval - elapsed)
            result = func(*args, **kwargs)
            last_called[0] = time.time()
            return result
        return wrapper
    return decorator

@rate_limit(calls_per_minute=50)
def call_feishu_api():
    # Your API call
    pass

def get_stock_data(symbol, retries=3):
    try:
        return ak.stock_zh_a_hist(symbol=symbol)
    except Exception as e:
        if retries > 0:
            time.sleep(2)
            return get_stock_data(symbol, retries - 1)
        else:
            # Fallback to manual data source
            return fetch_from_tushare(symbol)

import browser_cookie3

def refresh_cookie(domain):
    """Auto-refresh cookie from browser"""
    cookies = browser_cookie3.chrome(domain_name=domain)
    cookie_str = '; '.join([f'{c.name}={c.value}' for c in cookies])
    return cookie_str

undefined

// In AGENTS.md
memory_strategy: {
  coordinator: "workspace/memory/coordinator.json",
  researcher: "workspace/memory/researcher.json",
  writer: "workspace/memory/writer.json",
}

// Code
async function saveAgentMemory(agentName, data) {
  const memoryPath = `workspace/memory/${agentName}.json`;
  await fs.writeFile(memoryPath, JSON.stringify(data, null, 2));
}