Blog

If you’ve just started running OpenClaw on a Hetzner VPS, or any other cloud provider, and you’re seeing unexpected resource spikes or even crashes, especially during off-peak hours, you’re not alone. I encountered this frequently in my first month, leading to a lot of head-scratching. The problem often isn’t the OpenClaw core itself, but how underlying dependencies and resource management interact with the burstable nature of most cloud VMs. Specifically, I found that the default log rotation and temporary file cleanup mechanisms on my Ubuntu 22.04 LTS Hetzner instance were clashing with OpenClaw’s internal state management, leading to temporary file system exhaustion and subsequent application failure.

Affiliate Disclosure: As an Amazon Associate, we earn from qualifying purchases. This means we may earn a small commission when you click our links and make a purchase on Amazon. This comes at no extra cost to you and helps support our site.

Understanding the “Phantom” Resource Spikes

My initial deployment was a standard OpenClaw setup: a small Python script invoking the OpenClaw API for daily summarization tasks, running within a Docker container on a CX21 (2 vCPU, 4GB RAM) Hetzner VPS. For the first few days, everything seemed fine. Then, I started noticing that my monitoring alerts for disk I/O and CPU utilization would spike erratically, usually between 2 AM and 4 AM UTC, often coinciding with OpenClaw failing to complete its tasks or, worse, the entire Docker daemon restarting. The docker logs openclaw-container command would often show truncated output or outright connection errors to the LLM provider, followed by messages like OSError: [Errno 28] No space left on device, even though df -h / showed plenty of free space.

The non-obvious insight here was the interaction between logrotate and OpenClaw’s default logging level. By default, OpenClaw can be quite verbose, especially during model inference or when encountering API errors. This verbosity, when combined with Docker’s default logging driver (usually json-file) and the host system’s logrotate, created a specific scenario. When logrotate would compress or move large Docker log files, it would briefly consume significant I/O and CPU, sometimes bottlenecking the already busy OpenClaw container trying to write its own logs or temporary inference data. The “no space left” error wasn’t about persistent disk space, but rather about temporary inode exhaustion or transient buffer space within the kernel during high I/O operations.

The Fix: Taming Logs and Temporary Files

To mitigate this, I made two critical adjustments. First, I configured Docker’s logging to be more conservative for the OpenClaw container. This prevents Docker itself from generating massive log files that need frequent rotation and compression. Add this to your docker-compose.yml for the OpenClaw service:

services:
  openclaw:
    image: openclaw/openclaw:latest
    # ... other configurations ...
    logging:
      driver: "json-file"
      options:
        max-size: "10m"
        max-file: "3"

This limits the Docker logs for the openclaw service to a maximum of 10MB per file, keeping only the three most recent files. This dramatically reduced the strain on the host system during log rotation.

Second, and more importantly, I realized OpenClaw’s default tmp_dir was often pointing to the system’s default /tmp. While fine for short-lived data, some LLM providers (especially local ones or those with complex streaming responses) can buffer significant data there. If /tmp is on a small, fast filesystem or a memory-backed filesystem (like tmpfs on some distributions), it can hit its limits quickly. The solution was to explicitly define a dedicated temporary directory within OpenClaw’s configuration and ensure it was mounted as a volume in Docker, pointing to a persistent disk location.

Add this to your .openclaw/config.json:

{
  "api_key": "your-api-key",
  "default_model": "claude-haiku-4-5",
  "tmp_dir": "/app/openclaw_tmp",
  "logging": {
    "level": "INFO",
    "filename": "/var/log/openclaw.log",
    "max_bytes": 10485760,
    "backup_count": 5
  }
}

Then, ensure this directory is mounted as a volume in your docker-compose.yml:

services:
  openclaw:
    image: openclaw/openclaw:latest
    volumes:
      - ./data/openclaw_tmp:/app/openclaw_tmp
      - ./data/logs:/var/log
      - ./config.json:/app/.openclaw/config.json:ro # Assuming config.json is in your project root
    # ... rest of the service config ...

This ensures /app/openclaw_tmp inside the container maps to ./data/openclaw_tmp on your host, preventing temporary data from exhausting critical system partitions. Similarly, the /var/log mount ensures OpenClaw’s own logs are also managed externally.

Model Choice and Cost Efficiency

Another significant surprise was the default model recommendation. While the documentation often suggests the latest frontier models for maximum capability, I quickly found that for 90% of my production tasks – summarizing articles, extracting key entities, or generating short, factual responses – a cheaper, faster model was perfectly adequate. My initial setup used claude-opus-20240229. While incredibly powerful, its latency and cost quickly became prohibitive for high-volume tasks. Switching to claude-haiku-4-5 reduced my API costs by approximately 10x for the same workload and significantly decreased overall inference time without any noticeable degradation in result quality for my specific use cases. Always benchmark with your actual data and desired output quality before committing to the most expensive model.

Limitations and Resource Requirements

It’s crucial to be honest about the limitations. These optimizations primarily address I/O and temporary file management issues. They assume your VPS has sufficient base resources for OpenClaw to operate. This setup, for instance, works well on a Hetzner CX21 (2 vCPU, 4GB RAM) for moderate workloads (e.g., 50-100 summarization tasks per hour). If you’re attempting to run OpenClaw on something like a Raspberry Pi 4 with only 1GB or 2GB of RAM, especially if you’re pulling in larger models or running other services, you will still struggle. The overhead of the Docker daemon itself, the Python runtime, and the memory footprint of even smaller LLM interactions means that a minimum of 2GB RAM is generally required for a stable OpenClaw deployment, with 4GB being much more comfortable for any bursty usage. Attempting to run local LLMs on such low-spec hardware is a non-starter.

The insights here are specifically for cloud VPS environments where you have root access and can configure Docker and OpenClaw’s underlying file system interactions. If you’re running OpenClaw in a more restricted environment, like a shared hosting platform or a serverless function, some of these solutions might not be directly applicable, and you’d need to consult your provider’s specific guidelines for temporary file handling and resource limits.

Your next concrete step: modify your docker-compose.yml to include the logging options and the volume mounts for openclaw_tmp and logs as specified, then run docker-compose up -d --build to apply the changes.

If you’re looking to turn your OpenClaw instance into a reliable home server assistant, handling monitoring, alerts, and automated maintenance, you’ve likely hit a few snags. The default OpenClaw setup is powerful for creative tasks, but a bit too chatty and resource-intensive for the background hum of a server assistant. We’re aiming for quiet, efficient operation, waking up only when something needs attention. Forget the verbose responses; we want concise, actionable information.

Affiliate Disclosure: As an Amazon Associate, we earn from qualifying purchases. This means we may earn a small commission when you click our links and make a purchase on Amazon. This comes at no extra cost to you and helps support our site.

Optimizing OpenClaw for Low-Resource Monitoring

The first step is to optimize OpenClaw itself. Running a full language model for every system check is overkill. For monitoring tasks, we often need pattern matching, simple comparisons, and the ability to summarize logs. The default claude-opus-20240229 is fantastic for complex generation, but it’s a resource hog and expensive. For monitoring, we can be much smarter.

I’ve found that claude-haiku-20240307 (or even gpt-3.5-turbo-0125 if you’re using OpenAI) is perfectly capable for 90% of monitoring tasks. It’s significantly faster and, crucially, 10x cheaper. Modify your ~/.openclaw/config.json to reflect this. If you don’t have this file, create it. Here’s a snippet:

{
  "api_key": "YOUR_ANTHROPIC_API_KEY",
  "default_model": "claude-haiku-20240307",
  "max_tokens": 512,
  "temperature": 0.2
}

Setting max_tokens to 512 prevents verbose responses, forcing the model to be succinct, which is exactly what you want for alerts. A low temperature (0.2) ensures more deterministic and factual output, reducing the chance of creative interpretations of your server’s health. This configuration alone will drastically reduce your API costs and improve response times for monitoring prompts.

Integrating with System Monitoring: Cron and Custom Scripts

The core of an effective home server assistant is its ability to interact with your system. OpenClaw isn’t a replacement for Prometheus or Nagios, but it can act as an intelligent layer on top of standard system tools. We’ll use cron jobs to periodically run scripts that collect data, and then feed that data to OpenClaw for interpretation and alerting.

Let’s say you want to monitor disk usage. Create a script, for example, ~/scripts/check_disk.sh:

#!/bin/bash
DISK_USAGE=$(df -h / | awk 'NR==2 {print $5}' | sed 's/%//')
if (( DISK_USAGE > 80 )); then
  echo "CRITICAL: Disk usage is at ${DISK_USAGE}%."
  echo "Disk usage for /: $(df -h /)"
  echo "Top 10 largest files/directories in /var: $(du -sh /var/* | sort -rh | head -n 10)"
else
  echo "Disk usage is normal: ${DISK_USAGE}%."
fi

Now, we’ll pipe the output of this script directly into OpenClaw. Edit your crontab with crontab -e:

# Run every hour
0 * * * * ~/scripts/check_disk.sh | while read line; do
  if echo "$line" | grep -q "CRITICAL"; then
    /usr/local/bin/openclaw "Analyze this server alert and suggest a fix, be concise: $line" > ~/openclaw_alerts/disk_alert_$(date +\%Y\%m\%d_\%H\%M).txt
  fi
done

This cron job runs hourly. If the disk usage is critical, it pipes the detailed message to OpenClaw, asking for analysis and a fix. The output is saved to a timestamped file. You can then set up another cron job or a simple script to email you the contents of any new files in ~/openclaw_alerts/, or push them to a notification service like ntfy.sh.

The non-obvious insight here is to *only* invoke OpenClaw when an anomaly is detected. Running openclaw on every check, even when things are normal, wastes tokens and API calls. The shell script handles the conditional logic, minimizing OpenClaw’s involvement.

Automated Maintenance and Self-Healing

For more advanced scenarios, OpenClaw can even suggest maintenance or “self-healing” actions. Let’s extend our disk example. Instead of just saving to a file, we could prompt OpenClaw to suggest a command. This requires careful consideration, as you’re giving an AI the ability to suggest commands to be run on your system. Always review suggested commands before execution, especially when starting out.

Let’s create a script ~/scripts/process_alert.sh:

#!/bin/bash
ALERT_MESSAGE="$1"
OPENCLAW_RESPONSE=$(/usr/local/bin/openclaw "Based on this server alert, what exact Linux command would you run to resolve the issue? Only output the command, nothing else. If no command is applicable, output 'NONE'. Alert: $ALERT_MESSAGE")

if [[ "$OPENCLAW_RESPONSE" != "NONE" && "$OPENCLAW_RESPONSE" != "" ]]; then
  echo "OpenClaw suggested command: $OPENCLAW_RESPONSE" >> ~/openclaw_actions.log
  # For safety, we just log it. For full automation, you'd add:
  # eval "$OPENCLAW_RESPONSE" >> ~/openclaw_actions.log 2>&1
  # echo "Command executed." >> ~/openclaw_actions.log
else
  echo "OpenClaw found no specific command for: $ALERT_MESSAGE" >> ~/openclaw_actions.log
fi

Then modify your crontab entry:

# Run every hour
0 * * * * ~/scripts/check_disk.sh | while read line; do
  if echo "$line" | grep -q "CRITICAL"; then
    ~/scripts/process_alert.sh "$line"
  fi
done

This setup will log OpenClaw’s suggested actions. Initially, you should manually review ~/openclaw_actions.log. Once you build confidence, you can uncomment the eval line in process_alert.sh for truly automated responses. Be extremely cautious with this, especially on production systems. The prompt “Only output the command, nothing else” is critical here to prevent OpenClaw from adding conversational filler that would break eval.

Limitations and Hardware Considerations

This approach works best on a VPS or a dedicated home server with at least 2GB of RAM. While OpenClaw itself is lightweight when idle, the underlying Python environment and API calls do consume some memory and CPU during execution. A Raspberry Pi 3 or older, especially with less than 2GB RAM, might struggle with the OpenClaw execution alongside other server tasks, leading to slower responses or system instability. Modern Pis (4 or 5) with sufficient RAM should be fine. Network latency to the API provider is also a factor; a fast, stable internet connection is assumed.

This setup is not a replacement for enterprise-grade monitoring solutions. It’s a practical, cost-effective way to add intelligent, human-readable insights and suggestions to your home server’s existing shell scripts and cron jobs. It excels at summarizing log data, translating technical alerts into understandable language, and suggesting remediation for common issues that might otherwise require manual research.

Your next concrete step: update your ~/.openclaw/config.json with "default_model": "claude-haiku-20240307" and "max_tokens": 512 to optimize OpenClaw for efficient monitoring.

If you’ve been developing custom skills for OpenClaw and find them consistently failing without clear error messages, you’re not alone. The OpenClaw skill execution environment can be a black box, especially when dealing with complex dependencies or subtle runtime issues. This guide will walk you through a systematic debugging process, focusing on practical steps and real-world scenarios that often trip up developers.

Understanding the OpenClaw Skill Execution Environment

Before diving into debugging, it’s crucial to understand how OpenClaw executes skills. Each skill runs in an isolated environment, typically a separate process or even a container, depending on your OpenClaw setup. This isolation is great for security and stability but makes direct debugging challenging. OpenClaw captures standard output (stdout) and standard error (stderr) from your skill’s execution and logs them. The primary challenge is that not all errors make it to these logs, especially if the process crashes early or a critical dependency isn’t met.

A common misconception is that if your skill works locally on your development machine, it will work perfectly within OpenClaw. This often isn’t true due to differences in environment variables, installed packages, user permissions, and working directories. OpenClaw typically executes skills from a specific working directory, often related to ~/.openclaw/skills/<skill_name>/, and might not inherit your shell’s environment path.

Initial Checks: The Low-Hanging Fruit

Start with the basics. Many skill failures are due to simple oversight. First, check your skill’s skill.yaml configuration file. Ensure the entrypoint path is correct and executable. For Python skills, this often looks like:

name: my_failing_skill
description: A skill that never works
entrypoint: python3 main.py
runtime: python

Verify that main.py actually exists in the root of your skill’s directory. A common error is placing it in a subdirectory, or misnaming it. Next, ensure all necessary dependencies are declared. For Python skills, this means a requirements.txt file in the skill’s root. OpenClaw will attempt to install these when the skill is loaded or updated.

# requirements.txt
requests
numpy

If you’re using a specific Python version, make sure OpenClaw is configured to use it, or explicitly call it in your entrypoint, e.g., python3.9 main.py. The non-obvious insight here is that OpenClaw’s default Python environment might not have all the system-wide packages you expect, even if they’re installed globally on your host. Always declare dependencies in requirements.txt.

Leveraging OpenClaw’s Internal Logs

OpenClaw provides internal logging that can be invaluable. The most direct way to access these logs is through the OpenClaw command-line interface (CLI). To see the output of a specific skill failing, use:

openclaw logs --skill my_failing_skill

This command will show you the captured stdout and stderr. Pay close attention to any Python tracebacks, permission denied errors, or “command not found” messages. If you see a Python traceback, the crucial part is often the first few lines indicating the file and line number where the error originated, and the last line describing the exception type.

For more verbose logging from OpenClaw itself, you can increase the global log level. This is particularly useful if your skill isn’t even getting to the point of execution (e.g., an issue with loading the skill itself). Edit your ~/.openclaw/config.json:

{
  "log_level": "DEBUG",
  "skills_directory": "~/.openclaw/skills"
}

Restart OpenClaw after making this change. Then, monitor the main OpenClaw logs:

openclaw logs --follow

This will show you much more detail about skill loading, dependency installation attempts, and execution commands. A common non-obvious issue here is a failed dependency installation. If pip install -r requirements.txt fails silently, your skill will still load but crash immediately on import. The DEBUG logs will often reveal the exact pip error.

Reproducing the Environment Locally

The most effective way to debug deeply is to replicate OpenClaw’s execution environment as closely as possible outside of OpenClaw. This involves manually running your skill’s entrypoint from the same working directory and with similar environment variables.

First, navigate to your skill’s directory:

cd ~/.openclaw/skills/my_failing_skill

Next, try to execute your entrypoint directly. If your skill.yaml specifies python3 main.py, run:

python3 main.py arg1 arg2 # replace arg1/arg2 with actual skill inputs if known

If your skill relies on environment variables that OpenClaw might set (e.g., API keys passed via skill configuration), you’ll need to simulate those. For example, if your skill expects OPENCLAW_API_KEY, you would run:

OPENCLAW_API_KEY="sk-..." python3 main.py

This direct execution will often reveal errors that were previously swallowed or difficult to trace through OpenClaw’s logs. The non-obvious insight here is to pay attention to the user running the process. OpenClaw typically runs as the user who started it, but if you’re running it as a systemd service, it might run under a different user with limited permissions. Check the file permissions in your skill directory (ls -l) and ensure the user running OpenClaw has read/execute access.

For Python skills, consider adding explicit print statements throughout your code, especially at the beginning of functions, and before and after critical operations. These print statements will show up in openclaw logs --skill my_failing_skill and can help pinpoint exactly where the execution flow breaks down.

Advanced Techniques: Using a Debugger and Test Frameworks

For very complex skills, direct local execution might not be enough. If your skill is a Python application, you can integrate a debugger. Modify your main.py to include a breakpoint or use a debugger like pdb:

# main.py
import pdb

def my_skill_function():
    # ... some code ...
    pdb.set_trace() # Execution will pause here
    # ... more code ...

if __name__ == "__main__":
    my_skill_function()

When you run this skill locally (python3 main.py), it will drop into a debugger prompt, allowing you to inspect variables and step through code. This won’t work directly within OpenClaw’s non-interactive environment, but it’s invaluable for isolating the problematic code path locally. The limitation here is that this technique is primarily for local debugging and can’t be used for live debugging within the OpenClaw runtime directly without significant effort to attach a remote debugger.

Finally, for robust skills, consider implementing unit and integration tests. A comprehensive test suite can catch regressions and ensure your skill functions as expected under various inputs, even before deploying it to OpenClaw. While this is more of a development best practice than a debugging technique, it prevents many issues from reaching the OpenClaw environment in the first place.

Conclusion and Next Step

Debugging OpenClaw skills requires a methodical approach, often moving from general checks to detailed environment replication. The key is to systematically narrow down the problem by leveraging OpenClaw’s logging capabilities and then reproducing the failure outside of OpenClaw to use standard debugging tools.

Your immediate next step is to update your ~/.openclaw/config.json to include "log_level": "DEBUG", restart OpenClaw, and then run openclaw logs --follow while attempting to invoke your failing skill. This will provide the most verbose output directly from OpenClaw, often revealing crucial setup or execution errors.

If you’re using OpenClaw to power a personal knowledge base and want it to integrate with Notion, you’ve likely hit a wall with keeping your Notion pages updated and organized without constant manual intervention. The dream is to simply dump information into a raw Notion page, and have OpenClaw categorize, summarize, and link it automatically. The reality is often a jumble of Python scripts, API rate limits, and a knowledge base that feels more like a chore than a help. This guide details a robust, self-managing system using OpenClaw and Notion, focusing on the practical steps and pitfalls.

Affiliate Disclosure: As an Amazon Associate, we earn from qualifying purchases. This means we may earn a small commission when you click our links and make a purchase on Amazon. This comes at no extra cost to you and helps support our site.

The Core Problem: Asynchronous Processing and Notion API Limits

The primary challenge when building an automated Notion knowledge base with OpenClaw is dealing with Notion’s API rate limits and the asynchronous nature of large language model (LLM) processing. You can’t just hit the Notion API with a hundred updates simultaneously. And waiting for OpenClaw to process a lengthy document synchronously before moving on often leads to timeouts or a sluggish user experience. We need a system that queues tasks, processes them in the background, and updates Notion when ready.

Our solution revolves around a combination of OpenClaw’s event-driven architecture, a simple SQLite queue, and a dedicated worker process. First, ensure your OpenClaw instance is configured to emit events upon document ingestion or modification. Add the following to your ~/.openclaw/config.json:

{
  "storage": {
    "driver": "sqlite",
    "path": "/var/lib/openclaw/data.db"
  },
  "event_bus": {
    "driver": "filesystem",
    "path": "/var/lib/openclaw/events"
  },
  "plugins": [
    "openclaw-notion-integrator"
  ],
  "notion": {
    "api_token": "secret_YOUR_NOTION_INTEGRATION_TOKEN",
    "database_id": "YOUR_NOTION_DATABASE_ID"
  }
}

The openclaw-notion-integrator is a custom plugin you’ll need to develop or adapt. It’s not part of the core OpenClaw distribution. This plugin listens for specific OpenClaw events (e.g., document.created, document.updated) and pushes a task into our SQLite queue. Here’s a simplified version of the plugin’s core logic:

# ~/.openclaw/plugins/openclaw_notion_integrator.py
import sqlite3
import json
import os

class NotionIntegratorPlugin:
    def __init__(self, config):
        self.config = config
        self.db_path = os.path.join(os.path.dirname(config['storage']['path']), 'notion_queue.db')
        self._init_db()

    def _init_db(self):
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS notion_tasks (
                id INTEGER PRIMARY KEY,
                event_type TEXT NOT NULL,
                payload TEXT NOT NULL,
                status TEXT DEFAULT 'pending'
            )
        ''')
        conn.commit()
        conn.close()

    def handle_event(self, event_type, payload):
        if event_type in ['document.created', 'document.updated']:
            conn = sqlite3.connect(self.db_path)
            cursor = conn.cursor()
            cursor.execute("INSERT INTO notion_tasks (event_type, payload) VALUES (?, ?)",
                           (event_type, json.dumps(payload)))
            conn.commit()
            conn.close()
            print(f"Queued Notion task for event: {event_type}")

    def register_handlers(self, event_bus):
        event_bus.register_handler('document.created', self.handle_event)
        event_bus.register_handler('document.updated', self.handle_event)

This plugin doesn’t directly interact with Notion. Instead, it acts as a bridge, ensuring that any relevant OpenClaw event is safely stored for later processing by a dedicated worker.

The Non-Obvious Insight: Model Choice and Cost Efficiency

When OpenClaw processes a document for summarization, categorization, or linking, it uses an LLM. The default models recommended in many OpenClaw examples, while powerful, can be prohibitively expensive for a personal knowledge base that might process dozens or hundreds of documents daily. For 90% of personal knowledge management tasks – generating a short summary, extracting keywords, or classifying a document into predefined categories – a smaller, cheaper model is often more than sufficient.

Specifically, I’ve found claude-haiku-4-5 to be an excellent balance of cost and capability. It’s often 10x cheaper than larger models like claude-opus-4-5 or even some GPT-4 variants, yet it performs remarkably well for typical knowledge base operations. To configure OpenClaw to use this:

# ~/.openclaw/config.json (excerpt)
{
  "llm": {
    "provider": "anthropic",
    "model": "claude-3-haiku-20240307",
    "api_key": "sk-ant-YOUR_ANTHROPIC_API_KEY"
  },
  "embedding": {
    "provider": "openai",
    "model": "text-embedding-3-small",
    "api_key": "sk-YOUR_OPENAI_API_KEY"
  },
  ...
}

Note: Even though we’re using Anthropic for the LLM, OpenAI’s text-embedding-3-small is incredibly cost-effective and performs well for embeddings. Mixing providers like this is perfectly fine and often leads to the most optimized setup.

The Dedicated Notion Worker

With tasks queued and OpenClaw configured for cost-efficient LLM use, we need a separate process to consume these tasks and update Notion. This worker runs independently, polling our SQLite queue and handling Notion API calls. This separation is crucial for rate limit management and fault tolerance.

Create a Python script, say notion_worker.py, with the following structure:

# notion_worker.py

import sqlite3

import json

import time

import os

from notion_client import Client

from openclaw.core.document import Document

from openclaw.core.config import Config

from openclaw.core.processor import Processor

# Load OpenClaw config to get Notion API token and database ID

config_path = os.path.expanduser('~/.openclaw/config.json')

claw_config = Config.from_file(config_path)

notion_api_token = claw_config.get('notion.api_token')

notion_database_id = claw_config.get('notion.database_id')
if not notion_api_token or not notion_database_id:

    raise ValueError("Notion API token or database ID not found in OpenClaw config.")
notion = Client(auth=notion_api_token)

processor = Processor(claw_config) # OpenClaw processor for document analysis
db_path = os.path.join(os.path.dirname(claw_config.get('storage.path')), 'notion_queue.db')
def get_next_task():

    conn = sqlite3.connect(db_path)

    cursor = conn.cursor()

    cursor.execute("SELECT id, event_type, payload FROM notion_tasks WHERE status = 'pending' LIMIT 1")

    task = cursor.fetchone()

    conn.close()

    return task
def update_task_status(task_id, status):

    conn = sqlite3.connect(db_path)

    cursor = conn.cursor()

    cursor.execute("UPDATE notion_tasks SET status = ? WHERE id = ?", (status, task_id))

    conn.commit()

    conn.close()
def process_document_for_notion(doc_payload):

    doc_id = doc_payload['id']

    # Reconstruct OpenClaw Document from payload

    # In a real scenario, you'd fetch the full document from OpenClaw's storage

    # For this example, let's assume 'content' is directly available or fetchable.

    # doc = processor.storage.get_document(doc_id) # This would be the robust way

    # For simplicity, let's assume payload contains enough for a basic Document object

    doc = Document(id=doc_payload['id'], content=doc_payload.get('content', ''))
    # Use OpenClaw's processor to get structured data