Introduction: Your Data, Your Rules, Your Assistant
In an era where cloud-based AI services often mean surrendering your private data and workflows, the promise of a truly personal assistant feels distant. What if your digital helper could live on your own machine, learning from your local files, calendars, and habits without ever sending a byte to a remote server? This is the agent-centric, local-first AI vision, and it’s fully achievable today with the OpenClaw ecosystem. This tutorial will guide you through building a Personal Assistant Agent that leverages local LLMs to manage your daily productivity, all while keeping your data under your control.
Why OpenClaw for a Local-First Assistant?
OpenClaw Core is not just another automation tool; it’s a framework designed for creating persistent, reasoning AI agents. Its architecture is perfect for a personal assistant because it allows the agent to maintain state, schedule itself, and interact with your local system securely. By combining it with a local LLM like Llama 3, Mistral, or Phi-3, you create a brain that processes your requests entirely offline. This setup ensures privacy, reduces latency, and allows for deep, personalized integration with your files and applications.
What You’ll Build
By the end of this tutorial, you will have a functional OpenClaw agent that can:
- Understand natural language requests via your local LLM.
- Manage your calendar and create events.
- Read, summarize, and organize documents from a designated folder.
- Set reminders and send you notifications.
- Operate on a schedule to provide daily briefings.
Prerequisites and Setup
Before we dive into the agent patterns, let’s ensure your environment is ready.
1. Installing OpenClaw Core
First, you need to install the OpenClaw runtime. It’s recommended to use a virtual environment.
- Create and activate a Python virtual environment:
python -m venv openclaw-env && source openclaw-env/bin/activate(or `\Scripts\activate` on Windows). - Install OpenClaw Core:
pip install openclaw-core
2. Setting Up a Local LLM
Your agent needs a brain. We’ll use Ollama for its simplicity and excellent OpenClaw integration.
- Download and install Ollama from ollama.ai.
- Pull a model suitable for your hardware (e.g.,
ollama pull llama3:8bormistral:7b). - Test it runs:
ollama run llama3:8b
3. Essential Skills & Plugins
Your assistant will need abilities. Install these core OpenClaw skills:
- Skill-Local-LLM: The bridge to Ollama. Install via:
claw skill install skill-local-llm - Skill-Filesystem: To read and manage your local documents.
- Skill-Scheduler: To run tasks at specific times.
- Skill-Notifications: For desktop alerts (OS dependent).
Install them using the same claw skill install command pattern.
Architecting Your Personal Assistant Agent
Now, let’s design the agent’s logic. We’ll create a single agent with multiple skills and a clear decision-making flow.
Step 1: Creating the Agent Configuration
Create a file named personal_assistant.yaml in your OpenClaw project directory. This YAML file defines your agent’s core identity and capabilities.
name: "PersonalAssistant"
description: "A local-first AI assistant for daily productivity."
skills:
- skill-local-llm
- skill-filesystem
- skill-scheduler
- skill-notifications
config:
llm:
provider: "ollama"
model: "llama3:8b"
watch_folder: "/path/to/your/documents"
Step 2: Building the Core Reasoning Loop
The agent’s intelligence comes from its ability to interpret a request, decide on an action, and execute it. We’ll write this logic in a Python file, assistant_agent.py.
First, import the necessary modules and initialize your agent with the config:
from openclaw.core.agent import Agent
import yaml
with open('personal_assistant.yaml', 'r') as f:
config = yaml.safe_load(f)
assistant = Agent(config=config)
Step 3: Implementing Key Functions (Handlers)
We’ll create functions, or handlers, for each major task. The local LLM skill will help parse the user’s intent.
Handler 1: Document Processing
This function monitors your `watch_folder` for new files and can summarize them.
@assistant.handler(pattern="summarize|review document")
async def handle_documents(context, request):
fs = assistant.get_skill("skill-filesystem")
llm = assistant.get_skill("skill-local-llm")
# Find the latest text/PDF file in the watch folder
docs = await fs.list_files(config['watch_folder'])
latest_doc = [d for d in docs if d.endswith(('.txt', '.pdf'))][-1]
content = await fs.read_file(latest_doc)
# Ask the local LLM for a concise summary
prompt = f"Provide a brief, three-bullet-point summary of this text: {content[:3000]}"
summary = await llm.generate(prompt)
# Send a notification with the summary
notifier = assistant.get_skill("skill-notifications")
await notifier.send(f"Document Summary", summary)
return f"Summarized {latest_doc}"
Handler 2: Scheduling and Reminders
This uses the scheduler skill to set future tasks.
@assistant.handler(pattern="remind me to|schedule a task")
async def handle_scheduling(context, request):
scheduler = assistant.get_skill("skill-scheduler")
# Use the LLM to extract task and time from the natural language request
llm = assistant.get_skill("skill-local-llm")
extraction_prompt = f"From this request: '{request}', extract the task description and time (e.g., 'in 2 hours', 'tomorrow at 9am'). Return as JSON."
extracted = await llm.generate(extraction_prompt, format="json")
# Schedule the task (pseudo-code, actual implementation uses cron parsing)
job_id = await scheduler.schedule_at(time=extracted['time'], task=extracted['task'])
return f"Reminder scheduled: {extracted['task']}"
Putting It All Together: The Daily Briefing
A hallmark of a great assistant is proactivity. Let’s create a scheduled task that runs every morning.
Add this to your agent’s startup or configuration to schedule a recurring job:
# Inside your agent's main setup
scheduler = assistant.get_skill("skill-scheduler")
await scheduler.schedule_cron("0 8 * * *", "generate_daily_briefing")
@assistant.handler(task="generate_daily_briefing")
async def daily_briefing(context):
llm = assistant.get_skill("skill-local-llm")
fs = assistant.get_skill("skill-filesystem")
# Gather context: today's schedule, recent documents
prompt = """
Based on the following context, create a friendly, concise daily briefing:
- It is morning.
- The user has a focus on productivity.
Suggest three priorities for the day and a motivational quote.
"""
briefing = await llm.generate(prompt)
notifier = assistant.get_skill("skill-notifications")
await notifier.send("Your Daily Briefing", briefing)
Running and Interacting with Your Agent
With the code in place, it’s time to bring your assistant to life.
- Start the OpenClaw runtime in your terminal:
claw start. - Register your agent:
claw agent register ./assistant_agent.py. - Your agent is now live. You can interact with it via the OpenClaw CLI:
claw request PersonalAssistant "Can you summarize my latest document?" - Observe its scheduled tasks, like the morning briefing, executing autonomously.
Conclusion: The Beginning of a Smarter, Private Workflow
Congratulations! You have successfully built a Personal Assistant Agent with the OpenClaw ecosystem that operates on a local-first AI principle. This is more than a script; it’s a persistent, reasoning entity that respects your privacy. You’ve seen how OpenClaw Core provides the skeleton, skills & plugins deliver the capabilities, and a local LLM offers the brain. The agent patterns you’ve implemented—from handlers to scheduled tasks—are just the foundation.
The true power lies in extension. Explore the OpenClaw community for integrations with email clients, note-taking apps, or smart home devices. Teach your agent new skills tailored to your unique needs. You are no longer just using software; you are cultivating a digital partner that evolves with you, securely and intelligently, right on your own machine.
